The document discusses several new features introduced in Java 5 that aim to simplify Java development: 1) New collection classes and concurrent utilities were added to the Java library to provide more robust functionality out of the box. 2) Covariant returns allow overriding methods to have a more specific return type as long as it extends the original return type. 3) Enhanced for loops (foreach loops) improve readability when iterating over collections by eliminating the need for iterators. 4) Autoboxing and unboxing automatically convert between primitives and their corresponding wrapper types.

1. Can these new and complex features simplify Java development?

3. New class addtion ?

java.lang.StringBuilder

java.lang.Formatter

java.util.Queue

java.util.concurrent.*

4. Covariant ReturnTypes?

Prior to JDK 1.5, a subclass could not override a
method using a different return type

In JDK 1.5, a method can be overridden with a
different return type as long as the new return
type extends the original

A return type that differs from that of the
method it is overriding is called a “covariant
return”

5. Covariant Returns (con..)
Prior to JDK1.5
package com;
public class CovarientParent
{
String str="";
public CovarientParent(String str)
{
str=this.str;
}
public CovarientParent getInstance()
{
return new CovarientParent("I am
CovarientParent");
}
}
Extended class
package com;
public class CovarientExample extends
CovarientParent
{
public CovarientExample(String str)
{
super(str);
}
// Compiler error:The return type is incompatible
with CovarientParent.getInstance()
public CovarientExample getInstance()
CovarientExample.javaJavaCollection
{
return new CovarientExample(" I m
CovarientExample");
}

6. Covariant Returns in JDK1.5 (cont)
package com;
public class CovarientParent
{
String str="";
public CovarientParent(String str)
{
str=this.str;
}
public CovarientParent getInstance()
{
return new CovarientParent("I am
CovarientParent");
}
}
Extended class
package com;
public class CovarientExample extends
CovarientParent
{
public CovarientExample(String str)
{
super(str);
}
// No more compile time error
// Compiler error:The return type is
incompatible with
CovarientParent.getInstance()
public CovarientExample getInstance()
CovarientExample.javaJavaCollection
{
return new CovarientExample(" I m
CovarientExample");
}

7. Enhanced for loop (foreach)

Improves readability

Reduces boilerplate code

Works with both arrays and objects that
expose an iterator

The enhanced for loop eliminates the need to use
java.util.Iterator to iterate over a collection.

8. Enhanced for loop (foreach)(cont)
 Before 1.5
Void cancelAll(Collection c)
{
for (Iterator i = c.iterator();
i.hasNext(); )
i.next().cancel();
}
 JDK 1.5
void cancelAll(Collection c)
{
for (TimerTask t : c)
t.cancel();
}

9. Enhanced for loop (foreach)(cont)
 More example
for (Suit suit : suits)
for (Rank rank : ranks)
sortedDeck.add(new
Card(suit, rank));
 Array looping
int sum(int[] a)
{
int result = 0;
for (int i : a)
result += i;
return result;
}

10. Autoboxing/unboxing

Conversions between primitives and their equivalent wrapper
types are now automatic.

Box primitive values into the appropriate wrapper class (which
is Integer in the case of int).

When you take the object out of the collection,You get the
Integer that you put in; if you need an int, you must unbox the
Integer using the intValue method

11. Autoboxing/unboxing(cont)
 Before jdk1.5
public class autoBoxing
{
ArrayList temp = new ArrayList();
public void addArrayList(int value)
{
// compiler error
//The method add(int, Object) in
the //type ArrayList is not
applicable //for the arguments
(int)
temp.add(value);
}
}
 After JDK1.5
public class autoBoxing
{
ArrayList temp = new ArrayList();
public void addArrayList(int value)
{
// compiler error
//The method add(int, Object) in the //type
ArrayList is not applicable
//for the arguments (int)
temp.add(value); // autoboxed
}
}

12. Autoboxing/unboxing(cont)
More examples
Autoboxing supports Boolean types
as well.
Boolean value1 = true;
Boolean value2 = false;
Boolean result = (value1 && value2);
//result is false
Autoboxing /unboxing example.
List ints = new ArrayList();
ints.add( 1 ); // auto-boxing to new
Integer( 1 )
ints.add( 2 );
ints.add( 3 );
for ( int num : ints )
// Auto-unboxing using obj.intValue()
System.out.println( num );

13. What is Generics?

Accepts “parameterized types” (parameters that accept
data types)

Improves type safety

Allows for compile time type checking. So Generics
improve reflection also

Eliminates manual type-checking and type-casting

E is a “type parameter” for ArrayList.The name “E” is
arbitrary. It simply serves as a placeholder that can
be replaced with any Java class type.

The compiler replaces every occurrence of E in the
methods with the type that you specify when the ArrayList
is created. Class ArrayList<E>
boolean add(E e)
E get(int index)

14. Generics (cont)
 Before jdk1.5
// Removes 4-letter words from c.
// Elements must be strings
static void expurgate(Collection c)
for (Iterator i = c.iterator();
i.hasNext(); )
if (((String) i.next()).length() == 4)
i.remove();
}
 After jdk1.5
// Removes the 4-letter words from c
static void expurgate(Collection<String> c)
{
for (Iterator<String> i = c.iterator(); i.hasNext(); )
if (i.next().length() == 4)
i.remove();
}
 Type arguments can be specified when an object is declared/created.
 If an ArrayList is created using a type argument of “String”,
the compiler enforces that the list can contain only String objects.
 Eliminates manual type-checking and type-casting

15. Generic Types (cont)
interface Collection <E>
{
boolean add(E o);
boolean addAll(Collection<? extends E> c);
Iterator<E> iterator();
<T>T[] toArray(T[] a);
…
}

16. Generic Interface (or Class) (cont)
interface Collection <E> …
Collection<Integer> integers;
E is the type parameter for the generic type
Collection is the raw type after type erasure
Integer is the actual type parameter used when
declaring an instance of the generic type
Cannot use primitive types but auto-boxing covers
over the difference

17. Generic using the type parameters (cont)
boolean add(E o);
Where ever E is used, the compiler will check the type against the
actual type parameter. At runtime E will be Object.
Ex:(auto boxing with generics)
List <Integer> temp= new ArrayList<Integer>()
temp.add(1) // auto boxing
temp.add(“mani”) // compile time error

18. Generics Wildcard Parameters (cont)
boolean addAll(Collection<?
extends E> c);
? represents an unknown type
List<?> list = new
ArrayList<String>();
Not legal:
List<Object> list = new
ArrayList<String>();
Would allow list.add( new
Object() );
The JDK 1.5 compiler will issue
“unchecked” type safety
warnings whenever a non-
parameterized collection is
used.To suppress warnings
when parameterization is not
required, method parameters
can be declared using the “?”
wildcard. For instance, this
method accepts a list of any
type.
void printList(List<?> list)

19. Generics bounded type parameters (cont)
boolean addAll
(Collection<? extends E> c);
Constrains possible actual types
An actual type must be same as E
or extend E
Generic types can be specify a range
of types using the “extends”
keyword. For instance, List<?
extends Number> declares a List
that only contains types that
extend Number (or Number itself).
void printNumberList(List<? extends
Number>)

20. Generics java doc paramers (cont)
JDK 1.5’s Javadocs use type parameters named E,
K, V, and T. These values stand for element, key,
value, and type, respectively.
The generic version of HashMap allows you to
declare a type for both key and value.
Class HashMap<K,V>
boolean put(K key, V value);
<T> T[] toArray(T[] a); Infers the actual type from the actual parameter
passed to the method.

21. Generics implementation(cont)

Type parameterization is implemented through a
process called “erasure”. Erasure removes all type
information as the code is compiled.

The compiler automatically adds any required type
casts to the bytecode.

Since it occurs at runtime, type parameterization
does not effect code executed through reflection.

22. Why enum?
// int Enum Pattern - has severe problems!
public static final int SEASON_WINTER = 0;
public static final int SEASON_SPRING = 1;
public static final int SEASON_SUMMER = 2;
public static final int SEASON_FALL = 3;
This pattern has many problems, such as:

Not typesafe - Since a season is just an int you can pass in any other int value
where a season is required, or add two seasons together (which makes no sense).

No namespace -You must prefix constants of an int enum with a string (in this
case SEASON_) to avoid collisions with other int enum types.

Brittleness - Because int enums are compile-time constants, they are compiled
into clients that use them. If a new constant is added between two existing
constants or the order is changed, clients must be recompiled. If they are not,
they will still run, but their behavior will be undefined.

Printed values are uninformative - Because they are just ints, if you print one
out all you get is a number, which tells you nothing about what it represents, or
even what type it is.

23. Enumeraton (cont)

The new enum data type allows the developer to
restrict valid values to a specified set.

The compiler enforces valid values.
public enum CardSuit {HEARTS, DIAMONDS, CLUBS, SPADES};
public setSuit(CardSuit suit) //method that accepts enum
{ … }
setSuit(CardSuit.CLUBS);

24. Ennumeration (cont)

All enum types extend java.lang.Enum.

enum types are classes not integers.This guarantees
type safety.

enum types cannot be extended.

enum values are public, static, and final.

enum values can be compared with == or equals().

25. Ennumeration (cont)

You can switch on enumerated types.

When switching, there is no need to preface the enum
values with the enum class name (in fact, the compiler does
not allow it).
switch (card.getSuit())
{
case HEARTS:
System.out.println(“Hearts”);
break;
case DIAMONDS:
System.out.println(“Diamonds”);
break;
// and so on
}

26. Ennumeration (cont)

Since they are classes, you can add constructors and methods to enum types.
(Grades.A.getAssessment() returns “Excellent!”)
public enum Grades {
A(1), B(2), C(2), D(3), F(3); //integer values are passed to constructor
private String assessment;
Grades(int value) {
switch (value) {
case 1: assessment = “Excellent!”; break;
case 2: assessment = “Not bad.”; break;
case 3: assessment = “Needs improvement!”; break;
}
}
public String getAssessment() {
return assessment;
}
}

27. What is Variable arguments or varargs?

Variable arguments, or varargs, allow a method to
accept any number of arguments.
printNumberList(“Numbers”, 1, 2, 3); //method call
void printNumberList(String header, int... list)
{
System.out.println(header);
for (int item : list)
{
System.out.println(item);
}

28. Variable arguments or varargs(cont)

Only one vararg parameter is allowed per method.

The vararg must be the last parameter.

The vararg parameter is implemented as an array.
Therefore, the compiler sees these methods
declarations as equivalent:
Ex:
void printNumberList(String header, int[] list);
void printNumberList(String header, int... list);

29. Variable arguments or varargs(cont)

Since the compiler implements variable arguments using
arrays, the vararg can be treated as an array.
void printList(String header, int... list)
{
System.out.println(header);
for (int i = 0; i < list.length; i++)
{
System.out.println(list[i]);
}
}

30. What is Static Imports?
Static imports allow static classes to be imported.
import static java.lang.System.out;
public class StaticImportTest
{
public static void main(String[] args)
{
out.println("Hello, world!");
}
}

31. Static Imports (cont)

Static imports also allow the import of static methods
and variables.
import static java.util.Arrays.sort; //import sort method
import static java.lang.Math.*; //import static members
public class StaticImportTest
{
public static void main(String[] args)
{
int[] numbers = {3, 6, 1, 4, 5, 2};
sort(numbers); //sort is method in Arrays class
double d = abs(-15); //abs is method in Math
class
}
}

32. What are new Annotations(Meta-data)?

Annotations provide
additional information about
the code to the compiler or
runtime environment.

Annotations are included in
the source code prefaced by
the “@” symbol.

JDK 1.5 includes three
standard annotation types:
@SuppressWarnings
@Override and @Deprecated

The @SuppressWarnings
annotation turns off specified
compiler warnings.

Defines a single parameter called
value.
@SuppressWarnings(value=“unchecked”
)
public void nonGenericMethod()
//these formats are also supported
@SuppressWarnings(“unchecked”)
@SuppressWarnings(value={“unchecked
”, “fallthrough”})

33. Annotation(cont)

The @Override annotation
indicates that a method is intended
to override a parent method.

If the method does not override a
parent method (names/signatures
do not match), the compiler issues
an error.
@Override
public String toString()
{
// implementation

The @Deprecated annotation
indicates that a method has been
deprecated.

Works in conjunction with the
@deprecated JavaDoc tag that
adds instruction on which
method to use instead.

Classes that call a deprecated
method will receive a warning at
compile time.
@Deprecated
public void MyDeprecatedMethod()

34. Formatted Output
Even though Java offers the excellent java.text
package classes and methods for Formatting of
data, people with C backgrounds still miss "printf"
and its functionality
Java 5 added java.util.Formatter with new
capabilities to all of Java's output methods
Formatting may be applied using the locale and
may be directed to a "sink" (often a file)
PrintStreamclass includes methods for "format()"
and "printf()" using the same formatting
characters; "format()" and "printf()" methods are
synonymous

35. Formatted Output (Cont)
 Here is an example of a numeric value being formatted using System.out.format()
--System.out.printf() works identically:
double balance = 1234.56;
System.out.format("Balance is$ %,6.2f",balance);
Output:Balance is $1,234.56
 Here is an example of a date being formatted
Date today = new Date();
System.out.format("nToday is %TF %TT", today,today);
Output:Today is 2005-06-09 20:15:26

36. Scanner Input (cont)
Java programs commonly use useSystem.in and its
"readLine()" method to access the keyboard
(requiring that IOExceptionbe handled)
Java 5 introduced the java.util.Scanner class
designed specifically to reduce the amount of code
needed to communicate with the keyboard

37. Scanner Input (cont)
Before jdk1.5
String firstName;
InputStreamReaderinStream= new
InputStreamReader(System.in);
BufferedReaderinBuf= new
BufferedReader(inStream);
System.out.print("Please enter your
first name => ");
try {
firstName= inBuf.readLine();
} // end of first try block
catch (IOException e) {
System.out.println("Problem reading
first name")
;return;
} // end catch block
After jdk1.5
String lastName;
System.out.print("Please enter your last name
=> ");
Scanner fromkeyboard= new
Scanner(System.in);l
lastName= fromkeyboard.next();

38. Scanner Input (cont)
next()
returns the next input buffer String
token
•next(comparePattern)
Or next(compareString)
uses patterns to return values
•Numeric variations include:
–nextBigDecimal()
–nextBigInteger()
–nextBoolean()
–nextByte()
–nextDouble()
–nextFloat()
–nextInt()
–nextLine()
–nextLong()
–nextShort()

39. Concurrency Utilities
Beginning with Java 5 (Java 1.5) the
java.util.concurrent.locks, java.util.concurrent, and
java.util.concurrent.atomicpackages are available
providing better locking support than provided by
the "synchronized" modifier.
All existing code still works as before
The java.util.concurrent.xxx packages include
interfaces and classes used to simplify
synchronization and locking

40. Concurrency Utilities(cont)
The java.util.concurrent.locks.Lockinterface has
several methods including:
–lock() to obtain a lock (blocks if can’t get lock)
–unlock() to release a lock
–lockInterruptibility() gets lock, allows interruptions
–tryLock() attempts to obtain a lock without a wait.
The java.util.concurrent.locks.ReentrantLockclass
behaves like using synchronized does today
The java.util.concurrent.locks.Conditioninterface
allows complex and multiple conditional waits
The
java.util.concurrent.locks.ReadWriteLockinterface
allows separate read/write locks

41. What is Class data sharing?
 Class data sharing (called CDS by Sun) is a mechanism which reduces
the startup time for Java applications, and also reduces memory
footprint. When the JRE is installed, the installer loads a set of classes
from the system jar file (the jar file containing all the Java class library,
called rt.jar) into a private internal representation, and dumps that
representation to a file, called a "shared archive".
 During subsequent JVM invocations, this shared archive is memory-
mapped in, saving the cost of loading those classes and allowing much
of the JVM's Metadata for these classes to be shared among
multiple JVM processes.The corresponding improvement for start-up
time is more noticeable for small programs.

42. What is StringBuilder ?
 New with Java 5, java.lang.StringBuilderclass provides a faster
alternative to StringBuffer
 In most ways StringBuilderworks exactly the same as
StringBuffer
 StringBuilderis faster than StringBufferbecause it is not
ThreadSafe(multiple threads should not access
StringBuilderobjects without Synchronizing)
 Use StringBuilderwhen speed is important in a single-thread
environment and use StringBufferif multiple threads might
require access.

43. StringBuilder Example (cont)
String myString= "How";
StringBuilder myStrBldr= new StringBuilder("How");
myString+= " now";
myString+= " Brown";
myString+= " Cow?";
myStrBldr.append(" now");
myStrBldr.append(" Brown");
myStrBldr.append(“Cow?");
System.out.println("String= " +myString);
System.out.println("StringBuilder= " + myStrBldr);

44. Changes in the array
java.util.Arrays.toString()
java.util.Arraysclass has new methods including a
toString() method to print the contents of any
array/collection
int[] anArray= { 1, 3, 5, 7, 9, 11, 13, 15, 16, 20 };
System.out.println(Arrays.toString(anArray));
Generates the following output:
[1, 3, 5, 7, 9, 11, 13, 15, 16, 20]

45. Changes in the array(cont)
Arrays.deepToString()
displays the contents of a multi-dimensional array:
int[][] apartment = new int[5][4];
The results of using Arrays.toString() and
Arrays.deepToString() are illustrated below. –
First, using Arrays.toString() the contents of the first level
show as addresses (Windows PC used for example):
[[I@10b62c9, [I@82ba41, [I@923e30, [I@130c19b,
[I@1f6a7b9]–
Next, using Arrays.deepToString() the contents of the array
are listed:[[0, 0, 0, 0], [0, 1, 2, 3], [0, 4, 5, 6], [0, 7, 8, 9], [0,
10, 11, 12]]

46. ?