1. CS6202: Advanced Topics in Programming Languages
Java 5
and Systems
Lecture 10/11 : Java Generics and Collections Some features in new language
• Overview boxing/unboxing
• Subtyping and Wildcard
• Comparison and Bounds new form of loop
• Declaration and Erasure
• Reification and Reflection functions with variable number of arguments
• Collections
• Iterator, Iterable, Collection generics
• Set, Queues, List, Maps
• Design Patterns more concurrency features
• Other Issues
CS6202 Java Generics 1 CS6202 Java Generics 3
Motiva tion Java 5 : Example
Generics is important for: unboxing/boxing
generic collection
software reuse
type safety
new
optimization (fewer castings) loop
Important Principle :
“Everything should be as simple as possible but no simpler” function with variable
number of arguments
assert from Java 1.4
CS6202 Java Generics 2 CS6202 Java Generics 4

2. Example in Java 1.4 Boxing and Unboxing
Unboxed types can give better performance
Boxed type may be cached for frequent values.
60% slower
similar code with Array in Java 1.4
CS6202 Java Generics 5 CS6202 Java Generics 7
Generics by Erasure Foreach Loop
Works with iterator and is more concise.
Java Generics is implemented by erasure: Kept simple – cannot use remove + multiple lists.
- simplicity
- small
- eases evolution (compatibility)
List<Integer>, List<String>, List<List<String>>
erases to just List
compiles to
Anomaly : array type very different from parametric type.
new String[size]
new ArrayList<String>()
with the latter losing info on element type.
CS6202 Java Generics 6 CS6202 Java Generics 8

3. Ite ra tor/ Ite rable Inte rfaces Methods with Vara rgs
Iterator supports iteration through a collection. Syntactic sugar to support Varargs. varargs
Iterable allows an Iterator object to be build.
The above is compiled to use array.
CS6202 Java Generics 9 CS6202 Java Generics 11
Methods with Vara rgs
Outline
Arrays can be used to accept a list of elements.
• Overview
• Subtyping and Wildcard
• Comparison and Bounds
• Declaration and Erasure
• Reification and Reflection
• Collections
• Iterator, Iterable, Collection
• Set, Queues, List, Maps
Packing argument for array is cumbersome. • Design Patterns
• Other Issues
CS6202 Java Generics 10 CS6202 Java Generics 12

4. Subtyping and Substitutions Principle Example
Subtyping Principle : Copy from one list to another :
A variable of a given type may be assigned a value of any
subtype of that type. The same applies to arguments.
Getting elements :
However, it is not sound to have:
List<Integer> <: List<Number>
But arrays may be covariant:
Integer[] <: Number[]
CS6202 Java Generics 13 CS6202 Java Generics 15
Cova riant and Contrava riant Subtyping Example
Covariant Subtyping : Putting elements :
List<Integer> <: List<? extends Number>
list of elements of any type that is a subtype of Number
Contravariant Subtyping :
List<Number> <: List<? super Integer>
list of elements of any type that is a supertype of Number Two Bounds? Not legal though plausible.
Get and Put Principle : use an extends wildcard when you
only get values out of a structure, use a super wildcard
when you put values into a structure. Don’t use wildcard
when you both get and put.
CS6202 Java Generics 14 CS6202 Java Generics 16

5. Arrays Wildca rd Capture
Array subtyping is covariant. We can reverse a list using parametric type or wildcard type?
This was designed before generics.
Seems irrelevant now :
- unsound as it relies on runtime checks
- incompatible with Collection
- should perhaps deprecate over time.
One Solution : Use more of Collection rather than Array
- more flexibility
- more features/operations
- better generics
CS6202 Java Generics 17 CS6202 Java Generics 19
Wildca rd vs Type Pa rameter Wildca rd Capture
Wildcards may be used if only Objects are being read. Solution is to use a wrapper function with wildcard capture :
Collection<?> also stands for Collection<? extends Object>
Alternative (more restrictive but safer).
This solution is similar to a open/close capture of an
existential type.
CS6202 Java Generics 18 CS6202 Java Generics 20

6. Re striction on Wildca rds
Wildcards should not appear at Outline
(i) top-level of class instance creation
(ii) explicit type parameters of generic method • Overview
(iii) in supertypes of extends/implements • Subtyping and Wildcard
• Comparison and Bounds
• Declaration and Erasure
• Reification and Reflection
• Collections
• Iterator, Iterable, Collection
• Set, Queues, List, Maps
• Design Patterns
• Other Issues
CS6202 Java Generics 21 CS6202 Java Generics 23
Re striction on Wildca rds Compa rison and Bounds
Restriction on supertype of extends/implements x.compareTo(y) method is based on natural ordering
x less_than y returns a negative value
x equal_to y returns zero
x more_than y returns a positive value
Restriction on explicit parameter of methods
Consistency with equal
x.equals(y) if and only if x.compareTo(y)==0
Main difference with null
x.equals(null) returns false
permitted x.compareTo(null) throws an exception
CS6202 Java Generics 22 CS6202 Java Generics 24

