Java was first released, and over the years, it has undergone significant changes. I started working with Java in the early 2000s, using J2SE 1.3, which lacked features that are now commonplace. Java 5 introduced generics, “for each” loops, annotations, autoboxing, and unboxing, resulting in more modern Java code.
Back then Java code looked like this:
List users = new ArrayList();
users.add(new User("John"));
users.add(new User("Mary"));
for (Iterator iterator = users.iterator(); iterator.hasNext(); ) {
User user = (User) iterator.next();
System.out.println(user.getName());
}
Java 5 finally brought us generics, for each, annotations, autoboxing and unboxing, so todays java code looks normally more like this:
List<User> users = new ArrayList<>();
users.add(new User("John"));
users.add(new User("Mary"));
for (User user : users) {
System.out.println(user.getName());
}
Though I haven’t used Java as my primary language in the past six years, I recently returned to it and have familiarized myself with the changes and new APIs that have been integrated mostly since Java 8. In this post, I will highlight some of the most significant language enhancements that have been added to Java in the last 20 years.
Optionals
Optionals were introduced in Java 8 as a way to handle null values in a more robust and safer way. Prior to Java 8, handling null values in Java code could be error-prone and could lead to NullPointerExceptions.
An Optional in Java is a container object that may or may not contain a value. It is used to represent the case where a value might not be present, instead of using a null reference. The Optional class provides a set of methods for working with the value it contains or for handling the case where the value is not present.
By using Optional, Java developers can write cleaner, more expressive code that is easier to read and maintain. Optionals can also help to reduce the risk of NullPointerExceptions, which can be a common source of bugs in Java code.