Module 6: Data Structures

Thus, the following would work:

    // Create a new list object.
    GenericList L = new GenericList ();

    // Let's 10 random numbers between 1 and 100
    for (int i=1; i <= 10; i++) {
      int k = (int) UniformRandom.uniform (1,100);
      Integer K = new Integer (k);  // Integer object.
      L.addData (k);
    }

    // ... print etc ...

What is interesting is that the following will also work:

    // Create a new list object.
    GenericList L = new GenericList ();

    // Let's 10 random numbers between 1 and 100
    for (int i=1; i <= 10; i++) {
      int k = (int) UniformRandom.uniform (1,100);
      L.addData (k);    // Automatic conversion to object equivalent (autoboxing)
    }

    // ... print etc ...

NOTE: this autoboxing feature was not available until JDK 1.5.

Linked lists - separate files

One final note on linked lists: to be really useful, the generic linked list ought to be in a separate file by itself, such as the file GenericList.java:

class ListItem {

  // ...

}


// Linked list class - also a dynamic class.

public class GenericList {

  // ...

} 
  

Then, this class can be used elsewhere, say in a file called GenericListTest.java:

public class GenericListTest {

  public static void main (String[] argv)
  {
    // Create a new list object.
    GenericList L = new GenericList ();

    // Let's 10 random numbers between 1 and 100
    for (int i=1; i <= 10; i++) {
      int k = (int) UniformRandom.uniform (1L,100L);
      Integer K = new Integer (k);  // Integer object.
      L.addData (K);
    }

    // Enumerate items.
    L.startEnumeration();
    while (L.hasMoreElements()) {
      Integer K = (Integer) L.getNextElement();

      // Integer has overridden toString()
      System.out.println (K); 
    }

  }

}
 

Java Generics

While the flexibility of inserting any object is useful, it can also lead to problems, e.g., (source file)

class ListItem {
  // ... as before ...
}

class LinkedList {
  // ... as before ...
} 


public class ListProblem {

  public static void main (String[] argv)
  {
    LinkedList L = new LinkedList ();

    // Add stuff the list was originally designed for:
    L.addData (new Integer(5));
    L.addData (new Integer(6));

    // Does this belong?
    L.addData (new String("Blah-blah"));

    // An application that fails:
    L.startEnumeration ();
    int sum = 0;
    while ( L.hasMoreElements() ) {
        Integer I = (Integer) L.getNextElement ();
        sum = sum + I;
    }
    System.out.println ("sum=" + sum);

  }

} 

To address this problem, Java 1.5 added generics, a new language feature.

First, let's look at an example of using generics (from the Java library):

// Need this for java.util.ArrayList
import java.util.*;

public class ListProblem2 {

  public static void main (String[] argv)
  {
    // NOTE: this a data-structure in the Java library.
    ArrayList<Integer> L = new ArrayList<Integer> ();

    // Add stuff the list was originally designed for:
    L.add (new Integer(5));
    L.add (new Integer(6));

    // This does not compile:
    L.add (new String("Blah-blah"));

  }

} 
    

Next, let's see if we can write our own such generic list:

• The syntax is a little strange at first.

• Let's first look at the class ListItem first: (source file)

  class ListItem<E> {
  
    E data = null;          // Note: the type is declared as E
    ListItem next = null;
  
    // Constructor: notice the type - same identifier as the class generic.
    public ListItem (E obj)
    {
      data = obj;  next = null;
    }
    
    // Accessor:  notice the return type.
    public E getData () 
    {
      return data;
    }
  }
      

• What do we learn so far?
  • It is possible to associate a generic type identifier (here we chose the name E) with a class (ListItem in this case).
  • The type-identifier can be used as a type in variable declarations, method parameters etc.

• Next, let's examine the code for the list itself: (source file)

  class LinkedList<E> {       // Again, a generic-type identifier
  
    ListItem front = null;
    ListItem rear = null;
    int numItems = 0;      
  
     // Notice the type identifier as parameter:
  
    public void addData (E obj)
    {
      if (front == null) {
        front = new ListItem<E> (obj);      // Example 1 of using the type
        rear = front;
      }
      else {
        rear.next = new ListItem<E> (obj);
        rear = rear.next;
      }
      numItems++;
    }
  
    public void printList ()
    {
       // ...
    }
  
  }
      

