Exploring Exciting New Features in Java 17 With Examples

Java, one of the most popular programming languages, continues to evolve and improve with each new release. Java 17, the latest long-term support (LTS) version, brings several exciting features and enhancements to the language. In this article, we will explore some of the notable new features in Java 17 and provide practical examples to help you understand how to use them effectively.

Sealed Classes

Sealed classes allow you to restrict which classes or interfaces can extend or implement them. This feature enhances encapsulation and helps maintain code integrity by controlling who can inherit from a sealed class. Let's look at an example:

public sealed class Shape permits Circle, Square, Triangle {
    // Common properties and methods for all shapes
}

final class Circle extends Shape {
    // Circle-specific properties and methods
}

final class Square extends Shape {
    // Square-specific properties and methods
}

final class Triangle extends Shape {
    // Triangle-specific properties and methods
}

Any other class that tries to extend the Shape class(apart from permit classes like Circle, Square, and Triangle)will result in a compilation error

The Ultimate Java Expert Certification Bundle.*

*Affiliate link. See Terms of Use.

Pattern Matching for Switch

 Java 17 introduces pattern matching for switch statements, which simplifies code by combining the declaration of a variable with its conditional check. Here's an example:

public String getDayOfWeek(int day) {

            String dayOfWeek = switch (day) {

            case 1 -> "Monday";

            case 2 -> "Tuesday";

            case 3 -> "Wednesday";

            case 4 -> "Thursday";

            case 5 -> "Friday";

            default -> "Unknown";

        };

        return dayOfWeek;

    }

Foreign Function Interface (FFI)

An FFI allows a high-level programming language like Java to interact with functions or libraries written in lower-level languages like C or C++. Java has the Java Native Interface (JNI) for this purpose. JNI allows Java applications to call and be called by native applications and libraries. With JNI, you can load and invoke functions in dynamic link libraries (DLLs) or shared object files (SOs) written in languages like C or C++.

Here's a basic overview of using JNI in Java:

• Write a Java class that contains native method declarations, specifying the native keyword.
• Implement these native methods in C or C++ and compile them into a shared library.
• Use the System.loadLibrary or System.load method in Java to load the shared library.
• Call the native methods from your Java code.
• Example:

Step 1: Write the Java Class

First, create a Java class that declares the native method. In this example, we'll call it NativeSum.java.

public class NativeSum {
    // Load the shared library containing the native function
    static {
        System.loadLibrary("NativeSum");
    }

    // Declare the native method to add two integers
    public native int add(int a, int b);

    public static void main(String[] args) {
        NativeSum nativeSum = new NativeSum();
        int result = nativeSum.add(5, 7);
        System.out.println("Sum: " + result);
    }
}

Step 2: Write the Native C Code

Next, create a C file that implements the native method. In this example, we'll call it NativeSum.c.

#include <jni.h>

JNIEXPORT jint JNICALL Java_NativeSum_add(JNIEnv *env, jobject obj, jint a, jint b) {
    return a + b;
}

Step 3: Compile the Native Code

Compile the native C code into a shared library. The exact steps to do this depend on your development environment and platform. Here's a simple example of using GCC on a Unix-like system:

gcc -shared -o libNativeSum.so -I$JAVA_HOME/include -I$JAVA_HOME/include/linux NativeSum.c

Replace $JAVA_HOME with the path to your Java installation.

Step 4: Run the Java Program

Now, you can run the Java program

java NativeSum

This program will load the libNativeSum.so shared library and call the add method, which adds two integers and returns the result. In this case, it adds 5 and 7 and prints "Sum: 12."

Memory API

Java provides memory management through its own mechanisms, and Java developers typically do not need to deal directly with memory allocation or deallocation. Java's memory management includes automatic garbage collection, which cleans up memory that is no longer in use. The Java Virtual Machine (JVM) takes care of memory management for you.

However, if you have specific memory-related requirements or need to work with off-heap memory, you might use third-party libraries or features such as Java's NIO (New I/O) package. NIO allows for more direct and efficient memory manipulation, including memory-mapped files, buffers, and channels. It can be useful for certain low-level operations and high-performance I/O.

Here's an example of using Java's New I/O (NIO) package to work with memory-mapped files and memory buffers.

Step 1

In this example, we'll create a simple program that reads and writes data to a memory-mapped file using memory buffers.

import java.io.RandomAccessFile;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;

public class MemoryMappedFileExample {
    public static void main(String[] args) throws Exception {
        // Create a random access file for read and write operations
        RandomAccessFile file = new RandomAccessFile("example.txt", "rw");

        // Get the file channel
        FileChannel channel = file.getChannel();

        // Map the file into memory
        MappedByteBuffer buffer = channel.map(FileChannel.MapMode.READ_WRITE, 0, 1024);

        // Write data to the memory-mapped file
        String data = "Hello, Memory-Mapped File!";
        buffer.put(data.getBytes());

        // Read data from the memory-mapped file
        buffer.flip();
        byte[] readData = new byte[data.length()];
        buffer.get(readData);

        System.out.println(new String(readData));

        // Close the file and channel
        channel.close();
        file.close();
    }
}

In this example, we create a memory-mapped file called "example.txt," write some data to it, read it back, and print it.

Step 2: Compile and Run

Compile and run the Java program. It will create a file named "example.txt" in the current directory and write "Hello, Memory-Mapped File!" to it. It then reads the data from the memory-mapped file and prints it.

Please note that the memory-mapped file can be larger than the physical memory because it uses the virtual memory system of the operating system. The mapped data is directly read from and written to the file without explicitly loading the entire file into memory.

Text Block

In Java 17, a new feature known as "Text Blocks" was introduced to simplify the writing of multiline strings and make the code more readable when working with long text content. Text Blocks allow you to write multi-line strings in a more natural and concise way. They are enclosed within triple double quotes, and indentation is preserved. Here's an example of how to use Text Blocks:

public class TextBlocksExample {
    public static void main(String[] args) {
        String longText = """
            This is a text block in Java 17.
            It allows you to write multi-line strings
            without needing to escape newline characters.
            
            You can also preserve leading whitespace for formatting.
            \tIndented text is also preserved.
            """;

        System.out.println(longText);
    }
}