Interesting features in Java 17
Tags: java, programming, features, beginners
Published: 2022-02-05 08:40:05


Originally published in [sendilkumarn.com](https://sendilkumarn.com/blog/java-17)

Few months ago, Java 17 was released. The new LTS version comes with a lot of performance improvements, new features, and API enhancements. Here are my top features in this release.

1. Sealed Classes or Interfaces
2. Pattern Matching in switch 
3. Vector API 
4. Foreign Function and Memory API



# Sealed Classes or Interfaces

With Java 17, Sealed classes or interfaces are finally out of preview. They allow classes or interfaces to specify which other classes or interfaces can extend or implement them. This feature enables the superclasses to be accessible but restricts extending superclasses.

You can define a sealed class as follows: 

```java
public abstract sealed class CollectionAdapter 
	permits ListAdapter, SetAdapter, MapAdapter { ... }
```

The sealed classes have a `sealed` modifier followed by the class definition. We have to explicitly define the allowed subclasses for the sealed class. We can do it either by defining the sub classes directly in the same source file (as inner or auxiliary classes) or using `permits` modifier followed by a list of allowed subclasses. Only these classes can extend the `sealed` classes.

> Note: Sealed and its permitted subclasses should live on the same package or module (who uses a module ;) ).

The subclass can extend the sealed class just like any other class. But the subclass should either be `final`, `sealed`, or `non-sealed` (yeah! hyphenated modifier ;)).  

## final

The final completely prevents further extension of the sealed class.

```java
public final class ListAdapter extends CollectionAdapter { ... }
```

## sealed

The sealed classes allow its subclasses to extend the sealed superclasses via themselves.

```java
public sealed class SetAdapter extends CollectionAdapter 
	permits SortedSetAdapter, HashSetAdapter { ... }
```

Now both SortedSetAdapter and HashSetAdapter can (indirectly) extend the CollectionAdapter via SetAdapter. 

> Note: If SorterSetAdapter and HashSetAdapter directly extend CollectionAdapter then it will error during compilation.

## non-sealed

The non-sealed makes unrestricted extension of a superclass possible.

```java
public non-sealed class MapAdapter extends CollectionAdapter { ... }
```

## Record classes & Sealed Interfaces Best Friends Forever

Record classes landed on Java 16. They provide a concise way to represent immutable DTOs in Java. Sealed classes or interfaces work great with records.

```java
public abstract sealed interface Geometry 
	permits Point, Line { ... }

public record Point(int x, int y) implements Geometry { ... }

public record Line(Point x, Point y) implements Geometry { ... }
```

> Note: Record classes do not support declaring a superclass type as they are implicitly `final`. 

Both Record and Sealed classes are algebraic data types (ADT). ADTs are a fancy way of saying composite types (the type formed by combining other types). Record classes are product types. Sealed classes are sum types.

Being `sum` type, the Sealed classes make it easy for the compiler to understand its various type forms. Our next feature `pattern matching` rides on this exhaustive type checking.

# Pattern Matching in switch

> This is a preview feature in Java 17

