ITEC 120 2008spring ibarland, jdymacek

home—info—archive—exams—lectures—labs—hws
Recipe—Laws—lies—syntax—java.lang docs—java.util docs

lect13c
arrays; main
cont.

Arrays vs Lists

• Arrays hold a fixed number of items, whereas lists can hold any number of items.

reminder: Sometimes people confuse the variable referring to the list, with the loop-variable which refers to an element of the list. They are very different!

You don't confuse an apple with a bag-of-apples; you don't confuse a bus-passenger with a bus; so similarly don't confuse an item with a collection-of-items.

• To access elements of an array by index, use […]; for lists, use the get(…) method. That is, myArray[3] vs. myList.get(3). While the array syntax is shorter, it's a bit confusing to introduce a whole new type of punctuation which is really just a method-call in disguise.
• Both arrays and lists let you replace the item at a certain index: myArray[3] = newVal; (see powerpoint/book), vs. myList.set( 3, newVal );. Thus the square-bracket notation can mean either get or set, depending on context. (Again, this is a trade-off between shorter notation, and having brand-new notation which we didn't have to worry about before.)
• In an array, there is no way to automatically add or remove a new element in the middle, and have all the other elements slide over to fill/create the gap. Lists have versions of remove and add which do this, taking an index as (one of) their arguments.
• When calling a constructor for type int[], you must provide one argument: the size of the array (which is then forever fixed). But instead of writing new int[](100), you write new int[100].
  In fact, this is the first time when the declared-type and the new don't quite match up: int[] data = new int[100];.
• To get the size of a list, you use the method size(). To get the size of an array, you use the field length: That is, myList.size() vs. myArray.length. (Note the lack of parentheses, since we're accessing a field directly, not calling a getter-method).
• In both arrays and lists with N elements, valid indices are in the range [0,N) (that is, N-1 is the largest valid index). Far and away the most common runtime beginner-mistake with arrays and lists is “index out of bounds exception”, from trying to use N (or occasionally -1) as an index.
• Arrays can hold primitive values, whereas lists only contain actual objects. (This drawback is ameliorated by the wrapper classes and auto-boxing, as we saw.)
• The built-in toString for arrays is pathetic. Instead use the static method static java.util.Arrays.toString(Type[]).
  Note the ‘s’ on the end of ‘Arrays’. (The class java.util.Arrays is a utility class — i.e. full of static methods — whose purpose is to provide the methods which should have been built-in to the first version¹of Java.
  Don't get confused by documentation for similarly-named classes java.lang.reflect.Array or java.sql.Array, yikes!

In practice, lists prove much more flexible than arrays: it's much more common to have data of the form “0 or more data” than “exactly 100 data”.²

main

BlueJ has a rich interface for interacting with Java programs: you can call any method of any class. Most IDEs have a much more limited interface: They let you choose a certain class, but then you can only call one specific (static) method of that class:

/**
 * Write a description of class Acronym here.
 * 
 * @author (your name) 
 * @version (a version number or a date)
 */
public class Acronym {

  /** A test driver which makes an acronym from its input,
   * printing the results to SYstem.out.
   * @param args The words of input.  Each String must be non-empty (and non-null).
   */
  public static void main( String[] args ) {
    System.out.println( "A " + args.length + "-letter acronym for "
                      + Acronym.wordsToString( args, " ", "\"", "\"" )
                      + " is "
                      + "\"" + Acronym.acronym(args) + "\""
                      + "." );
  }

  /* Return a single string, concatenating each word in an array of Strings.
   * @param words the individual Strings.
   * @param between What to put in between each word; usually " " or ", ".
   * @param before What to start the answer with; often "".
   * @param after What to finish the answer with; often "".
   */ 
  public static String wordsToString( String[] words, String between, String before, String after ) {
    String innards = "";
    if (words.length > 0) {
      innards += words[0];
      }
    for ( int i=1;  i < words.length;  ++i ) {
      innards += between + words[i];
      }
    return before + innards + after;
    }
    
  /** Return an acronym for an array-of-words, each letter capitalized.
   * and separated by a ".".
   * @param words An array of single words.  Each String must be non-empty.
   * @return an acronym for an array-of-words, each letter capitalized.
   */
  public static String acronym( String[] words ) {
    String asf = "";   // "acronym so far"
    for ( int i=0;  i < words.length;  ++i ) {
      asf += words[i].toUpperCase().charAt(0) + ".";
      }
    return asf;
    }
      
      
  }

java Acronym hello, world

Review and different perspective

• Fixed size -- when the array is created with "new", its size is set in stone
• instead of "new LinkedList<String>()", a new syntax: "new String[50]"
• Instead of "l.get(7)", a new syntax: a[7]
• instead of "l.add("meow", 8)", a new syntax for the same thing: a[8] = "meow"
• instead of "l.add(..)", … nothing! (You can't add new things to the end.)
• Instead of "l.size()", a new syntax: a.length

Why a new data structure, if a List can already do everything an array can, and yet the array is limited to a fixed size?

• Shallow answer: They gave it a special syntax which saves some typing once you've learned it.
• Good answer: When we want to add/remove from the collection as time passes, use a list.
• Best answer: sometimes the physical world corresponds to fixed-size collections, and the 0th law of programming tells us that our data should reflect what we're trying to model.

  class Motel { String name; String address; int numRooms = 57; Room[] rooms = new Room[this.numRooms]; //... }

• Subtle observation: For some data, the exact index of the data is also part of the information. For instance, consider the high temperature for each day in January. double[] is an appropriate type:

  double[] temps = new double[31]; /* Here, have code which initializes all 31 elements of the array */ temps[5] // Knowing that the high occured on Jan.06 is part of the data.

If a list is a line-up bag of suspects (er, objects), then an array is a bus of objects.

When creating an array, initialize all the fields immediately. If you can't, that's a good indication that you want to use a List instead.

(Note that when you add into the middle of a list, it changes what index each later object has. With an array, you can't add into the middle, so that isn't an issue. You can only overwrite the existing contents of a particular bus-seat-#.)

double[] data;
data = new double[500];
java.util.Random r = new java.util.Random();

// Initialize array contents with random numbers in [0,1).
for (int i = 0;  i < double.length;  ++i ) {
  data[i] = r.nextDouble();
  }


// Find the average:
double sumSoFar = 0.0;

for ( double d : data ) {
  sumSoFar += d;
  }

double average = sumSoFar / data.length; 
// N.B. if data.length is 0, then floating-division gives Double.NaN.

home—info—archive—exams—lectures—labs—hws
Recipe—Laws—lies—syntax—java.lang docs—java.util docs

©2008, Ian Barland, Radford University Last modified 2008.Apr.14 (Mon)

Please mail any suggestions (incl. typos, broken links) to iba�rlandrad�ford.edu