• Finally, let's use this in main(): (source file)

  class TestGeneric {
  
    public static void main (String[] argv)
    {
      // Notice how the actual type is provided:
      LinkedList<Person> L = new LinkedList<Person> ();
  
      // Create a Person instances and add it to list.
      L.addData (new Person ("Terminator", "444-43-4343"));
      L.addData (new Person ("Rambo", "555-54-5454"));
      L.addData (new Person ("James Bond", "666-65-6565"));
      L.addData (new Person ("Bruce Lee", "777-76-7676"));
  
      // Print contents.
      L.printList();
  
      // This won't compile:
      L.addData (new String("blah-blah"));
    }
  
  }
      

Finally, let's look at a special type of for-loop for such data structures: (source file)

// Need this for java.util.ArrayList.
import java.util.*;

public class TestGeneric2 {

  public static void main (String[] argv)
  {
    // This is a data-structure in the Java library:
    ArrayList<Integer> L = new ArrayList<Integer> ();

    // Add stuff the list was originally designed for:
    L.add (new Integer(5));
    L.add (new Integer(6));
    L.add (new Integer(7));
    L.add (new Integer(8));

    // New for loop:
    for (Integer I: L) {
        System.out.println (I);
    }

    // An interesting variant that uses autoboxing:
    for (int i: L) {
        System.out.println (i);
    }
    
  }

} 
  

• The answer is: yes, but ...

• To have your data structure be used in a for-each loop, the data structure needs to implement the Iterable interface.

• We will cover interfaces in Module 7.

Built-in data structures in the library

Java provides several built-in data structures in its vast library. They are all in the package java.util. For example:

• Stack - a stack object which can store instances of Object.
• Hashtable - a hashtable that stores Object's and let's you define a key for retrieval.
• Properties - a data structure like a hashtable that lets you store property strings and values conveniently.
• Vector - a class that implements an expandable "array" to contain any Object.
• BitSet - a space-compact implementation of a set of bits, with methods to set and read particular bits.

We will next look at some of these data structures.

Built-in data structures - java.util.Stack

We have seen how to exploit the all-super superclass Object to store any user-defined object in a list.

The same idea applies to the Stack class in java.util.

An example shows you how: (source file)

// Need to import from java.util.

import java.util.*;


// An object to use in the stack:

class Person {

  String name;
  String ssn;

  // Constructor.
  public Person (String nameInit, String ssnInit)
  {
    name = nameInit;  ssn = ssnInit;
  }

  // Override toString()
  public String toString ()
  {
    return "Person: name=" + name + ", ssn=" + ssn;
  }

} // End of class "Person"


public class TestStack {

  public static void main (String[] argv)
  {
    // Create a new stack object.
    Stack S = new Stack ();

    // Create a Person instance and add it to the Stack.
    S.push (new Person ("Terminator", "444-43-4343"));
    S.push (new Person ("Rambo", "555-54-5454"));
    S.push (new Person ("James Bond", "666-65-6565"));
    S.push (new Person ("Bruce Lee", "777-76-7676"));

    // Pop the top of the stack. Note the cast needed.
    Person p = (Person) S.pop();
    System.out.println (p);

    // Look at the top without popping. Note the cast needed.
    p = (Person) S.peek();
    System.out.println (p);

  }

} // End of class "TestStack"
 

Note:

• An instance of Stack needs to be created before use.
• Stack supports the usual push and pop methods.
• Stack also supports the peek method, which lets you look at the top without popping it.
• Stack accepts Object's - automatic casting is done for a push.

    S.push (new Person ("James Bond", "666-65-6565"));
   

• However, you must explicitly cast to the appropriate class when you pop or peek

    Person p = (Person) S.pop();
   

public class TestStack2 {

  public static void main (String[] argv)
  {
    // Create a new stack object, this time specifying the type.
    Stack<Person> S = new Stack<Person> ();

    // Create a Person instance and add it to the Stack.
    S.push (new Person ("Terminator", "444-43-4343"));
    S.push (new Person ("Rambo", "555-54-5454"));
    S.push (new Person ("James Bond", "666-65-6565"));
    S.push (new Person ("Bruce Lee", "777-76-7676"));

    // Pop the top of the stack. NOTE: no cast needed.
    Person p = S.pop();
    System.out.println (p);

    // Look at the top without popping. Again, no cast needed.
    p = S.peek();
    System.out.println (p);

  }

} 

