Java 15 - What's new features in Java 15

Java 15 is now available!

Java 15 (Java SE 15) and its Java Development Kit 15 (JDK 15) open-source has been released on 15 September 2020, the most common coding language and application platform in the world.

Some of the significant feature highlights of JDK 15 include text blocks, hidden classes, a foreign-memory access API, the Z Garbage Collector, and previews of sealed classes, pattern matching, and records.

Developers can look at JDK 15 now to get an idea of what will be in JDK 17

Java 15 Release Date

15 September 2020

JDK 15 has now been officially released, listed below features/enhancements as part of the jdk 15.

JEP 339: Edwards-Curve Digital Signature Algorithm (EdDSA)

It introduces cryptographic signatures using the Edwards-Curve Digital Signature Algorithm (EdDSA) as defined in RFC 8032.

EdDSA is a modern elliptical curve signing method with numerous advantages in comparison to the existing JDK signature schemes. The SunEC provider will add new Signature, KeyFactory and KeyPairGenerator services to support EdDSA. New classes and interfaces to represent EdDSA keys will be added to the API, and new standard algorithm names to represent EdDSA signature schemes will be included. The API will use the NamedParameterSpec class developed for XDH to describe the parameters of the curve domain and the variants of EdDSA.

Example: Create a key pair and sign

KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("Ed25519");
KeyPair keyPair = keyPairGen.generateKeyPair();
// use Ed25519 algorithm
signaturenature signature = signaturenature.getInstance("Ed25519");
signature.initsignaturen(keyPair.getPrivate());
signature.update(msg);
byte[] s = signature.signaturen();

Create a public key using KeyFactory

KeyFactory keyFactory = KeyFactory.getInstance("EdDSA");
boolean param1 = ...
BigInteger param2 = ...
NamedParameterSpec paramsSpec = new NamedParameterSpec("Ed25519");
EdECPublicKeySpec publicSpec = new EdECPublicKeySpec(paramsSpec, new EdPoint(param1, param2));
PublicKey publicKey = keyFactory.generatePublic(publicSpec);

JEP 360: Sealed Classes (Preview)

Sealed classes and interfaces restrict/limit, which other classes or interfaces may extend or implement them. It enhance the Java programming language with sealed classes and interfaces.

A class can be sealed by using the sealed modifier - permits to its declaration. After which any extends and implements clauses, the permits clause specifies the classes that are permitted/allowed to extend the sealed class.

Example: Below example shows how Animal class specifies three permitted subclasses:

package com.techgeeknext.example.species;

public sealed class Animal
    permits Dog, Monkey, Leopard {...}

Note: The classes specified by permits must be located close to the superclass, either in the same module or in the same package.

package com.techgeeknext.example.species;

public sealed class Animal
	com.techgeeknext.example.species.canis.Dog,
	com.techgeeknext.example.species.macaca.Monkey,
	com.techgeeknext.example.species.rana.Leopard
	{....}

Take a look at our Suggested Posts :

Java 14 Features

Java 16 Features

Java 11 Features

Java 8 Programming Interview Questions and Answers

Java 11 Interview Questions and Answers

Java 9 - Jshell

Spring Boot - Session Management

Spring Boot - Transaction Management

Spring Boot - Security Tutorial

Mapped Byte Buffer

Java Zip File Folder Example

JEP 371: Hidden Classes

Hidden classes are classes which can not be used directly by the bytecode of other classes. Hidden classes are intended to be used by frameworks that generates classes at runtime and use them indirectly through reflection. A hidden class can be defined as a member of the access control nest and can be unloaded independently of other classes.

Deprecate the non-standard API sun.misc.Unsafe::defineAnonymousClass, with the intent to deprecate it for removal in a future release.

JEP 372: Remove the Nashorn JavaScript Engine

Removes the Nashorn JavaScript script engine, the APIs and the jjs tool as mentioned below as it was already deprecated in java 11.

