Java 8 New Features

Java LogoLast month’s release of Java 8 came with a slew of changes that are beginning to be picked up by the local informatics community. At this month’s San Diego Java User Group, John Clingan (Oracle Product Manager for Java EE and Glassfish) gave us an update on some of the new features. You can find out more about Java 8 at the Launch Webcast here.

Here’s a brief list of some of the new features along with some links to tutorials to help you make the most of them.

While delving into some of these features I came across some interesting surprises and side benefits associated with Java 8.

Improvements to Collections
With the addition of lambda expressions to Java, one of the long-standing holes in the language has now been filled.  Most Java developers have been adding Apache Commons Collections, or Google’s Guava library to their projects to add support for Predicates, and Functions.  Both of these libraries contain support for Predicate-based filtering, and Function’s that can be applied to each element in a collection.

With the latest release of Java, the new java.util.function package contains new interfaces for Predicate and Function with default methods. A removeIf method was added to the Collection interface to make it easier to filter a collection using a Predicate.

Over the years, this long-requested change to the Collections API has gone unfulfilled due to impact that such a change would have on collections like ArrayList, HashMap, etc. However, the new default method functionality made it possible to add support for functions and predicates without causing a lot of code to break.

Parallelism
The poorly named “Streams” API came with an extra added benefit.  You can now switch from stream() to parallelStream() and execute each stream in parallel. ParallelStream is backed by a ForkJoinPool, which means that your streams automatically execute across all available processors without all the extra boilerplate code traditionally required to create and submit ForkJoinTasks.

Annotations On Method Parameters
We’re used to seeing annotations at the class level (@Entity), and at the method declaration level (@Overload), but now we can annotate method parameters, and class attributes.  So if you want to indicate that a list can’t be empty you simply declare it with the @NonEmpty annotation. If you want to indicate that a String can’t be null, you can use the @NonNull.  If the String is an email address use @Email.  You can find some examples here and here.

JavaFX
For the past 6 years, Oracle has been working on JavaFX, its official replacement for Swing.  JavaFX has a number of advantages over Swing (including better performance, CSS for styling, FXML for user-interface creation, and much, much more — too much to talk about here).

With Java 8, Oracle added video, and audio recording, a new default skin called Modena, printing support, a DatePicker and TreeTable, support for Nashorn in WebView, 3D support, embedded Swing components, improved styled text support via the TextFlow class, support for web fonts, numerous bug fixes and performance improvements.  In addition, a new version of SceneBuilder has support for all of the latest components.

Nashorn shell scripting
Javascript support in the JavaVM has been one of the most overlooked features.  You don’t see that many people creating javascript shell scripts, even though that capability has been available since Java 6 via the jrunscript engine which ships with the JDK.

But recently, the Rhino JavaScript engine was replaced with Nashorn (“nahz-horn” — German for Rhino).  This new scripting engine is faster and provides better shell scripting support within JavaScript.

Nashorn makes it even easier to create shell scripts that will run wherever you have Java installed. You simply use #!/usr/bin/jjs as your shebang line in your shell script, and off you go. You can find more information about it here. The only thing missing from all of this is support for dependency resolution.  In Groovy, we have the @Grab annotation which we can use to insure that all of the dependencies needed by the script are downloaded and made available at runtime.  Nashorn doesn’t have this capability yet, and we hope to see it soon.

Nashorn on the Server
Part of the reason that Oracle spent so much time and effort on Nashorn in this release, was the increasing popularity of Node.js.  Node is a platform built on top of Google Chrome’s JavaScript engine that allows you to run JavaScript on the server.  This makes it possible to create an application that uses JavaScript at both the user-interface, middle-tier, and database levels of a web application.  The MEAN stack (MongoDB, ExpressJS, AngularJS, and Node.js) is intended to do just this.

Oracle’s approach to this is to make Nashorn the engine that runs that stack.  The Avatar.js [Avatar Tutorial]project makes MongoDB, ExpressJS and a number of other frameworks available as part of your server ecosystem.

Project Sumatra: Java on the GPU
GPUs have gotten a lot of attention over the past few years as a means of executing computationally intensive tasks.  For most developers interested in GPUs though, it has meant having to learn or re-learn the C toolset and having to port code over to run on GPUs.

Project Sumatra’s goal though is to provide the Java developer a means of letting Java code run on GPUs.  This makes it possible to use the new streams capabilities across multiple GPUs.

What does this mean for informatics?

  • Simpler, easier to maintain code with lambdas.
  • Parallelization is now easier.
  • Default methods make it easier to update older interface definitions without impacting existing code.
  • Nashorn support for shell scripting makes it easier to call Java code from within shell scripts.
  • JavaScript on the server making a Node-like stack possible for the Java VM — which in turn means potentially faster development times.
  • Improved performance
  • Ability to leverage GPUs

 

Advertisements

About aspenbio

I write software for scientists. I'm interested in Java/Groovy/Grails, the Semantic Web and Cancer Biology.
This entry was posted in Bioinformatics, Informatics, Java and tagged , , . Bookmark the permalink.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s