Java 5 Part 1

CSE301

University of Sunderland

Harry Erwin, PhD

Introduction

• Java 5 has been changed to improve the language.• This lecture will discuss the changes. You will be

tested on your knowledge of Java 5.• References include:

– McLaughlin and Flanagan, 2004, Java 1.5 Tiger: A Developer’s Notebook, O’Reilly

– Flanagan, 2005, Java in a Nutshell, 5th edition, O’Reilly

Topics

Part 1 (today)• Arrays• Queues• Overriding return

types• Unicode• StringBuilder• Generics

Part 2 (next lecture)• Enumerated types• Boxing• Annotations• for/in• Static imports• Formatting• Threading

Arrays• Many static utility methods have been added for use

with arrays. (Possible test questions follow!)• To use them, import java.util.Arrays;

• Arrays.toString(theArray); lists the array contents• Arrays.deepToString(theArray);

• Arrays.equals(array1,array2); tests two arrays for equality • Arrays.hashCode(theArray); provides a hashcode (qv) for

the array. • Arrays.deepEquals(array1,array2); is similar.• Arrays.deepHashCode(theArray); is similar.

Queues• import Java.util.Queue; to use queues.• That gives you a nice first-in-first-out data structure.• Don’t use add() or remove() with it, as they throw

exceptions. Instead, use offer() and poll(). offer() returns false if the queue is full, and poll() returns null if the queue is empty.

• If you want to see the next available entry in the queue without removing it, use element() or peek().

• PriorityQueue is ordered using comparators. (It still isn’t as efficient as a C++ priority queue.)

• Possible test questions

Overriding return types

• In correct C++ implementations—I believe Visual C++ has finally fixed this—you can have a ‘covariant return’, where a method in a subclass returns a more specialised type instance than the overridden method in the base class. This is now available in Java 5. The return type of the subclass method must be an extension of the return type of the base class, and the compiler must be told you’re compiling Java 5 code.

• Possible test question.

Unicode 4.0

• Java 5 supports Unicode 4.0, which defines some characters that require 21 bits in addition to the 16-bit standard Unicode 3.0 characters.

• You use int to represent these characters, and some of the static methods in the Character class now accept int arguments to deal with them.

• In a String, use a pair of char values to encode a 21-bit character.

StringBuilder

• This is a drop-in replacement for StringBuffer when thread safety is not an issue and speed is. (If thread safety matters, use StringBuffer.)

• StringBuffer and StringBuilder represent modifiable Strings, so you can edit them in many ways.

• The toString(); method for either converts its buffer into a String.

• To go the other direction, create a StringBuffer or StringBuilder object around the String.

Generics

• This is the most important new feature of Java 5. This allows a class to indicate that it uses or contains instances of some generic type. This increases the type safety of Java because the compiler can verify that you’re using that type correctly.

• A generic class or method looks like a C++ template class or method.

• Test questions are to be found throughout the material on generics!

Why Generics?

• This is pre-Java 5, legal, and unsafeList listOfStrings = getListOfStrings()

for(Iterator i = listOfStrings.iterator(); i.hasNext();){

String item = (String)i.next();

Do something with the String item

}

• You cannot remove the cast to String.

The Java 5 Solution

• This is legal only in Java 5 and much more safe:List<String> listOfStrings = getListOfStrings();

for(Iterator<String> i = listOfStrings.iterator(); i.hasNext();){

String item = i.next();

Do something with the String item

}

• The cast to String is gone.• Not much change? Wait.

Class Syntax for Generic

• class Foo<E> {E can be used as a method argument type, a field member, or anywhere that a type can be used in a class definition.

}

(The naming convention for a parameter is to use a single uppercase letter.)

• E cannot be used in a static member field as the class that is shared among all instances of type Foo<N> is Foo itself. Sorry!

• E can be used in static member methods.

Generics and Primitive Types

• They are incompatible, simply put. ‘E’ cannot be a primitive type. Use the corresponding wrapper types (Integer, Boolean, Float, Double, Character, etc.) and let autoboxing and unboxing (discussed later) handle the conversions.

• List<int> will fail.• List<Integer> will work.

Generics and Collections

• All the collection classes support generics (in addition to their normal use in pre-Java 5 code).

• Map even takes two parameters. Map<F, B> defines the keys to the map as type F, and the values as type B.

• Iterators are also parameterized (although they can also be nearly avoided using for/in loops, discussed later). Note you must parameterize the iterator if the collec-tion is parameterized.

• Finally, if you parameterize the iterator and not the collection, you’re playing with fire.

Parameterized Types as Method Arguments

• private void Foo(Bar<Baz> argument);– This works fine.

• private Bar<Baz> Foo();– Returns an object of class Bar<Baz>.

• private void Foo(Bar<?> argument);– Can read but not write objects of type Quux<?> internally,

and you cannot construct an object of type Quux<?>.

• private void Foo(Bar<N extends Baz> arg);– Is limited to N where N extends Baz. Similarly for class

definitions and implements.

• Bar<Object> is not Bar<?>.

Type Conversions with Parameterized Types

• Here be dragons!• Parameterized types form a hierarchy, but the

hierarchy is based on the base type, not on the types of the parameters.

• A LinkedList<Float> is a List<Float>, but not a LinkedList<Number>. (It is a LinkedList.)

• Why? Generics are a Java 5 add-on, and the class files must be Java 1-compatible and forgetting about the parameter types. (Inner classes are a similar add-on with some unexpected behaviour.) To avoid abuse, inheritance ignores parameters.

Arrays of Parameterized Types

• Here be more dragons!• An array of type S[] is also of type T[] when T is a

base class or interface of S.• If you try to store an object of type T into an array of

type S via an alias array of type T[], you get a class cast exception. If the type S were parameterized, this protection could not be enforced during run-time, as parameterized types are new in Java 5.

• So to prevent this, you are not allowed to create an array of a parameterized type! Sorry!