Table of Contents
Java 9, which was released on September 21, 2017, includes the following improvements that can help you to write better code more efficiently and in less time. Java 9 has just been released, and there are many new features and improvements that you need to know about if you are still using Java 8 as your programming language. If you are not familiar with Java 9, you should start now because it’s the first long-term support (LTS) release from Oracle, which will provide stability in the language until 2023. Here are Java 9 features and improvements that you should know about. Since Java 9 was released in July 2017, it’s grown immensely popular. In fact, Java 10 was recently released in March 2018! Still, many developers are curious about the new features introduced in this upgrade, especially since Java continues to be one of the most important programming languages out there today. To help you get up to speed with all of these new Java 9 features and improvements, we’ve created a handy list to introduce you to these changes and how they can benefit your codebase! Let’s jump right into it!
1) Release Date
March 20, 2017 (source) Java 9 is a major release of Oracle’s programming language that’s been around since 1995. It’s used to build websites, games, apps for mobile devices—pretty much anything you can think of. The new version includes a range of improvements and features that developers will want to know about. Here are 10 important changes in Java 9 that every developer should know about: 1. JShell – This feature allows developers to quickly test out snippets of code without having to create an entire project or class first. 2. HTTP/2 Client – This is one change you might not notice right away but it’s worth knowing about because it could save you time down the road when your website gets more traffic and needs faster loading times. 3. Local-Variable Type Inference – With local-variable type inference, you don’t have to specify what type of variable you’re using; instead, it’s inferred from how you use it. 4. Reactive Streams – Reactive Streams give developers a standard way to write asynchronous programs so they can be used across different platforms and frameworks 5. Multi-Release JAR Files – These files allow multiple versions of Java classes to be packaged into one file 6. Compact Strings – These strings consume less memory than regular strings 7. Process API Updates – There are several updates that affect how processes are managed 8. Time-Based Release Versioning – This new versioning scheme uses years and months instead of just numbers 9.
2) Project Jigsaw
3) Compiler Interface Project (Java Enhancement Proposal API)
The Compiler Interface Project (JEP 282) in JDK 9 aims to implement an enhanced, javac-based compiler interface that is able to take advantage of modern high-performance virtual machines. The new compiler would provide improved support for language features introduced after JDK 1.0, better diagnostics, faster compilation times, and performance on par with modern JVM languages. With its modular design, it will be easier to develop new language features in coming versions of Java without sacrificing interoperability with existing bytecode-based runtimes. This will make it possible to evolve both Java SE and Java ME independently from each other. It also means that future versions of Java can use different VMs and thus have different performance characteristics. For example, a version optimized for server use could use a VM designed for long-running processes while a version optimized for embedded devices could use a VM designed to maximize throughput. A prototype implementation was released as part of JDK 8u40. A separate proposal has been submitted by Oracle to standardize parts of it as part of JSR 292: Modular Source Code in Source Compatibility Format (SCF). SCF provides a standardized format which allows tools like IDEs or refactoring tools to work across multiple source code repositories regardless if they are hosted on GitHub or internally within an organization’s private network.
4) Generic Variables and Type Inference
Generic variables allow you to write code once and use it in multiple contexts. This allows you to reduce boilerplate code, remove errors related to typos, reduce repeated imports of APIs, or simply make code easier to read. The tradeoff is that there’s a little bit more flexibility when using generics that can introduce bugs if used improperly. Thankfully, type inference makes it easier for developers to figure out where generics are being used. Type inference will be coming into Java 9 via two new features: default method implementations on interfaces and a local variable type inference capability within methods. These capabilities can help improve code quality by making your intentions clearer to readers, but they also have their limitations. Default method implementations are only allowed on interfaces and only take effect at compile time; however, they don’t change how existing classes work—they just make it possible for future interface-based libraries to offer better defaults than before. Local variable type inference is less flexible than its static counterpart because you must declare all parameters at once rather than declaring them individually; however, its main advantage is that it works at runtime rather than compile time. Together these improvements should help programmers write cleaner code without sacrificing power or flexibility.
5) Local-Variable Type Inference
Type inference is one of several syntax improvements that streamline method calls. For example, you can now write Integer result = myObject.toString() instead of Integer result = myObject.toString(myObject);. In addition to reducing clutter in code, type inference also helps you avoid mistakes, because you don’t have to specify types when they’re obvious from context (i.e., in most cases). Another syntactic improvement involves default methods on interfaces: if an interface defines a default method named foo, subclasses no longer need to override it—unless they want to do something different from what was specified by its superclass. If a class doesn’t provide any implementation for foo, then its behavior will be determined by that of its superclass’s implementation. This allows for better modularity and extensibility without sacrificing interoperability with existing libraries.
6) Bulk Data Operations
In other words, you can now perform operations across multiple sets of data at once, instead of having to do each operation on an individual set. The new operations include count , sum , min , max , average value (for integers) etc. A simple example would be looping through a list of 1000 people and calculating their total age in milliseconds by summing up their birthdays. This should have taken a few minutes before Java 9, but now it will take mere milliseconds (thousands times faster). Note that if any one person has no birthday recorded, then that result is simply not calculated. With JDK 8’s Streams API you could achieve similar results using map/filter/reduce methods; however these methods are limited in that they can only operate on one object at a time. They cannot handle bulk operations because they are single-threaded, and thus very slow when applied to large collections of objects. The Bulk Data Operations feature allows for multi-threaded processing of bulk operations which makes them much more efficient.
7) Process API Updates
Just like Scala has a Process API, Java now has an update to that process-managing functionality. The new ProcessBuilder class allows users to easily create new subprocesses, with code that looks very similar to how you’d call out to a function or method. What’s more, if you’re handling exceptional conditions in your main application but want finer control over how those exceptions get handled inside of a subprocess (as opposed to just letting them bubble up), throwable instances can now be passed into each subprocess as well. This gives developers fine-grained error handling when creating new processes from within their own application code. In addition, there are also security updates for when existing connections are reused for multiple process calls. Now, if a user is trying to connect using incorrect credentials on one connection attempt, subsequent attempts will fail automatically.
8) Memory Model and Implementation
The latest version of Java provides some significant updates to memory management, which have been a concern in previous versions. The new features are Garbage-First (G1) and ZGC. G1 is designed to speed up garbage collection by making it smarter about when to stop collecting unused objects, while ZGC is more efficient for environments that don’t require as much heap space. Both upgrades are part of Project Metropolis, which also includes changes to JVM’s HotSpot compiler. The hope is that these changes will improve performance without having to introduce new levels of complexity into how applications work with memory. It’s a big step forward for an area that has traditionally proved tricky for programmers writing multi-threaded applications in Java. (source: cnet)
While there are several other enhancements—including local variable type inference—that could help streamline Java code further, most developers seem focused on Project Valhalla. While that project’s main focus is delivering true value types (rather than just value-based semantics), there’s another bonus being offered alongside that ability. Called reification, it would allow variables to report information about their values at run time. This means you could check whether variables hold valid data types or whether they refer to existing objects or interfaces before performing operations on them; if they don’t meet expected criteria, you can avoid bugs arising from misused code by throwing exceptions at run time instead of compile time.
9) New HTTP Client Implementation & WebSocket Client API
The new HTTP client, which is built on top of Netty, is available in two different flavors: a blocking flavor that resembles how HttpURLConnection works (this flavor will be merged with HttpURLConnection), and an asynchronous flavor that uses CompletableFuture to make use of Java 8’s new asynchronous support. The current HTTP client implementation is expected to reach end-of-life status once WebSocket Client becomes available for general use. More information about migrating from Apache httpclient can be found here . There are also plans to deprecate sun.misc.Unsafe in JDK 9 so it won’t be present in JDK 10 or later releases.
For more information see Java SE 9 Release Contents (including JEPs) and JDK Enhancement Proposal 310 : HTTP Client API 2.0 – New features & improvements! the WebSocket Client API provides a standard client-side API for use with WebSocket endpoints, allowing you to write code that is independent of any specific server implementation. The new API is based on Google’s SockJS . It supports both blocking and non-blocking operations, allowing you to build both full-duplex and half-duplex applications in a single programming model. In addition, it provides support for upgrading from HTTP/1.1 to WebSockets via an extensible framework that allows you to plug in your own protocol handlers when necessary.
10) Miscellaneous Changes
The Java team has also introduced a few changes for consumers who run their own JVMs. For starters, adding more cores to your computer won’t improve performance in 64-bit versions of Java 9; these iterations of the language don’t support simultaneous multithreading (SMT), or hyperthreading on Intel chips. That doesn’t mean you need an entirely new processor if you’re looking to boost performance, though—Java 9 will run with SMT turned off. If you have a Skylake or newer Intel processor that supports SMT3, however, it might be worth enabling since there is a slight performance improvement. With Java 9, Oracle says it’s no longer supporting Apple’s Safari browser as a browser plug-in. It was already disabled by default, but now Oracle is just cutting all ties altogether. This change may seem random at first glance, but when you consider Oracle sued Apple back in 2010 over claims that Safari infringed on some of its patents related to Java SE 6 implementation details , things start to make sense.
The new version of Java promises some major improvements over previous versions. From increased performance to an overall improved ecosystem, it’s no wonder there is a lot of excitement about what will be possible with Java 9. For developers looking for a solid foundation to create their next big project or business owners in need of a robust tool, these updates can make all the difference. So if you’re looking to jump on board with Java 9, here are some things you should know. If you are interested to learn new coding skills, the Entri app will help you to acquire them very easily. Entri app is following a structural study plan so that the students can learn very easily. If you don’t have a coding background, it won’t be any problem. You can download the Entri app from the google play store and enroll in your favorite course.