CompSci 100E 40.1

Java 5 New Features

Generics Enhanced for loop Autoboxing/unboxing Typesafe enums Other

Varargs Static Import Metadata New classes and methods VM Enhancements

CompSci 100E 40.2

Generics Allows classes to store objects whose type is

irrelevant to storing class, while allowing type-safe retrieval

E.g., Collection Syntax

ArrayList<String> list = new ArrayList<String>();list.put(“hello”); // put() takes a StringIterator<String> iter = list.iterator();String s = iter.next(); // next() returns a String

Compare with earlier JavaArrayList list = new ArrayList();list.put(“hello”); // put() takes an ObjectIterator iter = list.iterator();String s = (String)iter.next(); // next() returns an Object which must be cast to String

CompSci 100E 40.3

Generics in API Docs

In API documentation, generics are given a type alias, e.g., “E”:

Alias is arbitrary, but stands for the same type throughout class definition

Can be on more than one type using different aliases Examples

Class ArrayList<E>o add(E o)o E get(int index)

Interface Map<K,V>o V put(K key, V value)o V get(Object key)o Collection<V> values()

CompSci 100E 40.4

Enhanced for Loop

Replaced iterators, indexing

Iterators and indexing are prone to bounds errors

// throws ArrayIndexOutOfBoundsExceptionfor (int i = 0; i <= arr.length; i++)

{ System.out.println(arr[i]); }

// what does this do?Iterator iter = list.iterator();while (iter.hasNext()) {

if (!“stop”.equals(iter.next())) {System.out.println(iter.next());

}}

CompSci 100E 40.5

Looping in Java 5 Java 5 introduces new language syntax for

looping over arrays and collections using for (aka “For-Each” loop)

Syntax:for (type var: collection) {

// do something with var}

Examples:void processArray(String[] arr) {

for (String s: arr) System.out.println(s.toUpperCase());

}

// generics work with new for loop to simplify syntax!void processList(List<String> list) {

for (String s: list) System.out.println(s);

}

CompSci 100E 40.6

Autoboxing/Unboxing

Java primitive types provided for performance, but mix poorly with objects:

// compilation error!ArrayList list = new ArrayList();list.add(42);int x = (int) list.get(0);

// Kludgey fix provided by original Java: ugh!list.add(new Integer(42));int x = ((Integer)list.get(0)).intValue()

Java 5 automatically “boxes” primitive types in Object types as neeeded:

Integer objInt;objInt = 42; // equivalent to objInt = new Integer(42);

CompSci 100E 40.7

Autoboxing with Generics and For-Each Note again how the new Java 5 features work

together:

// old syntaxInteger sumInteger(List list) {

int sum = 0;Iterator iter = list.iterator();while (iter.hasNext()) {

Integer iobj = (Integer) iter.next();sum += iobj.intValue();

}}return new Integer(sum);

// new syntaxInteger sumIntegers(List<Integer> list) {

int sum = 0;for (int x: list) sum+= x; // auto-unboxing elements

return sum; // autobox return value

}

CompSci 100E 40.8

New Features: Limitations Generics are not everywhere, yet

consider list.toArray() returning Object[]

Enhanced for loop on non-parameterized collections is still annoying (obviously using generics helps, but what if you are forced to use legacy code?)

for (Object o: list) { String s = (String)o; ... }

For loop doesn't give you a good way to loop over multiple collections in parallel: still must do:

int[] arr1, arr2;for (int i; i < arr1.length; i++) {

int x = arr1[i] + arr2[i];}

CompSci 100E 40.9

New Features: Limitations (con't)

Autoboxing doesn't carry over to arrays, or to converting arrays to lists and vice versa: can't do the following:

int[] arr = new int[100]; Integer[] arrInts = arr;

List<Integer> list = new ArrayList<Integer>(); list.addAll(arr);

CompSci 100E 40.10

Typesafe Enums

Enums are a safer alternative to constants Old way:

public static final int GO = 0;public static final int STOP = 1;public static final int YIELD = 2;....

Consider code taking these values as a parameter:void process(int status) {

if (status == GO) ...if (status == STOP) ...if (status == YIELD) ...else ... // what does status == 10 mean?

CompSci 100E 40.11

The Enum Alternative Enums define a type, just like a class or primitive

type Enums are not interchangeable with ints,

impossible to get undefined values Enums can be enumerated using for String representations of enums actually mean

something Examples:

public enum TrafficLight { GO, STOP, YIELD }public TrafficLight myLight = STOP;for (TrafficLight t: TrafficLight.values()) {

System.out.print(t);System.out.print(“ “);

}// output: GO STOP YIELD

CompSci 100E 40.12

Other New Features

Java 5 has many other new features, including: Varargs – variable-size argument lists for

methods Static Import – import constants, e.g. Math.PI Metadata – attach extra information about code New classes and methods – Queue, Scanner,

printf, etc. VM Enhancements