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

 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

 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

 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

 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

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

 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

 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

 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

 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

 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

 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
 Re flecting Generic Type s
Type interface to describe generic type :

CS6202 Java Generics 53