CS535 Object-Oriented Programming & Design
Fall Semester, 1996
Some Java Data Structures

1. References
   1. Classes by Type
   2. Classes by Package
   3. Containers
      1. Numeric Classes
      2. Vector
      3. Enumeration
      4. Vectors and Enumeration
      5. Stack
      6. Hashtable
   4. Some Useful Classes
      1. Random
      2. StringTokenizer
      3. BitSet
   5. Object

                                  Some Java Data Structures Slide # 1

                                  Some Java Data Structures Slide # 2

                                  Some Java Data Structures Slide # 3

                                  Some Java Data Structures Slide # 4

                                  Some Java Data Structures Slide # 5

                                  Some Java Data Structures Slide # 6

                                  Some Java Data Structures Slide # 7

template <class DataType>
class LinkedListNode
{
   DataType   theData;
   LinkedListNode* link;

   // more code here
}

                                  Some Java Data Structures Slide # 8

class LinkedListNode
{
   Object   theData;
   LinkedListNode link;
}

class Student
{
   String  name;
}

class UseLinkedListNode 
{
   public static void main( String args[] ) 
   {
      LinkedListNode  aNode  = new LinkedListNode();

      Student  junior  =  new Student();

      aNode.theData  =  junior;

      Student senior  =  (Student) aNode.theData;

      LinkedListNode  aNumNode  = new LinkedListNode();

      aNumNode.theData  =  5;  //compile error, 5 not an object

      aNode.link  =  aNumNode;

   }
}

                                  Some Java Data Structures Slide # 9

int, float, long, etc. are not objects

Classes Integer, Float, Double, Long are used to hold numbers

class UseLinkedListNode 
{
   public static void main( String args[] ) 
   {

      LinkedListNode  aNumNode  = new LinkedListNode();

      aNumNode.theData  = new Integer( 5 );

      int result  =  ((Integer) aNumNode.theData).intValue();

   }
}

                                  Some Java Data Structures Slide # 10

"The numeric classes provide an object wrapper for numeric data values and serves as a place for numeric-oriented operations. A wrapper is useful because most of Java's utility classes require the use of objects. Since int, long, float and double are not objects in Java, they need to be wrapped in a class instance."

                                  Some Java Data Structures Slide # 11

class NumericClassesExample 
{
   public static void main( String args[] ) 
   {
      Integer  height  =  new Integer( 10 );
      Integer  width  =  new Integer( 25 );
      Integer  depth  =  25;            // Compile error

      Integer area;
      area =  height * width;            // Compile error
      area =  new Integer(height.intValue() * width.intValue() );

      System.out.println(  area  );

      String  areaAsString  =  area.toString();

      int areaAsInt  =  area.intValue();
      long areaAsLong  =  area.longValue();

      System.out.println(  Integer.MAX_VALUE  );
   }
}

                                  Some Java Data Structures Slide # 12

                                  Some Java Data Structures Slide # 13

                                  Some Java Data Structures Slide # 14

import java.util.Vector;

class SampleVector 
{
   public static void main( String args[] ) 
   {
      Vector  growableList  =  new Vector( 2 );
      String  myName  =  "Roger";

      for ( int k = 0;  k < 5;  k++ )
         growableList.addElement(  new Integer( k )  );

      growableList.addElement(  myName   );
      growableList.addElement(  new SampleVector()  );

      growableList.setElementAt(  "Hi",  2  );
      System.out.println(  growableList.toString()  );

      String  convert  = (String) growableList.elementAt( 2 );

      growableList.removeElementAt(  5  );
      System.out.println(  growableList.indexOf(  myName  )  );
   }
}

-1

                                  Some Java Data Structures Slide # 15

import java.util.Vector;

class DoesNotWork 
{
   public static void main( String args[] ) 
   {
      Vector  empty  =  new Vector( 200 );
      empty.setElementAt( "No one home", 2 );
   }
}

        at DoesNotWork.main(All.java:8)

import java.util.Vector;

class ThisWorks 
{
   public static void main( String args[] ) 
   {
      Vector  fillFirst  =  new Vector( 200 );
      for ( int k = 0; k < 200; k++ )
         fillFirst.addElement( null );

      fillFirst.setElementAt( "Ok", 2 );
   }
}

                                  Some Java Data Structures Slide # 16

import java.util.Vector;

class ArrayAndObject 
{
   public static void main( String args[] ) 
   {
      Vector  test  =  new Vector( );

      int[]  grades  =  new  int[25];
      grades[10]  =  4;

      test.addElement( grades );

      int[]  recoveredGrades  =  ( int[] ) test.elementAt( 0 );

      System.out.println( recoveredGrades[ 10 ]  );

      recoveredGrades[ 2 ]  =  12;

      System.out.println( grades[ 2 ]  );
   }
}

                                  Some Java Data Structures Slide # 17