jdk.scripting.nashorn : It contains the jdk.nashorn.api.scripting and jdk.nashorn.api.tree packages.
jdk.scripting.nashorn.shell : It contains the jjs tool.

JEP 374: Disable and Deprecate Biased Locking

Biased locking is always enabled and available before Java 15. Biased locking will no longer be enabled with this JEP, when HotSpot is started unless -XX:+UseBiasedLocking is set on the command line.

JEP will deprecate the UseBiasedLocking option and all options related to the configuration and use of biased locking. Options will still be accepted and acted upon, but a warning of deprecation will be issued.

Product options
BiasedLockingStartupDelay, BiasedLockingBulkRebiasThreshold, BiasedLockingBulkRevokeThreshold, BiasedLockingDecayTime and UseOptoBiasInlining
Diagnostic options
PrintBiasedLockingStatistics and PrintPreciseBiasedLockingStatistics

JEP 375: Pattern Matching for instanceof (Second Preview)

Instanceof is used to check whether the object reference is and instance of given Type or not, and return boolean flag. It improves the programming language for Java with pattern matching for the operator instanceOf. Pattern matching allows for the more clear and efficient expression of common logic in a system, namely the conditional removal of components from objects.

Pattern matching, instanceof was suggested by JEP 305 in mid-2017, targeting in JDK 14 at the end of 2019 as a preview feature.

This JEP suggested to re-preview the feature in JDK 15, without any changes to the preview in JDK 14, in order to collect additional feedback.

Before- Without this feature

if (obj instanceof String) {
    String str = (String) obj; // need to declare and cast again the object
    .. str.contains(..) ..
}else{
     str = ....
}

With this feature enhancements

if (!(obj instanceof String str)) {
    .. str.contains(..) .. // no need to declare str object again with casting
} else {
    .. str....
}

For more examples visit JDK 14 - instanceof (Preview)

JEP 377: ZGC: A Scalable Low-Latency Garbage Collector

JDK 11 has introduced Z Garbage Collector as experimental feature. With Java 15, it seems the time may have come for ZGC to become a production feature.

In addition to the existing enhancements, it also improves important features as given below:

Concurrent class unloading
Uncommitting unused memory (JEP 351)
Maximum heap size increased from 4TB to 16TB
Minimum heap size decreased to 8MB
-XX:SoftMaxHeapSize
Support for the JFR leak profiler
Support for class-data sharing
Limited and discontiguous address spaces
Support for placing the heap on NVRAM
Improved NUMA awareness
Multi-threaded heap pre-touching

JEP 378: Text Blocks

In mid-2019, JDK 13 introduced Text Block as Preview feature, which then re-visited by adding two new escape sequences in Java 14 as Second Preview.
JDK 14 feedback indicates that the Text Blocks feature is now ready to become permanent and final as a Standard feature in Java 15.

In Java, to embed HTML, XML, SQL, or JSON snippet into a code is often hard to read and hard to keep, and to overcome this problem, Java 14 has introduced Text Block.

A text block is a multi-line string literals which prevents the need for most escape sequences, formats the string automatically, and allows the developer and gives control to format the string if necessary.

HTML Example With Text Block

String html = """
              <html>
                  <body>
                      <p>Hello, world</p>
                  </body>
              </html>
              """;

JEP 379: Shenandoah: A Low-Pause-Time Garbage Collector

Shenandoah was introduced into JDK 12 - JEP 189 as Experimental Feature. Shenandoah is now become ready as a production feature in Java 15.

Shenandoah reduces GC pause times by doing evacuation work at the same time as running Java threads. Shenandoah pause times are independent of the Heap Size, which means you will have the same consistent pause times whether your heap is 200 MB or 200 GB.

JEP 381: Remove the Solaris and SPARC Ports

It remove all source code related to Solaris operating system, SPARC architecture. These were deprecated in JDK 14 with the express intention of removing them in the future version.

