Java 5 New Features

1. Java 5 New Features • Generics • Enhanced for loop • Autoboxing/unboxing • Typesafe enums • Other • Varargs • Static Import • Metadata • New classes and methods • VM Enhancements

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 String Iterator<String> iter = list.iterator(); String s = iter.next(); // next() returns a String • Compare with earlier Java ArrayList list = new ArrayList(); list.put(“hello”); // put() takes an Object Iterator iter = list.iterator(); String s = (String)iter.next(); // next() returns an Object which must be cast to String

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> • add(E o) • E get(int index) • Interface Map<K,V> • V put(K key, V value) • V get(Object key) • Collection<V> values()

4. Enhanced for Loop • Replaced iterators, indexing • Iterators and indexing are prone to bounds errors // throws ArrayIndexOutOfBoundsException for (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()); } }

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); }

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

7. Autoboxing with Generics and For-Each • Note again how the new Java 5 features work together: // old syntax Integer 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 syntax Integer sumIntegers(List<Integer> list) { int sum = 0; for (int x: list) sum+= x; // auto-unboxing elements return sum; // autobox return value }

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]; }

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

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?

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

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