Status check

• Quiz 06 (due Friday)
• A06a and A06b
• jar files

Queue ADT

• Remember: ADTs defined in terms of behavior
• Queue: like waiting in line
• FIFO: first-in, first-out

Queue Behavior

Method names not as standardized as for stack

• add / enqueue / offer(E item)
  -- adds item to back of queue
• remove / dequeue / poll()
  -- removes and returns item at front of queue
• get / peek()
  -- returns item at front of queue
• size()
  -- returns number of items in queue

Queue Use

Queue<Integer> q = new Queue<Integer>();
q.offer(4);
q.offer(7);
q.offer(9);
System.out.println(q.size());  // 3
System.out.println(q.peek());  // 4
q.poll();                     
System.out.println(q.poll());  // 7

Implementation options

• array
• nodes (linked list)
• other ADT: ArrayList, Stacks, etc.

Array-based Queue

• As per stack, but with two ends: front, back
• However, to fit n items in an array of size n, each addition requires a shift: O(n)
• Solution to get O(1): circular queue
• Secret: modular arirthmetic
  • increment: (back + 1) % array.length
  • front == back means empty... or full?
    • Solution: track size, or else keep an empty cell.

Array-based Queue Implementation

public class Queue<E> {

  private static final int CAPACITY = 5;

  private E[] items;
  private int front;  //points at first item
  private int back;   //first blank spot

  public Queue() {
    //use one extra cell so never full, so front == back always means empty
    @SuppressWarnings("unchecked")  //more on this later...
    E[] array = (E[]) new Object[CAPACITY + 1];
    items = array;
    back = 0;
    front = 0;
  }

  public void offer(E item) {
    if (this.size() == CAPACITY) {
      //Implementation-level restriction: would be nice to avoid this...
      throw new IllegalStateException("Queue is full.");
    }
    this.items[back] = item;
    this.back = (this.back + 1) % items.length;
  }

  public E peek() {
    if (this.size() == 0) {
      throw new IllegalStateException("Queue is empty.");
    }
    return this.items[front];
  }

  public E poll() {
    E item = this.peek();  //throws exception if empty
    this.front = (this.front + 1) % items.length;
    return item;
  }

  public int size() {
    return (this.back + items.length - this.front) % items.length;
  }
}

Big-Os?

Array-based Queue - Growth

• Growing the array--as we should have done here--requires a bit of attention:
• Create new array
• Then could just reset content positions (so front == 0 again after copy)
• Else need to do some copying from 0 to back, if back is less than front

Node-based Queue implementation

• Use front and back references
• Links go from front to back.
• Both null when queue is empty
• Requires a bit of tweaking to handle this empty case
• (Implementation: for next quiz)
• Alternative: Circular (point to back, with back.getNext() as front; revisit idea this with linked lists)

Other Queue options?

• ArrayList. (Handles array growth, but drawbacks to this?)
• Stack (x 2; shifting back and forth)

ADT behavior vs efficiency

Pre-generics ArrayList use

Also before autoboxing

public static void main(String[] args) {
  ArrayList numbers = new ArrayList();
  numbers.add(new Integer(2));
  numbers.add(new Integer(4));
  numbers.add(new Integer(5));
  int total = product(numbers);
  System.out.println(total);
}

public static int product(ArrayList nums) {
  int product = 1;
  for (int i = 0; i < nums.size(); i++) {
    Integer n = (Integer) nums.get(i); //nums.get(i) returns an Object
    product *= n.intValue();
  }
  return product;
}

• What if we: numbers.add("3"); Or put only strings in there?
• Now: get many warnings about raw types for this

Modern ArrayList use

(Still no autoboxing in this example)

public static void main(String[] args) {
  ArrayList<Integer> numbers = new ArrayList<Integer>();
  numbers.add(new Integer(2));
  numbers.add(new Integer(4));
  numbers.add(new Integer(5));
  int total = product(numbers);
  System.out.println(total);
}

public static int product(ArrayList<Integer> nums) {
  int product = 1;
  for (int i = 0; i < nums.size(); i++) {
    Integer n = nums.get(i); //no cast; returns Integer now
    product *= n.intValue();
  }
  return product;
}

• Can't put String into numbers. Can only pass AL<Integer> to product.
• No warnings. But still compiles to old way! (Compiler puts the casts in for you.)

Very modern ArrayList use

Autoboxing, for-each loop

public static void main(String[] args) {
  ArrayList<Integer> numbers = new ArrayList<Integer>();
  numbers.add(2);
  numbers.add(4);
  numbers.add(5);
  int total = product(numbers);
  System.out.println(total);
}

public static int product(ArrayList<Integer> nums) {
  int product = 1;
  for (int n : nums) {
    product *= n;
  }
  return product;
}

• Now compiler also inserts all the wrapper class for us too.

Old way: Implement Queue

Still general purpose: Can insert any kind of object

class Queue {  //no <E>

  private static final int CAPACITY = 5;

  private Object[] items;
  private int front;  //points at first item
  private int back;   //first blank spot

  public Queue() {
    Object[] array = new Object[CAPACITY + 1];
    items = array;
    back = 0;
    front = 0;
  }