7. Contract for Compa rable Maximum of a Collection
Generic code to find maximum : need to compare
Anti-symmetric :
with its own type
sgn(x.compareTo(y)) == -sgn(y.compareTo(x))
Transitivity :
if x.compareTo(y)<0 and y.compareTo(z)<0
then x.compareTo(z)<0
Congruence :
if x.compareTo(y)==0 then A more general signature is based on get/put principle:
forall z. sgn(x.compareTo(z)==sgn(x.compareTo(z))
CS6202 Java Generics 25 CS6202 Java Generics 27
Implementing Integer a s Compa rable Fruity Example
Correct way : There is some control over what can be compared.
cannot compare apple with orange
Incorrect way - overflow problem :
can now compare between orange/apple
CS6202 Java Generics 26 CS6202 Java Generics 28

8. Fruity Example Compa rator
Recall : Implement max using Comparator :
This works for List<Orange> and List<Fruit>, but old
version works for only List<Fruit> .
Comparator from natural order :
CS6202 Java Generics 29 CS6202 Java Generics 31
Compa rator Enumerated Type s
Allows additional ad-hoc ordering to be specified : Enumerated type corresponds to a class with a set of final static
values. First, an abstract class :
Example : shorter string is smaller
compare within same
enumerated type only
CS6202 Java Generics 30 CS6202 Java Generics 32

9. Enumerated Type
An instance of enumerated type.
Outline
• Overview
• Subtyping and Wildcard
• Comparison and Bounds
• Declaration and Erasure
• Reification and Reflection
• Collections
• Iterator, Iterable, Collection
• Set, Queues, List, Maps
• Design Patterns
• Other Issues
CS6202 Java Generics 33 CS6202 Java Generics 35
Cova riant Overriding Constructors
Java 5 can override another if arguments match exactly but the Actual type parameters should be provided :
result of overriding method is a subtype of other method.
Pair<String,Integer> p = new
Useful for clone method : Pair<String,Integer>(“one”,2)
class Object {
:
public Object clone() { … }
If you forget, it is a raw type with unchecked warning :
}
class Point { Pair<String,Integer> p = new Pair(“one”,2)
:
public Point clone() { return new Point(x,y);}
}
covariant overriding
CS6202 Java Generics 34 CS6202 Java Generics 36

10. Sta tic Members
Static methods are independent of any type parameters :
Outline
• Overview
Cell.getCount() // ok • Subtyping and Wildcard
• Comparison and Bounds
Cell<Integer>.getCount() // compile-time error • Declaration and Erasure
Cell<?>.getCount() // compile-time error
• Reification and Reflection
• Collections
• Iterator, Iterable, Collection
• Set, Queues, List, Maps
• Design Patterns
• Other Issues
CS6202 Java Generics 37 CS6202 Java Generics 39
How Erasure Works Reification
Refers to an ability to get run-time type information.
This is a kind of concretization.
Array is reified with its component type, but
parameterized types is reified without its component type.
Number[] has reified type Number[]
ArrayList<Number> has reified type ArrayList
CS6202 Java Generics 38 CS6202 Java Generics 40

11. Reified Type s Reification - Arrays
Type that is reifiable. More problem :
Type that is not reifiable.
CS6202 Java Generics 41 CS6202 Java Generics 43
Reification Reification - Arrays
An incorrect code to convert a collection to an array. More problem :
not reifiable
CS6202 Java Generics 42 CS6202 Java Generics 44

12. Reification - Arrays Re flection
Alternative using another array + reflection! Reflection is a term to allow a program to examine its own
definition.
Generics for reflection supports the process using new generic
programming techniques.
Reflection for generics allow generic types (e.g. type vars,
wildcard types) to be captured at runtime.
CS6202 Java Generics 45 CS6202 Java Generics 47
Reification - Arrays Generics for Re flection
Solution using a Class – runtime type!
A new generic type for Class
CS6202 Java Generics 46 CS6202 Java Generics 48

13. Re flection for Primitive Type Re flection for Gene ric
Non-generic reflection example :
We cannot use Class<int> as type parameter must be reference
type. Use Class<Integer> for int.class instead!
Java.lang.reflect.array.newInstances(int.class,size)
returns int[] and not Integer[] through a hack!
However, int[].class is correctly denoted by Class<int[]> Output :
CS6202 Java Generics 49 CS6202 Java Generics 51
Generic Re flection Libra ry Re flection for Gene ric
Generic reflection example :
newArray
Output :
newArray
Bytecode contains generic type information!
CS6202 Java Generics 50 CS6202 Java Generics 52

14. Re flecting Generic Type s
Type interface to describe generic type :
CS6202 Java Generics 53