Note:

• We have used the syntax associated with generic types to declare a stack specifically for Person instances.

      Stack<Person> S = new Stack<Person> ();
      

• In this case, no casting is needed.

• In our examples, we will use both variations (with and without generics).

• Examples without generics will result in compiler warnings.

Built-in data structures - the Hashtable class

The package java.util provides a simple hashtable that lets you:

• associate a key with an object;
• store an object;
• retrieve an object by providing the key;

The key itself can be an object.

Consider a simple example with strings: (source file)

import java.util.*;

public class TestHashtable {

  public static void main (String[] argv)
  {
    Hashtable h = new Hashtable ();

    // Insert a string and a key.
    h.put ("Ali", "Anorexic Ali");
    h.put ("Bill", "Bulimic Bill");
    h.put ("Chen", "Cadaverous Chen");
    h.put ("Dave", "Dyspeptic Dave");

    // To retrieve, pass a key:
    String d = (String) h.get ("Dave");
    System.out.println (d);  // Prints "Dyspeptic Dave"
  }

}
 

Note:

• An instance of Hashtable needs to be created before use.
  
  
• The put function has the following signature:

  public Object put (Object key, Object obj)
   

Thus, in the call

    h.put ("Dave", "Dyspeptic Dave");
   

we pass the key (the string "Dave") first and then the object that needs to be stored (the string "Dyspeptic Dave").



• The definition of get is:

    public Object get (Object key)
    

and thus we pass the key ("Dave") as parameter

    String d = (String) h.get ("Dave");
    

and get an Object back. This needs to be cast back to a String.

public class TestHashtable2 {

  public static void main (String[] argv)
  {
    Hashtable h = new Hashtable ();

    // Insert a string and a key.
    h.put ("Ali", "Anorexic Ali");
    h.put ("Bill", "Bulimic Bill");
    h.put ("Chen", "Cadaverous Chen");
    h.put ("Dave", "Dyspeptic Dave");

    // Only one value can be stored for a particular key.
    // Old value with same key is deleted.
    h.put ("Dave", "Duplicitous Dave");
    String d = (String) h.get ("Dave");
    System.out.println (d);  // Prints "Duplicitous Dave"

    // You can get back the old value at the 
    // time of insertion.
    String c = (String) h.put ("Bill", "Blasphemous Bill");
    System.out.println (c);  // Prints "Bulimic Bill"

    // The return value is null otherwise.
    String e = (String) h.put ("Ed", "Egregious Ed");
    System.out.println (e);  // Prints "null".
  }

}
 

// A class to store in the hashtable.

class Person {

  // Instance data.
  String name;
  String nickname;

  // Constructor.
  public Person (String nameInit, String nickInit)
  {
    name = nameInit;  nickname = nickInit;
  }

  // Accessor for name: we will use it as a key:
  public String getName ()
  {
    return name;
  }

  // Overrides Object's toString()
  public String toString()
  {
    return "Person: name=" + name + ", nickname=" + nickname;
  }

} // End of class "Person"



public class TestHashtable3 {

  public static void insert (Hashtable h, Person p)
  {
    Person p2 = (Person) h.put (p.getName(), p);
    if (p2 != null) 
      System.out.println ("Warning: " + p + " replaced " + p2);
  }

  public static void main (String[] argv)
  {
    Hashtable h = new Hashtable ();

    insert (h, new Person ("Franco", "Flatulent Franco"));
    insert (h, new Person ("Gita", "Gluttonous Gita"));
    insert (h, new Person ("Heinrich", "Hemorrhaging Heinrich"));

    // When retrieving you get the whole object back.
    Person p = (Person) h.get ("Heinrich");
    System.out.println (p);  
  }

}
 

class NameAge {
  String name;
  int age;
  // Constructor.
  public NameAge (String nameInit, int ageInit)
  {
    name = nameInit;  age = ageInit;
  }
  // Override toString()
  public String toString ()
  {
    return "Name=" + name + ", Age=" + age;
  }

  // Overrides Object's hashCode()
  public int hashCode()
  {
    // Shift name's hashCode left by 8 bits.
    return 256*name.hashCode() + age;
  }

  // Overrides Object's equals()
  public boolean equals (Object obj)
  {
    NameAge n = (NameAge) obj;
    if ( (name.equals(n.name)) && (age==n.age) )
      return true;
    else
      return false;
  }

}

