Java 9

New Features of Java 9: Quick Summary

While much of this may not mean a great deal to a business owner, the new features of Java 9 have lots of meaning for developers, as they look at what’s new. Here is an overview of four of the most important.

  • Jshell: This is a new command line tool. It means that if a developer wants to run just a few lines of Java as a standalone, it can be done without having to wrap it all in a separate method or project.
  • Microbenchmarks: Now, the performance of very specific and small pieces of code can be measured with a standardized method. The Java harness (JMH) for analyzing down to nanoseconds is unique to Java 9.
  • Full Support for HTTP 2.0 Client: This is a speed thing, and HTTP 2.0 Client has shown to provide greater speed, ranging from 11.81% to 47.7% over HTTP 1.1 Client.
  • Process API: An API (application programming interface) allows app’s processes communicate with each other without using native code. This update in Java 9 will extend the ability of Java in controlling and managing OS processes.
  • Modular Source Code: Organizes JDK source code into modules.

Comparison of Java 8 and Java 9

Java 8 features have given developers remarkable versatility and the ability to provide software solutions to a wide variety of business sectors, including fintech, healthcare, and other industries.

The coming of Java 9, however, promises to deliver even more versatility and the ability to customize even further. For businesses, this is a huge plus.

Here, in rather simplistic terms, are just some new features of Java 9 that Java 8 did not have.

The Reason for the Title “Jigsaw

Project Jigsaw is the modularization of Java. Basically, it means that programming code is broken up and organized into modules based upon the tasks that those modules execute. By doing this, modules are reusable and far easier to manage and debug. This means that software development becomes easier, more streamlined, and debugged faster. This is a key difference between Java 8 and Java 9.

The second big benefit – it makes the Java Platform more lightweight and more scalable. It allows Java applications to run even on devices with low productivity (requires less resource to work).

The Jshell Command Line Tool

As mentioned above, this is an interactive tool that will allow testing of small snippets of code rather than requiring the creation of a new class. This new shell also comes with history and auto-completion features as well as other functionalities, like saving and loading some or all written statements.

Multi-Resolution Image

This API will allow the encapsulation of a set of images that all have different resolutions into a single object. Thus, a developer can retrieve an image that is resolution-specific or retrieve all variants within the image.

Unified JVM Logging

Now there is a common logging system for all JVM components. However, if we look at pros and cons of Java 9, here is one. It doesn’t add logging calls from all JVM components and doesn’t add logging to Java code in the Java Development Kit.

Publish-Subscribe Framework

This is an improvement over Java 8, as these interfaces will better support the interoperability of a number of asynchronous systems that run on JVM’s (Java Virtual Machines). The idea behind JVM’s is that they allow any computer to run a Java program, by converting Java code into machine language and then executing it. Improvements in this area are one of the big advantages of Java 9.

Immutable List, Set, Map, and Map.Entry API

In Java 8, to create a collection of several elements, a developer had to create several lines of code. Now it can be accomplished in a single line of code. One of the time-consuming disadvantages of Java 8 has thus been eliminated.

I’m expecting the Stream API Improvements. Why? It will facilitate the work with arrays and accelerate various functions.

As an example, check this:

Stream.of(1,2,3,4,5,6,7,8,9,10).takeWhile(i -> i < 5 ).forEach(System.out::println);

Will deliver: 1 2 3 4

Looks promising, isn’t it?

Benefits of Java 9 For Businesses

Granted, the details of Java 8 vs. Java 9 may not be of huge interest to the business looking for the best software solutions to meet its needs. To the developer, however, there will be a significant difference between Java 8 vs. Java 9 performance in creating those software solutions.

Whether using Java SE 9 or any other version, dependent upon the business need, the inclusion of the latest features will bring about improvements in the following:

  • Greater speed of development, specifically due to the system of modules which are reusable and much easier to debug and to manage.
  • One more benefit of the system of modules is that it will improve the resource effectiveness of applications (small or big ones) as for their development programmers will need to take only needed modules instead of all JRE.
  • Creation of sets using a single rather than several lines of code.
  • Microbenchmarks that will allow performance analysis of very small pieces of code.
  • Support for HTTP 2.0 Client – greater speed.