for (Enumeration e = v.elements() ; e.hasMoreElements() ;) 
{
   System.out.println(e.nextElement());
}

Returns true if the enumeration contains more elements; false if its empty.

Returns the next element of the enumeration.

                                  Some Java Data Structures Slide # 18

import java.util.*;

class SampleVector 
{
   public static void main( String args[] ) 
   {
      Vector  monthyOutput  =  new Vector( 2 );
      Random  dailyOutput  =  new Random();

      for ( int k = 0;  k < 5;  k++ )
         monthyOutput.addElement(  
                        new Integer(  dailyOutput.nextInt() ) );

      Enumeration  output  =  monthyOutput.elements();
      while ( output.hasMoreElements()   ) 
         System.out.print(  output.nextElement() + "\t" );
      System.out.println(   );

      output  =  monthyOutput.elements();
      int  totalOutput  =  0;
      while ( output.hasMoreElements() ) 
      {
         Integer  storedOutput =  (Integer) output.nextElement();
         totalOutput  +=  storedOutput.intValue();
      }

      System.out.println(  totalOutput   );
   }
}

                                  Some Java Data Structures Slide # 19

import  java.util.*;

class SampleStack 
{
   public static void main( String args[] ) 
   {
      Stack  test  =  new  Stack();

      test.push( new Integer( 5 ) );
      test.push( 5 );      //compile error
      test.push( new Student() );

      System.out.println( test.pop() );

      Student  fromStack  = (Student) test.pop();
   }
}

class Student
{
   public  String name;
}

empty() 
peek() 
pop() 
push(Object) 
search(Object) 

                                  Some Java Data Structures Slide # 20

                                  Some Java Data Structures Slide # 21

import  java.util.*;

class  Student {  String[]  courses;   }

class  SampleHash
{
   public static void main( String args[] )  {
      Student  csPerson  =  new  Student();
      Hashtable sample = new Hashtable();

      sample.put( "Roger", "Good Job" );
      sample.put( "Andrew", "Better Job" );
      sample.put( csPerson,  new Integer( 12 ) );

      Stack  ofCards  =  new  Stack();
      sample.put(  "Deck",  ofCards );

      String  myPerformance  = (String) sample.get( "Roger" );
      Enumeration  keys  =  sample.keys();

      while  ( keys.hasMoreElements()  )
      {
         System.out.print(  keys.nextElement()  +  "\t" );
      }
      System.out.println();

      Enumeration  elements  =  sample.elements();

      while  ( elements.hasMoreElements()  )
      {
         System.out.print(  elements.nextElement()  +  "\t" );
      }
      System.out.println();
   }
}

                                  Some Java Data Structures Slide # 22

                                  Some Java Data Structures Slide # 23

import java.util.Random;

class  SampleRandom
{
   public  static  void  main( String  args[]  )
   {
      Random  data   =  new Random();
      System.out.println(  data.nextDouble()  );
      System.out.println(  data.nextFloat()  );
      System.out.println(  data.nextGaussian()  );
      System.out.println(  data.nextLong()  );
      System.out.println(  data.nextDouble()  );
   }
}

                                  Some Java Data Structures Slide # 24

import java.util.*;
class  Parse
{
   public  static  void  main( String  args[]  )
   {
      String  message  =  "this is a test";
      StringTokenizer  parser  =  new  StringTokenizer( message );
      
      System.out.println(  parser.countTokens()  ); 
      printTokens(  parser  );

      message  =  "Hi,Mom;this.is a funny, message";
      parser  =  new  StringTokenizer( message, ",;." );
      printTokens(  parser  );

      parser  =  new  StringTokenizer( message, ",;.", true );
      printTokens(  parser  );
   }

   static void printTokens(  StringTokenizer  input)
   {
      while (input.hasMoreTokens()) 
      {
         System.out.println(  input.nextToken()  );
      }
   }
}

                                  Some Java Data Structures Slide # 25

Constructs a StringTokenizer on the specified String, using the specified delimiter set. If boolean is true, return delimiters with tokens.

Constructs a StringTokenizer on the specified String, using the specified delimiter set.

Constructs a StringTokenizer on the specified String, using the default delimiter set (which is " \t\n\r").

                                  Some Java Data Structures Slide # 26

Creates an empty set.

Creates an empty set with the specified size.

                                  Some Java Data Structures Slide # 27

Creates a clone of the object.

Compares two Objects for equality.

Code to perform when this object is garbage collected.

Returns the Class of this Object.

Returns a hashcode for this Object.

Notifies a single waiting thread on a change in condition of another thread.

Notifies all of the threads waiting for a condition to change.

Returns a String that represents the value of this Object.

Causes a thread to wait until it is notified or the specified timeout expires.

More accurate wait.

Causes a thread to wait forever until it is notified.