Copyright © 1997-2013
Robert W. Hasker

More on Arrays

• Ch. 9

Another Example: Roster

• Do:

          public static void main() 
          {
             // declare array of names - allow up to 100
             // need to know how many are actually on the roster
  
             // print names (one per line)
             ...
  
             // Read names from user:
             //   enter names until enter "END"
  
             // is "Jane Doe" in names?
  
             // is arbitrary person in names?
  
             // count number of "Jane Doe" entries in names list
          }
  

  • Write static method printNameList, use to print names in reverse

Making a class of the list of names

• Convert names to class Roster
• Extend RosterDriver (with bugs)
• Add operation to reverse list of names

Local vs. Instance Variables

• What happens if move definition of count to main top of class?
  • This makes it an "instance variable" - every instance of Roster has a count
  • Is this so bad? (add another test to RosterDriver)
  • Discuss impact of leaving it as a local variable
• Why worry about extra data in general?
  • illustrate physically
• Another example: Planet class from Exam 2
  • See solution; consider moving density value as instance variable
  • Current estimates are that there are "40 billion earth-sized planets with lukewarm temperatures" in the Milky Way

Alternative for loop syntax

• Consider processing temperatures:
  • Count temps below freezing, above 90, average high, average low, average average
• Alternative: for-each loop

          double[] temps = new double[30];
          ...
          int daysFreezing = 0;
          for(double dayTemp : temps)
             if ( dayTemp < 0.0 ) // celsius!
                daysFreezing++;
  

• With roster:

          for(String n : names)
             System.out.println(n);
  

• Notes:
  • here's a case where one-letter names can be ok
  • if need index, will need to write "regular" for loop

ArrayLists

• Ch. 10
• Consider Roster: what if have more than 100 students
• Suppose we store rosters for all of campus - lots of classes < 100 students
• Solution: use ArrayList
  • Similar to array: all elements have the same type
  • However, size of array can change easily
  • See http://docs.oracle.com/javase/7/docs/api/java/util/ArrayList.html for documentation (see also here)
  • Import java.util.ArrayList
• Rewrite Roster using array lists:
  • private ArrayList<String> names = new ArrayList<String>();
    • Angle brackets: what sort of item to store on the list
    • This type information is integral to the array list
  • Rewrite add()
  • Rewrite printNames
    • First with traditional for loop with .size and .get
    • Second with for-each loop
  • Rewrite occurrencesOf
  • Rewrite hasName using loop
    • Rewrite using contains
    • Examine ArrayList documentation for contains
    • Rewrite using indexOf - which is better?
  • Rewrite readNames
    • Use .clear()
  • Write code to convert all names to "proper" case
    • Use Character.toUpperCase(char ch), .toLowerCase(char ch)
• Declaring an array list of Planet objects
  • Based on

            public class Planet {
               private double habitableArea;
               private long population;
               public Planet(double habitableArea) {
                  this.habitableArea = habitableArea;
               }
               public long getPopulation() {
                  return population;
               }
               public double populationDensity() {
                  return population / habitableArea;
               }
               public boolean isSparse() {
                  return populationDensity() < 1.0;
               }
            }
    

  • Write code to count number of sparse planets
• Declaring a list of integers:

          ArrayList<Integer> rooms = new ArrayList<Integer>();
    

• ArrayLists vs. standard arrays:
  • Advantages of ArrayList:
    • Easy to increase size of ArrayList
    • Easy to write code to add something to the middle of an array list
  • Advantage of standard arrays:
    • Using [] is more natural than .get/.set
    • Standard array is more efficient for very high volumes, esp. with primitive types such as int and double

  Review

  • array of strings
  • common operations on the array
  • wrapping the array in a class
  • ArrayList