The 9 new features in Java 9 are: 1) the Java Platform module system, 2) linking, 3) JShell interactive shell, 4) improved Javadoc search, 5) collection factory methods, 6) Stream API improvements, 7) private interface methods, 8) support for HTTP/2, and 9) multi-release JARs that allow libraries to use new Java features while maintaining backward compatibility.

1. 9 new features in Java 99 NEW FEATURES IN JAVA.
1. The Java Platform module system
2. Linking
3. JShell: the interactive Java REPL
4. Improved Javadoc
5.Stream API improvements
6.Private interface methods
7.HTTP/2
8.Multi-release JARs
9.Collection factory methods

2. 1. The Java Platform module system
The defining feature for Java 9 is an all-new module system.When codebases grow
the odds of creating complicated,tangled “spaghetti code” increase exponentially.
There are two fundamental problems:
1.It is hard to truly encapsulate code,
and there is no notion of explicit dependencies between different parts (JAR files) of a system
2.Every public class can be accessed by any other public class on the classpath,
leading to inadvertent usage of classes that weren't meant to be public API

3. 2. Linking
When you have modules with explicit dependencies,and a modularized J
new possibilities arise.
Your application modules now state their dependencies on other
application modules and on the modules it uses from the JDK
Why not use that information to create a minimal runtime environment,
containing just those modules necessary to run your application?
That's made possible with the new jlink tool in Java 9.
Instead of shipping your app with a fully loaded JDK installation,
you can create a minimal runtime image optimized for your application.

4. 3. JShell: the interactive Java REPL3
Many languages already feature an interactive Read-Eval-Print-Loop, and Java now joins this club.
You can launch jshell from the console and directly start typing and executing Java code.
The immediate feedback of jshell makes it a great tool to explore APIs and try out language features
Testing a Java regular expression is a great example of how jshell can make your life easier.
The interactive shell also makes for a great teaching environment and productivity boost,
which you can learn more about in this webinar
public static void main(String[] args)` nonsense is all about when teaching people how to code Java.

5. 4. Improved Javadoc
Sometimes it's the little things that can make a big difference. Did you useGoogle all the time to
the right Javadoc pages, just like me?hat's no longer necessary. Javadoc now includes search right
the API documentation itself.As an added bonus, the Javadoc output is now HTML5 compliant. Also
you'll notice that every Javadoc page includes information on which JDK module
the class or interface comes from.

6. 5. Collection factory methods
Often you want to create a collection in your code and directly pop
it with some elements That leads to repetitive codwhere you instan
the collection, followed by several `add` calls.
With Java 9, several so-called collection factory methods have
been added:
Set<Integer> ints = Set.of(1, 2, 3);
List<String> strings = List.of("first", "second");
Besides being shorter and nicer to read, these methods
also relieve you from having to pick a specific collection implement
In fact, the collection implementations returned from the factory me
are highly optimized for the number of elements you put in.
That's possible because they're immutable:
adding items to these collections after creation results in an
`UnsupportedOperationException`.

7. 6. Stream API improvements:
The Streams API is arguably one of the best improvements to
the Javastandard library in a long time. It allows you to
Create declarativepipelines of transformations on collections.
With Java 9, this only gets better. There are four new methods add
to the Stream interface:
dropWhile, takeWhile, ofNullable. The iterate method gets a new
overload,allowing you to provide a Predicate on when to stop
Iterating:
IntStream.iterate(1, i -> i < 100, i -> i + 1).forEach(System.out::printl
The second argument is a lambda that returns true until the current
element in the IntStream becomes 100. This simple example therefo
prints the integers 1 until 99 on the console.

8. 7. Private interface methods
Java 8 brought us default methods on interfaces. An interface can now also contain behavior
Instead of only method signatures. But what happens if you have several default methods on an
interface
with code that does almost the same thing? Normally, you'd refactor those methods to call a priv
method containing the shared functionality. But default methods can't be private.
Creating another default method with the shared code is not a solution, because this helper met
becomes part of the public API. With Java 9, you can add private helper methods to interfaces to
solve this problem:
public interface MyInterface {
void normalInterfaceMethod();
default void interfaceMethodWithDefault() { init(); }
default void anotherDefaultMethod() { init(); }
// This method is not part of the public API exposed by MyInterface
private void init() { System.out.println("Initializing"); }
}

9. 8. HTTP/2
A new way of performing HTTP calls arrives with Java 9. This much overdue replacement for the old
HttpURLConnection` API also supports WebSockets and HTTP/2 out of the box. One caveat:
The new HttpClient API is delivered as a so-called _incubator module_ in Java 9.
This means the API isn't guaranteed to be 100% final yet. Still, with the arrival of
Java 9 you can already start using this API:
HttpClient client = HttpClient.newHttpClient();
HttpRequest req =
HttpRequest.newBuilder(URI.create("http://www.google.com"))
.header("User-Agent","Java")
.GET()
.build();
HttpResponse<String> resp = client.send(req, HttpResponse.BodyHandler.asString());

10. 9. Multi-release JARs
The last feature we're highlighting is especially good news for library maintainers. When a newversio
of Java comes out, it takes years for all users of your library to switch to this new version.
That means the library has to be backward compatible with the oldest version of Java
you want to support (e.g., Java 6 or 7 in many cases).
That effectively means you won't get to use the new features of Java 9 in your library for a long time.
Fortunately, the multi-release JAR feature allows you to create alternate versions of classes that are
only used when running the library on a specific Java version:
multirelease.jar
├── META-INF
│ └── versions
│ └── 9
│ └── multirelease
│ └── Helper.class
├── multirelease
├── Helper.class
└── Main.class
n this case, multirelease.jar can be used on Java 9, where instead of the top-level multirelease.
Helper class, the one under `META-INF/versions/9` is used. This Java 9-specific
version of the class can use Java 9 features and libraries. At the same time, using this JAR on earlier
Java versions still works, since the older Java versions only see the top-level Helper class.