Install Java 11 Ubuntu

Java 11 is the 2nd long-term release after Java 8. Oracle JDK will no longer be free for financial use since Java 11. We can use it in the integrating stages, but we need to purchase a license to commercially use it. If we do not, we can receive an invoice bill by Oracle. Java 10 version was the last no-cost Oracle JDK that can be downloaded.

From January 2019, Oracle stops support for Java 8. We will have to pay for more support. We can continue with it but would not get security/patch updates. Oracle will not be offering free LTS support for one Java release since Java 11. We can always install the builds of Open JDK from Oracle or many other providers, like Red Hat, IBM, Azul, AdoptOpenJDK, etc., while Oracle JDK is not free.

Which Build of Java Should We Download?

Since Oracle has made a release train where a new release will come up every 6 months, if we are using a no-cost Open JDK via Oracle, we have to update it every 6 months because Oracle would not give free updates when the new release is published. It can be challenging to accept a company. Pay for financial support to Oracle and shift only from a single Java release to the next LTS release.

We will get every update this way and Java 11 support till 2026. We can install Java 17 in 2022. Stay on no-cost Java release even after its support completes. Though we would not receive security updates, it could open up loopholes in security. Oracle would not offer commercial updates or support for Java 10 and Java 9. We have to look for another alternative build to continue with them for no-cost.

Features of Java 11

• New HTTP Client
  Java 11 is composed of a new HTTP client. It included the client in the java.net.http package/module and consists of the below essential classes and interfaces:
  • WebSocket is the access point to build up a WebSocket client.
  • HttpResponse is the output of an HttpRequest call.
  • HttpRequest is a claim to be transferred from the HttpClient.
  • HttpClient is the access point to utilize the API.
    The client is a great enhancement over the continuing HTTP client support of Java- java.net.HttpURLConnection, which was not a possible selection for production usage owing to several limitations.
  • Better Code Readability and Easier API: API ensures processing responses and constructing requests are simpler to code, less verbose, and easier to understand. The Builder pattern usage instead of setter methods also increases its responses/requests and the thread safety of the client.
  • Suitable with other Java APIs: The backs of the client utilizing the APIs and features of contemporary Java language, such as Optional, Lambda expressions, the standard Time and Date API, and others.
  • Protocol support: The latest HTTP (HTTP/1.1) client also provides support for HTTP/2 with WebSocket.
  • Supports Non-Blocking I/O: The client supports running requests without stopping the thread from the usage of an async callbacks/API, which use java.util.concurrent.CompletableFuture.
• Visibility management of Nested Classes Attributes
  Java supports many classes to be defined in one source file, such as nested classes. Although, they are regarded as related to the "same class" from the perspective of the user. So, users suppose to have the shared access regime corresponding to their attributes.
  Compilers should set up private attribute access to many classes in a similar package by consolidating access bridges for sustaining these assumptions. They gathered a private member invocation into a compiler-generated method call within the target class, which uses the recommended private number.
  They have also included three techniques to java.lang.Class:
  • boolean isNestmateof (Class)
  • Class [] getNestMembers ()
  • Class getNestHost ()
• No-Op Garbage Collector (Epsilon)
  With JDK 11, Epsilon GC is a new garage collector. This GC handles memory allocation but does not operate on the actual memory reclamation mechanism. So, when the entire java heap executes, it will stop the JVM by showing an OutOfMemoryError.
  The concept of building this garbage collector is to provide the lowest feasible latency overhead along with a restricted memory allocation limit, but at the price of memory throughout. It defines that heap learning will be enough for our application, so we do not require the JVM to use resources to run GC operations. It reduces the effect GC has on execution, and code executes in absolute separation.
  • Mainly, it can use epsilon GC to test the performance, such as how garbage collection affects the performance of our application and what is the threshold of our application memory.
  • Epsilon GC is also beneficial for many applications where we need to implement last-drop latency improvements, often for applications that are conscious of ultra latency, in which we are sure about memory allotments and understand the application memory footprint and in which getting the GC cycle could be a concern.
  • A lengthy GC cycle could be a problem because that stretches the detection failure, and recovery gets delayed conclusively in those applications. In such cases, permitting load balances to find out failure and a good recovery strategy than getting a GC cycle.
• Blocks, Scripts, and New Characters
  The striking distinction between many Java versions and Java 11 is the inclusion of 16,018 new characters. Java 11 has added 128 emoji characters and 19 symbols, ideal for Bitcoin signs and the new 4K TV standard. We can additionally come across 10 new scripts and 18 new blocks.
  The latest 10 scripts in Java 11 are Nushu, Zanabazar Square, Bhaiksuki, Tangut, Masaram Gondi, Marchen, Osage, Adlam, Soyombo, and Newa.
  Ten blocks are especially perfect for the 10 new scripts among the new 18 blocks. The other 8 new blocks are ideal for available scripts. The available scripts are Glagolithic Supplement, Syriac Supplement, CJK Extension F, Kana Extended-A, Punctuations and Ideographic Symbols, Mongolian Supplement, Cyrillic Extended-C, and Tangut Components.
