Review: the implementation of the IntegerStack

  • Previously, we implement an IntegerStack class with an array of Integer: 

       public class IntegerStack implements Stack<Integer>
   {
       private Integer[] item;
       private int stackTop;

       public IntegerStack(int N)
       {
           item = new Integer[N]; // Create an array of Integer objects
           stackTop = 0;
       }

       ....
   }

Implementing a StringStack

  • If we want to implement a stack of String objects, we must define another class: 

       public class StringStack implements Stack<String>
   {
       private String[] item;
       private int stackTop;

       public StringStack(int N)
       {
           item = new String[N]; // Create an array of String objects
           stackTop = 0;
       }

       ....
   }

DEMO: demo/09-stack/01-array/StringStack.java + Demo2.java

Implementing a generic stack   (i.e.: a parameterized stack)

  • Can't we implement a generic stack with a parameterized array type, like this???: 

       public class ArrayStack<T> implements Stack<T>
   {
       private T[] item;
       private int stackTop;

       public ArrayStack(int N) 
       {
           item = new T[N]; // Create an array of T objects
           stackTop = 0;
       }

       ....
   }

Implementing a generic stack   (i.e.: a parameterized stack)

  • Unfortunately, Java does not allowed the instantiation of a generic array: 

       public class ArrayStack<T> implements Stack<T>
   {
       private T[] item;
       private int stackTop;

       public ArrayStack(int N)
       {
           item = new T[N]; // Create an array of T objects
           stackTop = 0;
       }

       ....
   }

    Error message: 

    ArrayStack.java:12: error: generic array creation
        item = new T[N];  // Create an array of T objects

  • The reason why is outside the scope of CS171 - you can read more here:

DEMO: demo/09-stack/04-gen-array/ArrayStack.java -- javac ArrayStack.java

Implementing a generic stack   (i.e.: a parameterized stack)

  • Fortunately, there is a simple hack to work around this Java restriction: 

       public class ArrayStack<T> implements Stack<T>
   {
       private T[] item;
       private int stackTop;

       public ArrayStack(int N)
       {
           item = (T[]) new Object[N]; // Create an array of Object objects
           stackTop = 0;
       }

       ....
   }

    Warning message: 

    ArrayStack.java:12: warning: [unchecked] unchecked cast
        item = (T[]) new Object[N];  // Create an array of Object  objects
                     ^
  required: T[]
  found:    Object[]

  • Warning messages are not fatal errors and our Java program will run !

DEMO: demo/09-stack/05-gen-array-hack/ArrayStack.java -- javac ArrayStack.java

Implementing a generic stack   (i.e.: a parameterized stack)

  • The push() method (and all the other methods) using a generic array: 

       public class ArrayStack<T> implements Stack<T>
   {
       private T[] item;
       private int stackTop;

       ....

       public void push(T e)   // Pushes elem e on the stack
       {
           if ( isFull () )
           {
               System.out.println("Full");
               return ;
           }

           item[ stackTop ] = e;
           stackTop++;
       }

   }

  • Summary: in order to use a generic array, we only need to change the data type to a parameterized type

DEMO: demo/09-stack/06-gen-array/ArrayStack.java

How to define an stack of Integer with the generic stack

  • We can create a stack of Integer by using Integer as parameter when defining a generic ArrayStack variable: 

        public static void main(String[] args)
    {
        ArrayStack<Integer> s = new ArrayStack<>(5);

        s.pop();
        s.push(1);
        s.push(2);
        s.push(3);
        s.push(4);
        System.out.println( s );
        System.out.println( s.pop() );
        System.out.println( s );
        System.out.println( s.pop() );
        System.out.println( s );
        System.out.println( s.pop() );
        System.out.println( s );
        System.out.println( s.pop() );
        System.out.println( s );
    }

DEMO: demo/09-stack/06-gen-array/Demo.java

How to define an stack of String with the generic stack

  • We can create a stack of String by using String as parameter when defining a generic ArrayStack variable: 

        public static void main(String[] args)
    {
        ArrayStack<String> s = new ArrayStack<>(5);

        s.pop();
        s.push("not");
        s.push("or");
        s.push("be");
        s.push("to");
        System.out.println( s );
        System.out.println( s.pop() );
        System.out.println( s );
        System.out.println( s.pop() );
        System.out.println( s );
        System.out.println( s.pop() );
        System.out.println( s );
        System.out.println( s.pop() );
        System.out.println( s );
    }

DEMO: demo/09-stack/06-gen-array/Demo2.java