It’s not easy to keep up with Java’s frequent feature releases. If you missed sealed classes, text blocks, records, the new string methods, or the Optional class, let’s fix that.
Java quietly underwent one of the biggest changes in its development in 2018 with the adoption of a new release cadence. This bold new plan resulted in Java developers getting a new feature release every six months.
This is wonderful for keeping Java fresh and relevant, but it makes it pretty easy to miss features as they are introduced. This article rounds up several useful new features and gives an overview of them.
Sealed Classes
Introduced in Java 15, sealed classes allow developers to specify which classes or interfaces can extend or implement a given class or interface. This feature enhances the Java type system by providing more control over the inheritance hierarchy, making the code more maintainable and secure.
Text Blocks
Java 13 brought us text blocks, which provide a more readable and writable way to handle multi-line string literals. Text blocks simplify the writing of SQL queries, JSON/XML, or HTML by allowing developers to write them in their natural multi-line form without the need for excessive escape sequences.
Records
First introduced in Java 14 and further refined in subsequent releases, records provide a concise way to model immutable data. Records automatically generate boilerplate code such as constructors, getters, equals, hashCode, and toString methods, making them ideal for simple data carriers.
New String Methods
Java has continually improved the String API. Recent releases have introduced several new methods such as strip(), repeat(), lines(), and indent(), which provide more convenient and efficient ways to manipulate strings.
Pattern Matching for instanceof
Pattern matching for instanceof, introduced in Java 16, simplifies the common pattern of using instanceof followed by a cast. This feature reduces boilerplate code and makes type checks and casts more concise and readable.
The Optional Class
The null pointer exception is one of the most classic of all errors. And while it may be familiar, it is a very verbose problem to guard against. At least it was until Java 8 introduced (and Java 10 refined) the Optional class. The Optional class allows you to wrap a variable and then use the wrapper’s methods to deal more succinctly with nullness.
Listing 1 has an example of a garden variety null pointer error, wherein a class reference, foo, is null and a method, foo.getName(), is accessed on it. Using Optional, you can write more elegant and less error-prone code by explicitly handling the presence or absence of a value.
By staying updated with these features, Java developers can write more concise, readable, and maintainable code while leveraging the latest advancements in the language.