Java SE 6

The beta release of the Java 2 Platform, Standard Edition (J2SE) 1.5, started gaining momentum in the developer community due to its potential improvements to the language and its convincing feature set. J2SE 1.5, code named "Tiger," is being developed under the Java Community Process (JCP). The umbrella Java Specification Request (JSR) for this release is JSR 176. This article outlines the major features that are shipped with J2SE 1.5.0 Beta 1, which was released in February 2004. The final RI and TCK are targeted to be released in the summer of 2004.

Component JSRs in Tiger
JSR 176 defines the release contents of Tiger. There are at least 15 component JSRs that are developed under the JCP program and targeted toward the Tiger release. Table 1 details the JSRs along with their status as of this writing.

Detailed information about these JSRs is available at www.jcp.org/en/jsr/detail?id=JSR_NUMBER; simply replace the JSR_NUMBER with the actual JSR ID you are interested in. The status information mentioned in Table 1 was obtained from the individual JSR page in the JCP Web site. Some of this status information may not be current.

Generics
What Are Generics?
Generics are also called as parameterized types (often referred to as type polymorphism). To be more precise, Generics are similar to the powerful C++ templates but don't have the potential drawbacks faced by templates. Generics make type parameters explicit and type casts implicit, making the use of libraries safer and more flexible (e.g., the collections library).

The generics support in Java is the most frequently requested language feature from Java developers. This feature has been postponed for quite some time as it requires changes to the Java language specification, and also updates to the Java Virtual Machine (JVM) specification. Finally, this feature stands as the top-most priority for the Tiger release.

Generics Types
There are two forms of generics types.

• Parameterized types
• Type variables

A parameterized type consists of a class or interface type C and a parameter section <T1,. . .,Tn>. C must be the name of a parameterized class or interface; the types in the parameter list <T1,. . .,Tn> must match the number of declared parameters of C; and each actual parameter must be a subtype of the formal parameter's bound types.

As stated in section 2.1 of "Adding Generics to the Java Programming Language: Participant Draft Specification" dated April 27, 2001: "a type variable is an unqualified identifier. Type variables are introduced by parameterized class and interface declarations and polymorphic method declarations."

The generics syntax allows developers to enforce parameters, extend a class, or implement an interface. This helps restrict the type of parameters for a generic class/interface/ method and they are referred to as bound types. Listing 1 details the usage of generics in parameterized types, classes, interfaces, and methods.

Generics Advantage
The following code snippet shows the usage of generics in collection libraries. When using generics, you need to define the type the collection can hold. This helps the collection maintain homogeneous objects. If an undefined type is added to this collection, you'll be notified of errors at compile time. This helps us identify the cause of the problem during development time.

On the contrary, the traditional way of using heterogeneous objects in a collection may result in runtime errors. Sometimes these errors are uncovered during deployment, which is very crucial to the product quality.

With Generics
Map<String, Integer> map = new HashMap<String, Integer>();
map.put("one", new Integer(1));
Integer integer = map.values().iterator().next();

Without Generics
Map map = new HashMap();
map.put("one", new Integer(1));
Integer integer = (Integer)map.values().iterator().next();

Thus the generics approach is more readable and powerful than the traditional approach.

Collection Filtering
Filtering a collection is prone to ClassCastExceptions when the collection elements are heterogeneous, and may fail at runtime due to invalid casts. This behavior is overcome by the use of generics in collection filtering, which helps developers detect the errors at compile time. Listing 2 shows the current collection filtering and filtering collection with generics. (Listings 2-6 can be downloaded from www.sys-con.com/java/sourcec.cfm.)

Getting Started with Tiger
Download the J2SE 1.5.0 Beta 1 release from http://java.sun.com/j2se/1.5.0/download.jsp.

By default, the installer places the JDK directory under "C:\ Program Files\Java\j2sdk1.5.0". The Java Language Specification (JLS) implemented by the javac compiler in the Tiger beta release is version 1.4. To play with the new language features, its required to pass the argument -source 1.5 to the javac command.

IDEs that Support Generics and Other New Language Features
IDEs are available for writing generics-enabled code today, in addition to other new language features:

• Omnicore CodeGuide 6.1: www.omnicore.com/codeguide.htm
• IntelliJ IDEA 4.0: www.jetbrains.com/idea/
• Eclipse Java IDE: www.eclipse.org/jdt/index.html

Typesafe Enumerations
What Is Enum?
Enum is a special kind of class declaration. A typesafe enum facility defines a fixed set of constant legal values for types. This feature is borrowed from the C language and has been incorporated into the Java language in the Tiger release.

Advantages of Enum
The proposed enum facility has more advantages when compared to the traditional int enum approach in Java.

The advantages are:

• Enum provides compile time type safety.
• Enum provides proper name spacing for its types.
• Performance is comparable to int constants.
• Typesafe constants do not require a compilation when clients modify constants.
• Printed values are informative.
• Enum can be used in collections as they are objects.
• Enum is a special kind of class declaration, hence you can add arbitrary fields and methods.
• Enum can be made to implement arbitrary interfaces.