Pattern matching is a great feature. It is one of the many features I enjoyed while learning [Rust](https://doc.rust-lang.org/book/ch18-03-pattern-syntax.html). The pattern matching makes the programs concise and readable. It also empowers the compiler to do exhaustive type checks. The pattern matching `instanceof` was released on Java 16. It reduced the boilerplate code when using `instanceof`.

Instead of two separate statements to check the type and create a variable with casting, the pattern matching `instanceof` introduced a syntactic sugar that combines them into one.

```java
// before Java 16
if (snow instanceof Water) {
	Water w = (Water) snow;
	// do whatever with w
}

// from Java 16
if (snow instance of Water w) {
	// do the same thing with w
}
```

Java 17 extends these features further and introduces pattern matching for `switch` expressions. Together with exhaustive type check (introduced in Java 14) and pattern matching `switch` expressions are delightful to work with.

```java
switch (snow) {
	case null -> // well it is a null value
	case  Water w  -> // Do something with Water
	case Fire f -> // Do something with Fire
	default -> // Do something with something
}
```

Before Java 17, switch cases were not exhaustive. It introduced runtime exceptions. This exhaustive type checking in switch statement removes the runtime exceptions. When the switch cases are not exhaustive the compiler throws an error. The `case` labels should cover all the possible variations of the type. Also, the case expressions support the `null` case. 

The pattern matching in `instanceof` and `switch` provides a building block for allowing destructuring of the classes in the future. Let's jump on to two new cool features that are still in incubation but have potential.

# Vector API 

> This feature is in incubation.

In the Machine Learning ecosystem, Java is not the primary language. The main reason is that the language lacks a few essential constructs. Vector APIs addresses a few problems in the Machine Learning area.

Vector is a primitive data structure. In the initial release, vectors support `Byte`, `Short`, `Integer`, `Long` types. 

```java
// var vectorized = new Vector<E>();
var vectorInt = new Vector<Integer>();
var vectorLong = new Vector<Long>();
var vectorShort = new Vector<Short>>();
var vectorShort = new Vector<Byte>>();
```

_If you are thinking, What is a big deal it is another data structure?_

Vector API uses Single Instruction Multiple Data (SIMD). Modern CPU architectures allow you to perform multiple tasks in a single CPU cycle. That is the machine (CPU) allows simultaneous computation of a single instruction. For example, you have 1Million pixels image and you want to increase the contrast for each pixel in that image. In a normal instruction, the CPU has to fetch the pixel from a particular location and increase its RGB (Red Green Blue) value and continue doing that one million times. If the CPU supports SIMD, then the CPU can load a bunch of pixels (say n) and apply the single instruction (in our case increasing RGB values) on them. They do this in parallel for multiple bunches. Thus significantly increasing the performance of the overall operation. 

Thus Vector APIs provide an enormous performance boost and thus makes Java easier to use for [tensor](https://www.tensorflow.org/guide/tensor) calculations in the future. 

> Although most of the modern CPU architectures support SIMD computation, there are still some CPU architectures out there that do not support SIMD. Vector APIs allows graceful degradation for them too. 

# Foreign Function & Memory API

> This feature is in incubation.

Foreign Function and Memory API is another feature on incubation in Java 17. They provide necessary APIs for Java programs to access foreign functions and memory outside of the JVM. Java introduced Java Native Interface(JNI) long back. JNI is complex, slow, and dangerously unsafe to use. The new Foreign Function and Memory API were built from the ground up to provide simple, fast, and safer APIs when going out of the JVM.

_Why is it a big deal?_

The Java runtime keeps its object in the heap. This heap is called `on-heap data` and is fast to access. That is the main reason why Java is super fast. But when Java wants to call outside of its runtime for example C/C++ code, it becomes too slow to access the data. This is primarily because the data is outside the JVM's heap (on-heap), this heap is called `off-heap data`. JVM has to translate the value from `off-heap` to `on-heap` and vice versa. This makes accessing the `off-heap` data slower than accessing `on-heap` data.

> Note: Garbage Collection happens only on the "on-heap" data.

Java provides a couple of ways to call foreign functions or memory, like `ByteBuffer`, `Unsafe API`, or `JNI`. The `ByteBuffer API` allows accessing "off-heap" data, but they are not built for this use-case and they lack a few key features (like customised byte alignment). The `sun.misc.Unsafe API`, this exposes "on-heap" memory access. While it addresses the performance but as the name implicates it is "unsafe". `JNI` allows accessing "off-heap" data, but it provides significantly low performance. 

JNI has a ton of performance issues, platform-dependency (because of the foreign language), restrictions on the language to use. The translation of object representation between Java and the foreign language is too costly and uses the "Unsafe" API. 

With the new API we can allocate a memory segment using the following code: 

```java
// Alloactes 100bytes on the native memory using malloc
var nativeSegment = MemorySegment.allocateNative(100, newImplicitScope());
```

The Memory Segment is a contiguous region on memory (i.e., they are allocated together). The `implicitScope` on the above code specifies that the memory can be cleaned up once the `nativeSegment` goes out of scope. Additionally, the API also provides `MemoryLayout` to specify how the data is laid out on the memory. 

To load the function from `C`, we can use the `CLinker`. The `CLinker` implements the C Application Binary Interface (ABI) and helps us to load the `C` file and look up the functions defined in the C file.

```java 
// The below line loads the `cFunction` method from the C code. 
MethodHandle cFunction = CLinker.getInstance().downcallHandle(
							CLinker.systemLookup().lookup("cFunction"), ...);
// Create the required memory segment and provide the layout here.
// ...code is elided...
// The below line invokes the Foreign function from the Java code.
cFunction.invoke(
	// address where the memory lives 
	address, 
	// length of the memory 
	usedAddressLength, 
	// ... other args
)
```

The Foreign Function API makes the invocation of native code as simple as method handles inside Java. Foreign function and Memory API together will open a lot of new scopes in Java.

----

The Sealed classes and Record classes provide sum and product types for Java. These algebraic data types are great and they provide a cleaner way to pattern match. The pattern matching provides concise, readable code, and exhaustive type checks by the compiler. These three features make the Java language more modern and alleviate a few of the pain points. 

I am particularly excited about the Vector APIs and Foreign Function and Memory APIs changes. This lays a foundation for a much bigger and exciting future for Java. Both these features provide a big boost on performance and will introduce Java into the Machine Learning world ([Tensors](https://www.tensorflow.org/guide/tensor) here we come!). They are focused on performance, efficiency, and safety while not giving up on the readability of Java.


If you are looking for a full feature update on Java 17 then check the following links:
[Oracle official release announcement](https://www.oracle.com/news/announcement/oracle-releases-java-17-2021-09-14/) / [JEPs since Java 11](https://openjdk.java.net/projects/jdk/17/jeps-since-jdk-11) / [Updates from Java 8 to Java 17](https://advancedweb.hu/a-categorized-list-of-all-java-and-jvm-features-since-jdk-8-to-17/) / [Java 13 features](https://dev.to/sendilkumarn/java-enters-its-teen-age-4626)


Special thanks to [Billy Korando](https://twitter.com/BillyKorando) for the review.