Many currently developing projects and features, such as Valhalla, Loom and Panama, need significant CPU architecture and OS code changes. Removing support for Solaris and SPARC ports will enhance the development of new features that move the platform forward with help from contributors of the OpenJDK community.

JEP 383: Foreign-Memory Access API (Second Incubator)

Create an API for Java programs to access foreign memory outside the Java heap in a secure and efficient way.

It was targeted to Java 14 in late 2019 as an Incubator API - Foreign-Memory Access API

This JEP proposes to incorporate feedback-based improvements and re-incubate the API in Java 15. As part of this API update the following updates are included:

VarHandle combinator API
Spliterator interface
Enhanced support for mapped memory segments (e.g., MappedMemorySegment::force)
Secure API points to serial confinement (e.g. to transfer thread ownership between two threads)
Insecure API points to manipulate and dereference addresses coming from, e.g. to wrap these addresses into synthetic memory segments.

JEP 384: Records (Second Preview)

We need to write a lot of low-value, repetitive code to write a simple data carrier class responsibly: constructors, accessors, equals(), hashCode(), toString(), etc. To avoid this repetitive code, Java is planned to use record.

It is used to compact the class declaration syntax with record. Records Preview feature has been introduced in JDK 14.

This JEP proposes to incorporate feedback-based improvements and re-preview the feature to support additional forms of local classes and interfaces in the Java 15.

It include below updates along with Preview features proposed in Java 14.

Records and Sealed Types
Local records
Annotations on records

JEP 385: Deprecate RMI Activation for Removal

This JEP will deprecate the RMI Activation mechanism for future removal by using @Deprecated(forRemoval=true) annotation. RMI Activation is an outdated part of RMI that has been optional since Java 8. There will be no other part of RMI deprecated.

The RMI Activation mechanism enables RMI-based services to export stubs whose validity exceeds a remote object's lifetime or a JVM containing it.

Quick glance on earlier Java Versions Features :

Java 14 Features - JDK 14

Java 14 (Java SE 14) and its Java Development Kit 14 (JDK 14) open-source has been released on 17 March 2020, the most common coding language and application platform in the world.

A significant number of Java Enhancement Proposals (JEPs) have been released in version 14. (Even more JEPs than Java 12 and 13 combined)

JAVA 14 addresses a total of 16 main enhancements/changes (JEPs) ranging from the Java language support to the latest APIs for ongoing JDK flight recorder monitoring. The entire feature list consists of:

Java 13 Features - JDK 13

Java 12 Features

Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
Microbenchmark Suite
Switch Expressions (Preview)
JVM Constants API
One AArch64 Port, Not Two
Default CDS Archives
Abortable Mixed Collections
Promptly Return Unused Committed Memory from G1

Java 11 Features

Java 10 Features

Local-variable type inference
Experimental Java-based JIT compiler.This is the integration of the Graal dynamic compiler for the Linux x64 platform
Application class-data sharing. This allows application classes to be placed in the shared archive to reduce startup and footprint for Java applications
Time-based release versioning
Parallel full GC
Garbage-collector interface
Additional Unicode language-tag extensions
Root certificates
Thread-local handshakes
Heap allocation on alternative memory devices
Remove the native-header generation tool - javah
Consolidate the JDK forest into a single repository

Java 9 Features

Modularization of the JDK under Project Jigsaw (Java Platform Module System)
jshell: The Java Shell (a Java REPL)
Ahead-of-time compilation
XML catalogs
More concurrency updates. It includes a Java implementation of Reactive Streams, including a new Flow class that included the interfaces previously provided by Reactive Streams
Variable handles: define a standard means to invoke the equivalents of various java.util.concurrent.atomic and sun.misc.Unsafe operations
jlink: The Java Linker: create a tool that can assemble and optimize a set of modules and their dependencies into a custom run-time image. It effectively allows to produce a fully usable executable including the JVM to run it
JavaDB was removed from JDK
HiDPI graphics: automatic scaling and sizing

