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 list = new ArrayList (); list.put(“hello”);// put() takes a String Iterator 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

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

CompSci 100E 40.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()); }

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 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 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 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 list = new ArrayList (); list.addAll(arr);

CompSci 100E 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 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 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