CISC 3115
Modern Programming Techniques
Lecture 08
Collections (Containers), Generics, and Autoboxing

Resizing an array

ArrayList

• One of the Java Collection classes
• Essentially array behavior on steroids:
  • It's defined as a class
    • no subscript operator; get and methods instead
    • full-fledged member of the class hierarchy
    • toString method
    • many useful 'vector-like' methods: contains, insert, remove, addAll
  • automatic memory management

Like all the other collection classes:

• Object element type
  • Java's class hierarchy with Object at root
  • upcast for insertion; downcast for extraction
• wrapper classes for primitives

ArrayList alist = new ArrayList();		// Object element type

for (int i = 1; i < 10; i++) {
	Integer integer = new Integer(i);	// wrapping primitive int in Integer wrapper object
	alist.add(integer);				// upcast of Integer to Object element type
}

for (int i = 0; i < alist.size(); i++)
	System.out.println(alist.get(i));	// no cast downcast necessary -- calling toString which is defined in Object

for (int i = 0; i < alist.size(); i++) {
	Integer integer = (Integer)alist.get(i));	// downcast of Object to Integer
	int n = integer.intValue();				// extraction of primitive int from Integer wrapper
	n++;									// int operation
	integer = new Integer(n));				// wrapping primitive int in (new) Integer wrapper object
	alist.set(i, integer);					// upcast Integer to Object element type, replacing original element at i
}

Generics and Autoboxing

Overview

• Generics
  • Provides increased type-safety for collections
  • Eliminates most downcasting
• Autoboxing
  • Eliminates much of the drudgery of working with wrapper classes

Generics

• Prior to 1.5:

  ArrayList arrList = new ArrayList();
  while (...) {			// adding String's to the vector 
  	String s = ...;
  	arrList.add(s);
  }
  ...
  
  for (int i = 0; i < arrList.size(); i++) {
  	String s = (String)arrlist.get(i);	 	// downcast needed
  	…	
  }
  		

• Collections can now be declared with their element types:

  ArrayList<String> arrList = new ArrayList<String>
  		

• The compiler enforces this declaration

  ArrayList<String> arrList = new ArrayList<String>
  v.add(new Integer(5));		// compiler error
  		

• Collection is then guaranteed to be homogeneous
  • Above ArrayList can only contain Strings
• Downcasting can then be done automatically by the compiler

  ArrayList<String> arrList = new ArrayList<String>
  String s = ...;
  arrList.add(s);
  ...
  String s2 = arrList.elementAt(0);		// no need for downcast-- compiler takes care of it
  		

• Collection processing is now much simpler

  ArrayList<Strin>> v = new ArrayList<String>();
  while (...) {			// adding String's to the vector 
  	String s = ...;
  	arrList.add(s);
  }
  ...
  for (int i = 0; i < arrList.size(); i++) {
  	String s = arrlist.get(i);	 	// no downcast needed
  	…	
  }
  		

• Users can create their own generic class definitions as well

Type Erasure

• The generic type is used by the compiler to control the type of elements added to a generic collection.
  • In addition, the type is used by the compiler to insert the needed downcast when extracting from the collection
• Once the code has passed compilation, the generic type is removed; it has served it purpose
  • This is known as type erasure
• At runtime, there are thus only collections of Objects.
  • i.e, the generic type was a compile type entity only

Enhanced for loop

• Language-provided support for iteration

  for (element-declaration : iterable)
  	use element in loop body
  		

Random r = new Random();

ArrayList<Integer> arrList = new ArrayList<Integer>();
for (int i = 0; i < 100; i++)
	arrList.add(new Integer(r.nextInt(200)));

for (Integer i : arrList)
	System.out.println(i);

Autoboxing

• any time a primitive type appears in a context requiring an object, the type is wrapped (by the compiler) into its wrapper class object

  ArrayList<Integer> arrList = new ArrayList<Integer>
  ...
  arrList.add(3);		// compiler automatically insert a 'new Integer(3)'
  		

• any time an object appears in a context requiring a primitive type, the object is unwrapped into its corresponding primtive type

  ArrayList<Integer> arrList = new ArrayList<Integer>
  ...
  int i = arrList.get(0);		// compiler automatically insert a '.intValue()' 
  		

The Diamond Operator

• When creating generic objects, the following pattern often arises:

  ArrayList<Integer> arrList = new ArrayList<Integer>();
  

  i.e., the generic type argument needs to be specified in both the declaration of the reference variable as well as in the creation of the object.
• The above can be replaced by:

  ArrayList<Integer> arrList = new ArrayList<>();
  

  • The <> is called the diamond operator
  • The compiler infers the correct generic type from the declaration
  • This does not work in every context; mainly on the right-hand side of an assignment or initialization, and as an argument passed to a method.

Type Inference

Code for this Lecture