{"id":7962,"date":"2018-04-24T10:09:36","date_gmt":"2018-04-24T10:09:36","guid":{"rendered":"https:\/\/weblizar.com\/blog\/?p=7962"},"modified":"2025-08-11T12:14:44","modified_gmt":"2025-08-11T06:44:44","slug":"java-all-you-need-know-about-the-features-new-java","status":"publish","type":"post","link":"https:\/\/weblizar.com\/blog\/java-all-you-need-know-about-the-features-new-java\/","title":{"rendered":"Java 9 – All You Need To Know About The Features Of New Java"},"content":{"rendered":"

Java, the highly accessible programming language has been a no-brainer for developers across the globe. Ever since it\u2019s inception in 1995, the language has seen wide usage across various industries.<\/p>\n

Today, you will find Java on your phones. Powering Android OS and the myriad range of apps that Android offers. It is used for developing games like Minecraft which has a huge player-base. It also finds use in business applications like reading credit card information at shop tills and feeding the information between the systems and the banks.<\/p>\n

After a gap of 3 years, Java rolled out its new edition \u2013 Java SE 9. With several key architectural changes and add-on features, Java SE 9 offers a powerful solution that developers had been yearning for.<\/p>\n

Java 7 added try-with-resource in 2011, offering better resource management functionality.
\nJava 8 added lambda expressions, a good move but slightly flawed under OOP paradigm.<\/p>\n

Now Java Solutions<\/strong><\/a> allows programmers to have private methods. Private static methods! YES, you read that right!<\/p>\n

Java SE 8 offered many structural changes that were received with mixed emotions by developers. Majorly, these are the shortcomings of Java SE 8 that Java SE 9 has tried to overcome:<\/p>\n

    \n
  1. The JDK was not navigable for the small computing device<\/li>\n
  2. There was no overall improvement in application performance<\/li>\n
  3. There was no overall security and maintenance of JDK<\/li>\n
  4. Java developers faced difficulty to build and uphold the code libraries and larger application<\/li>\n<\/ol>\n

    So, let\u2019s look at the key changes and enhancements that Java 9 offers over its predecessors<\/p>\n

     <\/p>\n

    Process API updates in Java 9<\/strong><\/p>\n

    Traditionally, Java\u2019s API has been primitive in nature. That support to launch new processes, redirect output and error streams. In Java 9, the new updates to the Process API enable:<\/p>\n

      \n
    1. Getting the PID of the current and any other JVM process<\/li>\n
    2. Managing subprocesses<\/li>\n
    3. Managing subprocesses<\/li>\n
    4. Get information such as PID, name, and resource usage of the processes running in the system.<\/li>\n<\/ol>\n

      This is a sample code, which prints the current PID as well as the current process information:<\/p>\n

      public class NewFeatures
      \n{
      \npublic static void main(String [] args)
      \n{
      \nProcessHandle currentProcess = ProcessHandle.current();
      \nSystem.out.println(\"PID:\"+ currentProcess.getPid());
      \nProcessHandle.Info currentProcessInfo = currentProcess.info();
      \nSystem.out.println(\"Info:\" + currentProcessInfo);
      \n}
      \n}
      \n<\/code><\/p>\n

      HTTP\/2 client in Java 9<\/strong><\/p>\n

      This feature is expected to be reformed in the subsequent releases or may even be removed completely.
      \nPreviously developers would rely on the third-party libraries, for examles Apache HTTP, Jersey, and so many. The Java\u2019s HTTP API predates the HTTP\/1.1 specification and is synchronous and hard to maintain. These limitations called for the need to add a new API. The new HTTP client API provides the following:<\/p>\n

        \n
      1. A simple and concise API to deal with most HTTP requests<\/li>\n
      2. Support for HTTP\/2 specification<\/li>\n
      3. Better performance<\/li>\n
      4. Better security<\/li>\n
      5. A few more enhancements<\/li>\n<\/ol>\n

        Here is a code snippet to make an HTTP GET request using the new APIs. This is the module as defined in the file module-info.java:<\/p>\n

        module newfeatures{
        \nrequires jdk.incubator.httpclient;
        \n}
        \n<\/code>
        \nThe following code uses HTTP Client API. This is a part of jdk.incubator.httpclient<\/em> module:<\/p>\n

        import jdk.incubator.http.*;
        \nimport java.net.URI;
        \npublic class Http2Feature{
        \npublic static void main(String[] args) throws Exception{
        \nHttpClient client = HttpClient.newBuilder().build();
        \nHttpRequest request = HttpRequest
        \n.newBuilder(new URI(http:\/\/httpbin.org\/get;))
        \n.GET()
        \n.version(HttpClient.Version.HTTP_1_1)
        \n.build();
        \nHttpResponse.String response = client.send(request,
        \nHttpResponse.BodyHandler.asString());
        \nSystem.out.println(\"Status code:\" + response.statusCode());
        \nSystem.out.println(\"Response Body:\" + response.body());
        \n}
        \n}
        \n}
        \n<\/code>
        \nMore Concurrency Updates feature in Java 9<\/strong><\/p>\n

        With Java 9, a new class called – java.util.concurrent.Flow has been introduced, which supports the implementation of a publish-subscribe framework. This framework enables developers to build components. These components can asynchronously consume a live stream of data by setting up publishers that produce the data and subscribers that consume the data. These are the new interfaces:<\/p>\n