  public void offer(Object item) {
    if (this.size() == CAPACITY) {
      //Implementation-level restriction: would be nice to avoid this...
      throw new IllegalStateException("Queue is full.");
    }
    this.items[back] = item;
    this.back = (this.back + 1) % items.length;
  }

  public Object peek() {
    if (this.size() == 0) {
      throw new IllegalStateException("Queue is empty.");
    }
    return this.items[front];
  }

  public Object poll() {
    Object item = this.peek();  //throws exception if empty
    this.front = (this.front + 1) % items.length;
    return item;
  }

  public int size() {
    return (this.back + items.length - this.front) % items.length;
  }
}

Old way: Using Queue

  public static void main(String[] args) {
    Queue q = new Queue();
    q.offer("here");
    q.offer("there");
    q.offer(4.3);  //autoboxed -> Integer -> Object

    //...

    while (q.size() > 0) {
      Object o = q.poll();              //every thing comes out as Object
      String str = (String) o;          //need to cast back to what you put in
      System.out.println(str.length());  //crash: ClassCastException
    }
  }

Type Erasure

• Compiler checks that all uses are correct according to generic <type>s
• Then strips out all type parameter info
• Produces old version with all necessary casts (basically)
• So any type parameters are no longer available at runtime!
• So certain things you can't do... like build new arrays or instances of type E

Generic array creation

class Queue<E> {

  private static final int CAPACITY = 5;

  private E[] items;
  private int front;  
  private int back; 

  public Queue() {
    this.items = new E[CAPACITY];  //NO!  Does not compile
    this.front = 0;
    this.back = 0;
  }
}

Compiler can't put a specific E here: Integer, String, what? Needs one type that works for all Stack uses.

Generic array creation

  this.items = new E[CAPACITY];  //NO!  Does not compile

  this.items = new Object[CAPACITY];  //NO!  E[] != Object[]

  this.items = (E[]) new Object[CAPACITY];  //Works... but warning

• Compiler tends to take narrow/local view. We can suppress the warning if we're certain it's safe.
  • If you're not certain, then you just turned a compiler warning into a likely runtime error.
• Good to limit suppression to narrowest possible scope. Needs to be on a definition, though (class, method, or variable):

    @SuppressWarnings("unchecked")
    E[] array = (E[]) new Object[CAPACITY];
    this.items = array;

Arrays of parametized types

• Array type checked at runtime, but generic types checked at compile time
• Therefore, can't create arrays of parametized types:

    ArrayList<String>[] strMatrix = new ArrayList<String>[10];  //NO!
  

• Remember, <String> part lost at runtime. So, if above compiled, we could do this:

    ArrayList<Integer> nums = new ArrayList<Integer>();
    nums.add(3);
    Object[] matrix = strMatrix;     //because ArrayList[] is a kind of Object[]
    matrix[0] = nums;                //because an ArrayList is an Object
    strMatrix[0].get(0);      //OOPS!  Just got an Integer out of ArrayList<String>[]
  

• Just violated protection of generics, so first line above is disallowed.

Conclusions

• Can't create instances of parameter types: new E();
• Arrays and generics don't play well together

  PyramidStack<Meep>[] shafts = new PyramidStack<Meep>[3];  //NO!  Can't.
  shafts[0] = new PyramidStack<Meep>();
  

• Can use an ArrayList just fine though:

  ArrayList<PyramidStack<Meep>> shafts = new ArrayList<PyramidStack<Meep>>();
  shafts.add(new PyramidStack<Meep>());
  

More info: Java Tutorial, Arrays in Java Generics

BTW: Good Java references

If you want to master the more advanced aspects of Java, I enjoyed:

• D. Flanagan's Java in a Nutshell (first 1/3; covers Java 5)
• J. Bloch's Effective Java (2nd ed)

Can access digital versions of both for free through UH Library, but only 4 users at a time.

Method call series

Given:

ArrayList<PyramidStack<Meep>> shafts = new ArrayList<PyramidStack<Meep>>();
//... add three new PyramidStack<Meep>()s
Meep newcomer = new Meep(5);  //Meeps are Comparable, so has compareTo method.

Problem: See if meep on top of left shaft (index: 0) is smaller than newcomer

   (shafts)                  //whole ArrayList
   (shafts.get(0))           //first PyramidStack<Meep>
   (shafts.get(0).peek())    //Top of that stack: a Meep
   (shafts.get(0).peek().compareTo(newcomer))   //an int

  if (shafts.get(0).peek().compareTo(newcomer) < 0) {
    //top meep is smaller

Shortcut logic operators

  if (shafts.get(0).peek().compareTo(newcomer) < 0) {
    //top meep is smaller

Now we have 3 stacks in shafts, but what if stack at shaft.get(0) is empty? Crash!

  if (shafts.get(0).size() > 0 && 
      shafts.get(0).peek().compareTo(newcomer) < 0) {
    //...

  if (shafts.get(0).size() == 0 ||
      shafts.get(0).peek().compareTo(newcomer) < 0) {
    //newcomer can move to first shaft

For next time...

• Quiz 06 (by Fri)
• Finish up A06a and move onto A06b
• Lists next