• Java Flight Recorder
  Several tools guide us in resolving and analyzing problems during the development process. However, particular problems only occur at the runtime of the application. Often, analyzing them is impossible or laborious because we often can't regenerate such errors.
  Java Flight Recorder can aid us by recording JVM data at execution time and ensuring that it's present in a file for evaluation. For years, JFR has been already there as a commercial aspect in Oracle's JDK. It becomes the OpenJDK part and can be used freely with JDK Enhancement Proposal 328.
  How to start a Flight Recorder?
  We can start a Flight Recorder in two different manners. In the first manner, we can enable Flight Recorder at the starting of an application using the below option on the Java terminal:
  -XX:StartFlightRecorder=filename=<file name>
  In the second manner, we can use jcmd to enable Flight Recorder in the running Java application:
  jcmd JFR.start filename=<file name>
• APIs Improvements
  JDK 11 inserts many new methods and classes built into available modules. The list listed below is a short overview, focusing on the improvements that seem to occur to be crucial.
  java.lang.String:
  • Java.util.function: It illustrates a function that gets in one argument and generates a result.
  • String stripTrailing (): It returns a String reduced trailing white spaces.
  • String stripLeading (): It returns a String without its leading white spaces.
  • string repeat (int): It returns a String that's the actual String added with itself n times.
  • String strip (): It returns a String clear of trailing and leading white spaces.
  • stream lines (): It returns a line's stream acquired from the String.
  • boolean isBlank (): It returns true or false if the String is made of just or blank white spaces.
  java.util.function.Predicate
  • Predicate not (Predicate). It returns a Predicate; the Predicate repudiation passed as an argument.
  java.lang.CharSequence
  • int compare (CharSequence, (CharSequence): It returns a null, positive, or negative value.
  java.lang.StringBuffer/java.lang.StringBuilder
  • Now, classes have authorization to a new compareTo () method that gets a StringBuilder/StringBuffer argument. It returns an int. The comparison logic follows the same lexicographic sequence as for the new method of the CharSequence class.
• Deletions and Deprecations
  This list explains every deprecated aspect or aspect that is deleted from JDK.
  Eliminating the CORBA Modules and Java EE
  JDK Enhancement Proposal 320 removes the following listed modules from JDK:
  • jdk.xml.bind (tools for JAXB)
  • jdk.xml.ws (tools for JAX-WS)
  • jdk.se.ee (combined module for the six formerly explained modules)
  • java.transaction (JTA)
  • java.corba (CORBA)
  • java.xml.ws.annotation (Basic Annotations)
  • java.activation (JAF)
  • java.xml.bind (JAXB)
  • java.xml.ws (JAX-WS)
  The mentioned technologies were initially developed for the Java EE environment and consolidated into the standard "Java SE" edition when Java 6 was published. In Java 9, they were marked as "deprecated" and finally free from Java 11. We can get the libraries of Java 11 back to our project after updating it.
  • Abandon the Nashorn JavaScript Engine
    "Rhino", the JavaScript engine, was introduced in JDK 8 and Java 11 with JEP 335. It was marked "deprecated for removal" and is to be removed altogether in the subsequent releases. The cause of it is the ECMAScript's quick advancement and the node.js engine.
  • Abandon the Pack200 API and Tools
    It introduced a unique compression technique Pack200 in Java 5 and reached better compression rates as compared to the standard techniques, specifically for .class and .jar files. Pack200 saves a lot of bandwidth in the early 2000s. The algorithm is complex, and the further improvement costs are not in line with the helpfulness in times of 100-Mbit Internet lines. Hence, the tool has been marked "deprecated" along with JDK Enhancement Proposal 336 and should be removed in one of the Java releases.
  • JavaFX Goes its Way
    The related javapackager and JavaFX tools are not dispatched with JDK in Java 11. Instead, we can have an isolated SDK, which can be downloaded through the JavaFX homepage.
• Other Improvements
  Unicode 11 support
  ava 11 has included the support of Unicode 11 to overcome platform APIs. Following are some listed Java classes that are mostly supported by Unicode 10:
  • In the java.text package: BreakIterator, Normalizer, and Bidi
  • In the java.lang package: Characters and String
  • In the java.awt.font package: NumericShaper
  This upgrade consists of Unicode 9 modifications and incorporates 16,018 characters and 10 new scripts.
  Improved KeyStore Mechanisms
  Java 11 can affect the security precedents for the features of Java 12. In Java 11, the improved KeyStore mechanisms can certainly provide proof of that. We can find a new security property with the "jceks.key.serialFilter" with Java 11. The JCEKS KeySrore users can utilize this security filter at the time of encrypted key object decentralization positioned in a SecretKeyEntry. The outcome of the filter delivers an UNDECIDED value and brings default configuration via 'jdk.serialFilter' without configuration.
  Low-overhead Heap Sketching
  Java 11 provides the aspect of a low-overhead technique of Java heap allocation sampling by the JVMTI. The concept of this technique is ideal to focus on particular goals. Low-overhead is first at a satisfactory stage for default activation. The next helpfulness is to bring data about live and dead Java objects. Besides, the JVMTI is a programmatic and well-defined interface that provides easy access. Also, we would understand low-overhead heap sketching as one of the possible improvements in Java 12 aspects.
  Improved Aarch64 Intrinsics
  The compiler manages an Intrinsic function in some unique ways. They grab advantages through the CPU architecture-specific assembly code for enhancing performance. Java 11 enhanced and optimized the overcoming array and string intrinsic on AArch64 processors. Java 11 also consolidates new Intrinsics for sin, log, and cos java.lang techniques.
• Long-Term Support of Java 11
  We can use Java 11 in several development phases. The latest Java 11 aspects of commercial usage would call a license. A lot of necessary information came to the forefront after the publication date of Java 11.
  For instance, Oracle would not provide Java 8 support posted in 2019. We can continue using Java 8 for support by paying, though we wouldn't get any security and patch updates. We can download the builds of OpenJDK because we can't use Oracle JDK at no cost.
  Various providers provide flexible options, and we use the builds of OpenJDK through these providers and also update them when required. Everyone can use OpenJDK 11, and it is free to use. On 25 September 2018, the initial JDK LTS release with Java 11 since the move to the six months release cycle was released. For many years, LTS defines that Oracle would provide this release with security patches. The last LTS version was Java 8. Java 10 and Java 9 were not LTS versions, which defines that this release support was abandoned with all successive versions.

A few other essential features of Java 11 are mentioned below:

• Flight Recorder (JEP 328)
• Writing/Reading Strings from and to the files
• HTTP Client (JEP 321)
• Nested Based Access Control
• Local-Variable for Lambda Parameters
• New utility techniques in String class
• Executing Java File with one command

How to install Java 11 in Ubuntu?

Java language is one of the most famous programming languages in the world. It is also an object-oriented, general-purpose, class-based, and multipurpose programming language that is famous due to the structure of having lesser dependencies of the implementation, meaning that the compiled code of Java can be executed on every platform that supports Java without the requirement for recompilation.

Also, Java is reliable, secure, and fast. It's widely utilized to develop Java applications in cell phones, scientific supercomputers, game consoles, data centers, laptops, etc. It can also be used for creating desktop and server applications, and Java executes on almost every operating system, including Linux, Windows, and macOS. The software specified in Java can be compiled and executed on any system creating Java. This versatile environment that can be used for creating anything from software to common web applications. OpenJDK is the open-source and free implementation of the Java SE (Oracle Java Standard Edition) development kit.

Java SE and OpenJDK are equivalent to JDK, which adds a JRE (Java Runtime Environment) and tools to develop and compile Java applications. While there are several available releases of OpenJDK, the 11 version is the latest LTS version. For this reason, OpenJDK 11 is the suggested version to develop production applications.

Important Modifications

• An entire part of supported browsers has been deleted from the supported configuration list because of the deployment stack's unavailability.
• Auto-update feature has been deleted from JRE installations in macOS and Windows.
• Now, Java Mission Control and JavaFX are available as individual downloads.

Before We Start

There are several different implementations of Java. Oracle Java and OpenJDK are the two primary implementations of Java, which are almost the same as each other, excluding Oracle Java, and have some extra commercial aspects. Oracle Java License allows only non-commercial software use, like development use and personal use.

The default 20.04 Ubuntu repositories include two packages of OpenJDK; Java Development Kit and Java Runtime Environment. The Java Runtime Environment consists of the binary, classes, and Java Virtual Machine that permit us to execute Java programs. The Java Development Kit includes libraries, debugging/development tools, and Java Runtime Environment necessary to create Java applications.

If we aren't sure which package of Java to install, the general suggestion is to install the 11 version (default OpenJDK). A few Java-based applications may need a specific Java version, so we should check the application documentation. We will discuss how to install Oracle JDK 11 in Ubuntu in this article.

Download Oracle JDK 11 in Ubuntu

Oracle JDK 11 is not present in the official Ubuntu package repository. But we can download it easily from Oracle's official website and install it in Ubuntu. We need to first check the official website of Java SE at the below link:

We will select "Downloads" when the page loads, as shown in the below screenshot:

We will select DOWNLOAD from the section, i.e., Java SE 11.x (LTS) as shown in the below screenshot:

We will select the "Accept License Agreement" option by scrolling down a little bit, as displayed in the below screenshot:

For Oracle Java Standard Edition, we have obtained the Oracle Technology Network License Agreement; we can proceed with downloading Oracle JDK 11. Press the DEB file link to download Oracle JDK 11 in Ubuntu, as displayed in the below screenshot:

Our browser should ask us to store the DEB package file of Oracle JDK 11. Select the "Save File" option and press the OK button.

Our download process should begin. It may take some to complete.

Install Oracle JDK 11

We will use the directory in which our browser stored the DEB package file when the download process is finished. It's usually the directory, i.e., ~/Downloads in our HOME directory.

Important: The name of the package file may be different. Make sure that we replace the name of the package file with ours.

Now, we can install the Oracle JDK 11 version using the below command:

Now, we will type in the password of our login user and click on the Enter button. Oracle JDK 11 has been successfully installed in our Ubuntu system.