Java 8 Features

Language-level support for lambda expressions and default methods (virtual extension methods) which allow the addition of methods to interfaces without breaking existing implementations.
Project Nashorn, a JavaScript runtime which allows developers to embed JavaScript code within applications
Annotation on Java types
Unsigned integer arithmetic
Repeating annotations
Date and time API
Statically-linked JNI libraries
Launch JavaFX applications (direct launching of JavaFX application JARs)
Remove the permanent generation

Java 7 Features

JVM support for dynamic languages
Compressed 64-bit pointers
Strings in switch
Automatic resource management in try-statement
Improved type inference for generic instance creation, aka the diamond operator <>
Simplified varargs method declaration
Binary integer literals
Allowing underscores in numeric literals
Catching multiple exception types and rethrowing exceptions with improved type checking
Concurrency utilities
New file I/O library adding support for multiple file systems
Timsort is used to sort collections and arrays of objects instead of merge sort
Library-level support for elliptic curve cryptography algorithms
An XRender pipeline for Java 2D, which improves handling of features specific to modern GPUs
New platform APIs for the graphics features
Enhanced library-level support for new network protocols, including SCTP and Sockets Direct Protocol
Upstream updates to XML and Unicode
Java deployment rule sets

Java 6 Features

Support for older Win9x versions dropped
Scripting Language Support
Dramatic performance improvements for the core platform, and Swing.
Improved Web Service support through JAX-WS.
JDBC 4.0 support.
Java Compiler API
Upgrade of JAXB to version 2.0
Support for pluggable annotations
Many GUI improvements, such as integration of SwingWorker in the API, table sorting and filtering, and true Swing double-buffering (eliminating the gray-area effect).
JVM improvements include: synchronization and compiler performance optimizations, new algorithms and upgrades to existing garbage collection algorithms, and application start-up performance.
Java 6 can be installed to Mac OS X 10.5 (Leopard) running on 64-bit (Core 2 Duo and higher) processor machines.[54] Java 6 is also supported by both 32-bit and 64-bit machines running Mac OS X 10.6

Java 5 Features

Generic
Metadata
Autoboxing/unboxing
Enumerations
Varargs
Enhanced for each loop
Improved
Static imports
Improvements - Semantics of execution for multi-threaded Java programs
Improvements - Automatic stub generation for RMI objects
Improvements - Swing: New skinnable look and feel, called synth
Improvements - The concurrency utilities in package java.util.concurrent
Improvements - Scanner class for parsing data from various input streams and buffers

Java 15 - What's new features in Java 15

Java 15 is now available!

Java 15 Release Date

JEP 339: Edwards-Curve Digital Signature Algorithm (EdDSA)

JEP 360: Sealed Classes (Preview)

Take a look at our Suggested Posts :

JEP 371: Hidden Classes

JEP 372: Remove the Nashorn JavaScript Engine

JEP 374: Disable and Deprecate Biased Locking

Product options

Diagnostic options

JEP 375: Pattern Matching for instanceof (Second Preview)

JEP 377: ZGC: A Scalable Low-Latency Garbage Collector

JEP 378: Text Blocks

JEP 379: Shenandoah: A Low-Pause-Time Garbage Collector

JEP 381: Remove the Solaris and SPARC Ports

JEP 383: Foreign-Memory Access API (Second Incubator)

JEP 384: Records (Second Preview)

Records and Sealed Types

Local records

Annotations on records

JEP 385: Deprecate RMI Activation for Removal

Quick glance on earlier Java Versions Features :

Java 14 Features - JDK 14

Java 13 Features - JDK 13

Java 12 Features

Java 11 Features

Java 10 Features

Java 9 Features

Java 8 Features

Java 7 Features

Java 6 Features

Java 5 Features

Recommendation for Top Popular Post :