Status

• Quiz 06 (due today tomorrow)
• A05a extended
• Start on A05b
  • More on this in lab on Friday
• jar files

Trimming unnecessary code (tips from Exam 1)

• return and parentheses

    return(x);  //NO: looks like method call
    return (x); //BETTER... space at least (same with if/for/etc)
    return x;   //YES
    return x > 0 && y > 0;    //fine
    return (x > 0 && y > 0);  //now parentheses might be worth it
  

• boolean comparisons in ifs

    boolean negative = ...
    
    //NO: == is error prone (too easy to put =)
    if (negative == true) {    //just use: if (negative) {
      return true;           
    }
  

    //NO: if test == true, return true; if test == false; return false
    if (x < 0 && y < 0) {
      return true;
    }else {
      return false;
    }
    //instead: just return test;
  

• empty elses / reverse tests

    if (x < 0) {
      //...do this stuff...
    }else {     //NO: elses are optional for a reason
    }
  

    if (x < 0) {
      //...do this stuff...
    }else if (x >= 0) {    //NO: use else here
      //...do this other stuff...
    }
  

• ifs to skip loops that wouldn't run anyway

    if (array.length > 0) {
      for (int i = 0; i < array.length; i++) {
        //...do stuff...
      }
    }
    //(maybe need if doing stuff in if but outside loop)
    //(but not in simple case like this)
  

• Point of this: Practice looking at your code after you write it and see what you can trim
  • I realize there may not be time for this detailed reflection on an exam
  • but practice in in your regular coding and you'll improve/get faster

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 removal (or 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 (and we add/offer at 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. (Simple and handles array growth, but drawbacks to this?)

  class Queue<E> {
  
    private ArrayList<E> items;
  
    public Queue() {
      items = new ArrayList<E>();
    }
  
    public void offer(E item) {
      items.add(item);
    }
  
    public E peek() {
      if (items.isEmpty()) {
        throw new IllegalStateException("Cannot poll from empty queue.");
      }
      return items.get(0);
    }
  
    public E poll() {
      E item = this.peek();  //will throw exception if needed
      items.remove(0);
      return item;
    }
  
    public int size() {
      return items.size();
    }
  }
  

• 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.

  E example = new E();  //NO: which constructor would get called?
  
  public E[] snapshot() {
    return items;       //NO: Object[]?  
                        //But (new Queue<String>()).snapshot() should give String[]
                        //and (new Queue<Integer>()).snapshot() should give Integer[]
  }

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() or new E[size]
• 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

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(2))           //first PyramidStack<Meep>
   (shafts.get(2).peek())    //Top of that stack: a Meep
   (shafts.get(2).peek().compareTo(newcomer))   //an int

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

Shortcut logic operators

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

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

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

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

Summary

• Queue ADT
  • same behavior/public interface
  • many different (hidden/encapsulated) implementations possible
• A few technical details of generics (type erasure and its consequences)

For next time...

• Quiz 06
• Finish up A05a and move onto A05b
• Lists next