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
• ArrayListltStringgt list new ArrayListltStringgt()
• list.put(hello) // put() takes a String
• IteratorltStringgt 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 ArrayListltEgt
• add(E o)
• E get(int index)
• Interface MapltK,Vgt
• V put(K key, V value)
• V get(Object key)
• CollectionltVgt values()

4
Enhanced for Loop

• Replaced iterators, indexing
• Iterators and indexing are prone to bounds errors
• // throws ArrayIndexOutOfBoundsException
• for (int i 0 i lt arr.length i)
• System.out.println(arri)
• // 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(ListltStringgt 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(ListltIntegergt 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 lt arr1.length i)
• int x arr1i arr2i

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 int100
• Integer arrInts arr
• ListltIntegergt list new ArrayListltIntegergt()
• 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