class Person {

  // Instance data.
  NameAge na;
  String nickname;

  // Constructor.
  public Person (String nameInit, int ageInit, String nickInit)
  {
    na = new NameAge (nameInit, ageInit);
    nickname = nickInit;
  }

  // Overrides Object's toString()
  public String toString()
  {
    return "Person: " + na + ", nickname=" + nickname;
  }

  // Accessor for NameAge so that it can be used as key.
  public NameAge getNameage ()
  {
    return na;
  }

}


public class TestHashtable4 {

  public static void insert (Hashtable h, Person p)
  {
    Person p2 = (Person) h.put (p.getNameage(), p);
    if (p2 != null) 
      System.out.println ("Warning: " + p + " replaced " + p2);
  }

  public static void main (String[] argv)
  {
    Hashtable h = new Hashtable ();

    insert (h, new Person ("Franco", 25, "Flatulent Franco"));
    insert (h, new Person ("Gita", 18, "Gluttonous Gita"));
    insert (h, new Person ("Heinrich", 43, "Hemorrhaging Heinrich"));

    // When retrieving you get the whole object back.
    Person p = (Person) h.get (new NameAge ("Heinrich", 43));
    System.out.println (p);  
  }

}
 

 Circle1.center.x=100
 Circle1.center.y=250
 Circle1.radius=30
 Circle2.center.x=60
 Circle2.center.y=90
 Circle2.radius=10
 

public class TestProperties {

  public static void main (String[] argv)
  {
    // Create a new Properties object.
    Properties p = new Properties();

    // Insert some properties.
    p.put ("Circle1.center.x", "100");
    p.put ("Circle1.center.y", "250");
    p.put ("Circle1.radius", "30");

    // Note: both the property name and 
    // the value are String's.

    p.put ("Circle2.center.x", "60");
    p.put ("Circle2.center.y", "90");
    p.put ("Circle2.radius", "10");

    p.put ("Square1.topleft.x", "300");
    p.put ("Square1.topleft.y", "400");
    p.put ("Square1.side", "40");

    // Print all the properties to the screen.
    p.save (System.out, "Geometric objects");

    // Write the properties to text file called "geodata"
    try {
      FileOutputStream f = new FileOutputStream ("geodata");
      p.save (f, "Geometric objects");
    }
    catch (IOException e)
    {
      System.out.println ("Cannot open file");
      System.exit(0);
    }

  } // "main"

} // End of class "TestProperties"
 

public class TestProperties2 {

  public static void main (String[] argv)
  {
    // Create an instance of a Properties class.
    Properties p = new Properties();

    // Read from a text file with properties ("geodata").
    try {
      FileInputStream f = new FileInputStream ("geodata");
      // Use the "load" method in a Properties object.
      p.load (f);
    }
    catch (IOException e)
    {
      System.out.println ("Cannot open file");
      System.exit(0);
    }

    // Retrieve property values.
    String cx = p.getProperty ("Circle1.center.x");
    String cy = p.getProperty ("Circle1.center.y");
    String r =  p.getProperty ("Circle1.radius");

    System.out.println ("Circle1: cx=" + cx + ", cy=" + cy 
                        + ", r=" + r);

  }

}
 

public class TestProperties3 {

  public static void main (String[] argv)
  {
    Properties p = new Properties();

    // Read properties from the file "geodata".
    try {
      FileInputStream f = new FileInputStream ("geodata");
      p.load (f);
    }
    catch (IOException e)
    {
      System.out.println ("Cannot open file");
      System.exit(0);
    }

    // The entire list of property NAMES can be enumerated.
    System.out.println ("Property Names: ");
    Enumeration e = p.propertyNames();
    while (e.hasMoreElements()) {
      System.out.println (e.nextElement());
    }

  } // "main"

}
 

  public Properties getProperties()
  

public class SystemProperties {

  public static void main (String[] argv)
  {
    // The System class has a static function that
    // returns a Properties object:
    Properties p = System.getProperties();

    // The entire list of properties can be enumerated.
    Enumeration e = p.propertyNames();
    while (e.hasMoreElements()) {
      String propName = (String) e.nextElement();
      String propVal = p.getProperty (propName);
      System.out.println (propName + "=" + propVal);
    }
  }

}