Manish Chhabra's Blog

The development of Java Programming language continues, albeit a bit slow. Oracle announced availability of Java SE 7 on 28th July 2011 (link).  It took nearly 5 years after the release of Java 6 in December 2006, but still it shipped with bugs (example). But now after two updates (Update 1 in Oct 2011 and Update 2 in Dec 2011) you might seriously start looking at some cool new features of Java 7.

You can download the new JDK from here.

Here is a list of some of the new features in Java SE 7

• Diamond Operator (GENERICS)

You may have noted on many occasions your IDE complaining of types when working with Generics. For example, if we have to declare a map of trades using Generics, we write the code as follows:

Map<String, List<Trade>> trades = new TreeMap<String, List<Trade>> ();

The not-so-nice thing about this declaration is that we must declare the types on both the sides, although the right-hand side seems a bit redundant. Can the compiler infer the types by looking at the left-hand-side declaration? Not unless you’re using Java 7. In 7, it’s written like this:

Map<String, List<Trade>> trades = new TreeMap<> ();

Saves a few keystrokes without removing any type safety. Nice but small improvement.

• Automatic Resource Management

This is the try-with-resources or Automatic Resource Management block. If you declare a variable in the try() statement, Java automatically calls close on it, like you would in a finally block. This is a small improvement, but nice. You can use try-with-resources on your own object by implementing the new interface java.lang.AutoCloseable.

try ( BufferedReader reader = new BufferedReader(new FileReader(...))) {
    String line = reader.readLine();
    process(line);
}

•  Improved exception handling

There are a couple of improvements in the exception handling area. Java 7 introduced multi-catch functionality to catch multiple exception types using a single catch block.

Let’s say you have a method that throws three exceptions. In the current state, you would deal them individually as shown in below:

public void oldMultiCatch() {
    try {
        methodThatThrowsThreeExceptions();
    } catch (ExceptionOne e) {
        // log and deal with ExceptionOne
    } catch (ExceptionTwo e) {
        // log and deal with ExceptionTwo
    } catch (ExceptionThree e) {
        // log and deal with ExceptionThree
    }
}

Catching an endless number of exceptions one after the other in a catch block looks cluttered and I have seen code that catches a dozen exceptions. This is incredibly inefficient and error prone. Java 7 has brought in a new language change to address this ugly duckling. See the improved version of the method oldMultiCatch() below:

public void newMultiCatch() {
    try {
        methodThatThrowsThreeExceptions();
    } catch (ExceptionOne | ExceptionTwo | ExceptionThree e) {
        // log and deal with all Exceptions
    }
}

The multiple exceptions are caught in one catch block by using a ‘|’ operator. This way, you do not have to write dozens of exception catches.

• Using strings in switch statements

Switch statements work either with primitive types or enumerated types. Java 7 introduced another type that we can use in Switch statements: the String type.

Say we have a requirement to process a Trade based on its status. Until now we used to do this by using if-else statements.

private void processTrade(Trade t) {
    String status = t.getStatus();
    if (status.equalsIgnoreCase(NEW)) {
        newTrade(t);
    } else if (status.equalsIgnoreCase(EXECUTE)) {
        executeTrade(t);
    } else if (status.equalsIgnoreCase(PENDING)) {
        pendingTrade(t);
    }
}

This method of working on strings is crude. In Java 7, we can improve the program by utilizing the enhanced Switch statement, which takes a String type as an argument.

public void processTrade(Trade t) {
    String status = t.getStatus();
    switch (status) {
        case NEW:
          newTrade(t);
          break;
        case EXECUTE:
          executeTrade(t);
          break;
        case PENDING:
          pendingTrade(t);
          break;
    }
}

In the above program, the status field is always compared against the case label by using the String.equals()method.

• Improved File IO API

There are quite a bit of changes in the java.nio package. Many are geared towards performance improvements, but long awaited enhancements over java.io (specially java.io.File) have finally materialized in a new package called java.nio.file.

For example, to read a small file and print all the lines;

	List lines =  Files.readAllLines(
	FileSystems.getDefault().getPath("test.txt"), StandardCharsets.UTF_8);  

	for (String line : lines) System.out.println(line);

java.nio.file.Path is an interface that pretty much serves as a replacement for java.io.File, we need a java.nio.file.FileSystem to get paths, which you can get by using thejava.nio.file.FileSystems factory (getDefault() gives you the default file system).

java.nio.file.Files then provides static methods for file related operations. In this example we can read a whole file much more easily by using readAllLines(). This class also has methods to create symbolic links, which was impossible to do pre-Java 7. Another feature long overdue is the ability to set file permissions for POSIX compliant file systems via the Files.setPosixFilePermissions method. These are all long over due file related operations, impossible without JNI methods or System.exec() hacks.

I didn’t have time to play with it but this package also contains a very interesting capability via the WatchService API which allows notification of file changes. You can for example, register directories you want to watch and get notified when a file is added, removed or updated. Before, this required manually polling the directories, which is not fun code to write.

For more on monitoring changes read this tutorial from Oracle.

JVM changes

The Java virtual machine gets a new instruction: invokedynamic. Using invokedynamic, the JVM can invoke a method on an object without having to know on which class or interface the method is declared. If it walks like a duck and talks like a duck…
Invokedynamic will be very helpful for implementors of dynamic languages in the JVM, so it’s great. But the average developer will never encounter it in the wild.

Library changes

Looking at the release notes for Java 7, you may first suspect that there are some interesting library changes here. However, when examining the list more thoroughly, I couldn’t find a single change that I expect I will actually use. The library changes are mostly low-level, behind the scenes fixes of small problems.

Conclusions

So there it is: try-with-resources, multi-catch and a very limited type inference. Hopefully, Java 8 will be released as planned in early 2013 with all the stuff we’ve been waiting for. If so, I expect most shops will skip Java 7 and jump straight to Java 8. But hopefully Java 8 won’t follow the pattern of delays from Java 7.