CSC/ECE 517 Summer 2008/wiki1 6 arraysandhashes

Arrays and Hashes

Arrays and hashes are built into Ruby. Arrays, of course, are built into Java too, but hashes are only available through library classes. Compare Ruby and Java arrays, as well as hashes. Write equivalent code sequences in the two languages that illustrate the convenience of programming these constructs in both languages.

http://java.sun.com/javase/6/docs/api/ http://java.sun.com/docs/books/jls/

Arrays

While Java and Ruby both provide built-in support for arrays, they differ in the operations that can be performed on them. Arrays in both languages are objects. In Java, arrays are defined by the

Comparison of Common Operations in Ruby and Java

In this section, we provide a side-by-side comparison of common operations in Ruby and compare and contrast them with Java.

Creating an Array

One way to create an array in Ruby is to to use the new class method:

 planets = Array.new(8)

This creates an empty array named months. This is similar to the Java initialization:

 String[] planets = new String[8]

Arrays can also be initialized to values in both Java and Ruby. For example, we can initialize an arrays of planets by entering the following in Java follows, noting the use of curly braces in array initialization:

 String[] planets = {"Mercury", "Venus", "Earth", "Mars", "Jupiter", 
        "Saturn", "Uranus", "Neptune" }

Some people consider Pluto a planet, but is this arguable. In Ruby, we can perform a similar operation, instead using square brackets:

 planets = [ "Mercury", "Venus", "Earth", "Mars", "Jupiter",
        "Saturn", "Uranus", "Neptune" ]

The similarities between Java and Ruby with respect to array creation end here. Ruby provides additional convenience operators on array creation that Java lacks.

For example, Ruby provides an additional way to define an array of strings using the %w notation. It assumes that all elements are strings, but can save typing:

 planets = %w[ Mercury Venus Earth Mars Jupiter Saturn Uranus Neptune ]

An array can also be created by allowing the initialization of a default value to each element in the array:

 planets = Array.new(8, "planets")

Furthermore, since Ruby offers range capabilities, one can initialize an array using ranges:

 digits = Array(1..x)

The above Ruby code creates an array of digits with elements from 1 through 100. The equivalent Java code is far more cumbersome and potentially error-prone, as the programmer must micromanage the details of array indexing:

  for (int j = 1; j <= x; j++)
    digits[j - 1] = j;

Accessing Array Elements

Elements in Java and Ruby are accessed in much the same way, though Ruby offers a few additional methods for accessing elements of arrays. In Java, one could access the element "Venus" of the planets array as:

 planets[0];

In Ruby, the operation is much the same:

 planets[0]

In addition, Ruby allows one to index using negative indices, so that:

 planets[-1]

returns "Neptune". Finally, Ruby allows the first and last methods to easily get the first and last elements of an array.

Ruby provides several methods, which, in combination with the range operator, provide an elegant way to obtain sub-arrays of an array. In Ruby, for example, we can generate a sub array of the first three elements after "Mercury" of the array with:

 some_planets = planets[1..3]

Such tasks can also be accomplished in Java to a certain extent, but require the use of the java.util.Arrays package. The equivalent Java code for the simple operation above, for instance, would be:

 String[] somePlanets = java.util.Arrays.copyOfRange(planets, 1, 4)

Note that the Java method is a half-open interval.

Inserting, Removing and Changing Elements

Most static languages, including Java, require you to increase the size of an array in order to add elements to it. In Java, one must create a new array of larger size and copy the elements into the newly created array before adding the new element. While Java provides both System.arraycopy, and convenience methods in java.util.Arrays, the resulting Java code is far from transparent.

References

Back to the assignment page