Traditional Enum Pattern
The commonly used pattern for enumerated types in Java suffers from many drawbacks as shown in the following code. In this approach, whenever you modify the client code, you need to recompile.

public class Continent {
public static final int CONTINENT_AFRICA = 0;
public static final int CONTINENT _ASIA = 1;
public static final int CONTINENT _EUROPE = 2;
public static final int CONTINENT_NORTH_AMERICA = 3;
public static final int CONTINENT_OCEANIA = 4;
public static final int CONTINENT_SOUTH_AMERICA = 5;
}

Typesafe Enum Pattern
Java provides an alternative method to overcome the drawbacks of the traditional approach, called the typesafe enum pattern. This pattern defines a class that represents a single element of an enumerated type that doesn't provide any public constructors to it. Provide static final fields for each constant in the enumerated type. Listing 3 shows this pattern approach. This pattern provides compile time type safety by allowing only the six continents defined to be passed to a method that defines a parameter of type Continent.

Proposed Enum Facility
The proposed facility is simple and readable. The construct can be used with switch statements. Listing 4 shows the usage of the proposed enum facility for the Java language.

Autoboxing
What Is Autoboxing?
Developers are burdened when they convert primitive types to wrapper (reference) types (for example, converting int to Integer type). Adding primitive types to a collection is not possible unless they are converted to the corresponding reference type. To overcome this drawback of the current type system, the need for the automatic conversion of primitive type data to their corresponding wrapper type data was proposed. This conversion mechanism is known as autoboxing.

Listing 5 illustrates the code that achieves autoboxing in a collection. In this code sample, primitive type int is added to a collection that holds an Integer reference. The compiler takes care of type conversion for you.

There are several other forms of conversion that are supported by the compiler. Refer to JSR 201 for more information (http://jcp.org/aboutJava/communityprocess/jsr/tiger/autoboxing.html).

Enhanced For Statement
What's Wrong with the Current For Statement?
The current for statement is efficient and powerful in all aspects, but it's not optimized when it iterates over a collection, as the iterators are used only to get elements out of a collection and serve no other purpose. Generics helped make this situation better by adding the type safety to the collection. This resulted in proposing "enhanced for" statements with generics additions to them. With this new feature, the compiler takes care of the iterator for you. Listing 6 details the usage of "enhanced for" statements.

Using an "Enhanced For" Statement in an Int Array
The "enhanced for loop" has been specifically designed for iteration over collections and arrays. Its usage in an integer array is shown below:

public class TestIntegerArrayUsingEnhancedForLoop {
public static void main(String args[]) {
int [] a = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int sum = 0;
for (int e : a)
sum += e;
System.out.println("Array Sum : " + sum);
}
}

Static Import
Rationale for Static Import
In Java, when using any mathematical functions from the "java.lang.Math" package or when using named constants, you have to prefix the method name or field name with the class name. This way of coding looks more verbose. To make it more convenient for developers, the concept of static import was proposed. Using this, you can allow the import of static methods and fields similar to the import of classes and interfaces.

import static java.lang.StrictMath.*; // import static
import static java.lang.System.*; // import static

public class StaticImport {
static void testStaticImport() {
out.println("The square root of PI is : " + sqrt(PI));
}
public static void main(String args[]) {
testStaticImport();
}
}

In the above code snippet, the usage of static import is illustrated. The traditional approach is discussed below.

When accessing a static method, you need to prefix with the class name, for example:

Math.sqrt(Math.PI);
StrictMath.IEEEremainder(4.0, 2.0);
System.out.println("hello");

When accessing named constants, you need to prefix with the class name. For example:

class Suit {
public static final int CLUBS = 0;
public static final int DIAMONDS = 1;
public static final int HEARTS = 3;
public static final int SPADES = 4;
}
Suit.CLUBS
Suit.DIAMONDS
Suit.HEARTS
Suit.SPADES

This approach makes code more verbose. The static import helps you overcome this approach. This is a simple yet convincing feature for developers.

Conclusion
The features discussed in this article are only a subset of the features that are shipped with the Tiger beta release. These features are developer savvy and powerful additions to the Java programming language. The listings in this article are tested with J2SE 1.5.0 Beta 1 release. JSR 176 is currently available for public review at www.jcp.org/en/jsr/detail?id=176.

References

Java 2 Platform, Standard Edition 1.5.0 Beta 1 release: http://java.sun.com/j2se/1.5.0/download.jsp

J2SE v 1.5.0 Beta 1 Documentation: http://java.sun.com/j2se/1.5.0/docs/index.html

JSR 176, J2SE 1.5 (Tiger) Release Contents: www.jcp.org/en/jsr/detail?id=176

JSR 14, Add Generic Types to the Java Programming Language: www.jcp.org/en/jsr/detail?id=014

JSR 201, Extending the Java Programming Language with Enumerations, Autoboxing, Enhanced For Loops, and Static Import: www.jcp.org/en/jsr/detail?id=201