And this is just a partial list. But all of these and the other new features make the developer’s job of designing the roadmap for a custom business solution and then creating the software based upon that roadmap more streamlined. That streamlining of developing, testing and debugging means that the final product will have far fewer issues that need to be addressed. In this type of development environment, everyone wins.


The goal of this Project was to produce an open-source reference implementation of the Java SE 9 Platform as defined by JSR 379 in the Java Community Process.

JDK 9 reached General Availability on 21 September 2017. Production-ready binaries under the GPL are available from Oracle; binaries from other vendors will follow shortly.

The features and schedule of this release were proposed and tracked via the JEP Process, as amended by the JEP 2.0 proposal.


  • Process API Updates
  • HTTP 2 Client
  • Improve Contended Locking
  • Unified JVM Logging
  • Compiler Control
  • Variable Handles
  • Segmented Code Cache
  • Smart Java Compilation, Phase Two
  • The Modular JDK
  • Modular Source Code
  • Elide Deprecation Warnings on Import Statements
  • Resolve Lint and Doclint Warnings
  • Milling Project Coin
  • Remove GC Combinations Deprecated in JDK 8
  • Tiered Attribution for javac
  • Process Import Statements Correctly
  • Annotations Pipeline 2.0
  • Datagram Transport Layer Security (DTLS)
  • Modular Run-Time Images
  • Simplified Doclet API
  • jshell* The Java Shell (Read-Eval-Print Loop)
  • New Version-String Scheme
  • HTML5 Javadoc
  • Javadoc Search
  • UTF-8 Property Files
  • Unicode 7.0
  • Add More Diagnostic Commands
  • Create PKCS12 Keystores by Default
  • Remove Launch-Time JRE Version Selection
  • Improve Secure Application Performance
  • Generate Run-Time Compiler Tests Automatically
  • Test Class-File Attributes Generated by javac
  • Parser API for Nashorn
  • Linux/AArch64 Port
  • Multi-Release JAR Files
  • Remove the JVM TI hprof Agent
  • Remove the jhat Tool
  • Java-Level JVM Compiler Interface
  • TLS Application-Layer Protocol Negotiation Extension
  • Validate JVM Command-Line Flag Arguments
  • Leverage CPU Instructions for GHASH and RSA
  • Compile for Older Platform Versions
  • Make G1 the Default Garbage Collector
  • OCSP Stapling for TLS
  • Store Interned Strings in CDS Archives
  • Multi-Resolution Images
  • Use CLDR Locale Data by Default
  • Prepare JavaFX UI Controls & CSS APIs for Modularization
  • Compact Strings
  • Merge Selected Xerces 2.11.0 Updates into JAXP
  • BeanInfo Annotations
  • Update JavaFX/Media to Newer Version of GStreamer
  • HarfBuzz Font-Layout Engine
  • Stack-Walking API
  • Encapsulate Most Internal APIs
  • Module System
  • TIFF Image I/O
  • HiDPI Graphics on Windows and Linux
  • Platform Logging API and Service
  • Marlin Graphics Renderer
  • More Concurrency Updates
  • Unicode 8.0
  • XML Catalogs
  • Convenience Factory Methods for Collections
  • Reserved Stack Areas for Critical Sections
  • Unified GC Logging
  • Platform-Specific Desktop Features
  • DRBG-Based SecureRandom Implementations
  • Enhanced Method Handles
  • Modular Java Application Packaging
  • Dynamic Linking of Language-Defined Object Models
  • Enhanced Deprecation
  • Additional Tests for Humongous Objects in G1
  • Improve Test-Failure Troubleshooting
  • Indify String Concatenation
  • HotSpot C++ Unit-Test Framework
  • jlink* The Java Linker
  • Enable GTK 3 on Linux
  • New HotSpot Build System
  • Spin-Wait Hints
  • SHA-3 Hash Algorithms
  • Disable SHA-1 Certificates
  • Deprecate the Applet API
  • Filter Incoming Serialization Data
  • Deprecate the Concurrent Mark Sweep (CMS) Garbage Collector
  • Implement Selected ECMAScript 6 Features in Nashorn
  • Linux/s390x Port
  • Ahead-of-Time Compilation
  • Unified arm32/arm64 Port
  • Remove Demos and Samples
  • Reorganize Documentation

source: [1]