Java Objects.requireNonNull() Example

Null references have long been a source of errors in Java applications. A NullPointerException (NPE) is one of the most common runtime exceptions, often indicating a missing value where an object was expected. To handle such scenarios effectively, Java introduced the Objects.requireNonNull() method in Java 7. This utility method provides a cleaner, more efficient way to enforce non-null arguments and prevent unexpected NPEs. Let us delve into understanding how Objects.requireNonNull() works in Java and why it’s crucial for handling null values effectively.

1. Null Value Handling

Before Java 7, checking for null required manual validation, which could be verbose and inconsistent.

1.1 Traditional null checking

In this traditional approach, we manually check if the name argument is null. If it is, a NullPointerException is thrown with a custom error message. While functional, this method involves writing boilerplate code and is prone to repetition throughout your codebase.

With Objects.requireNonNull(), we can simplify the code and reduce repetition:

In this enhanced version, we use Objects.requireNonNull(), which checks if the name is null. If it is, it automatically throws a NullPointerException with the provided error message (“Name cannot be null”).

This approach is cleaner, easier to maintain, and ensures that all null checks are consistent throughout your code. Additionally, it reduces the chance of forgetting to include the validation, making your code more robust and less error-prone.

Furthermore, Objects.requireNonNull() helps you avoid the need for custom exception handling logic, offering a standardized approach for null validation. This method improves code readability, especially when validating multiple method parameters across different methods and classes.

1.2 Advantages of Objects.requireNonNull()

Using Objects.requireNonNull() provides several key advantages, making it a best practice in modern Java development:

• Code Readability: Objects.requireNonNull() eliminates the need for repetitive if-else checks for null values, resulting in cleaner, more readable code. It improves the flow of the program by keeping the focus on the actual logic rather than cluttering the code with null validation checks. Instead of manually writing exception handling code every time, developers can rely on this built-in method, improving both the appearance and clarity of the code.
• Standardized Exception Handling: Objects.requireNonNull() provides a built-in, standardized mechanism to throw a NullPointerException with a meaningful error message. This ensures that exception handling is consistent across the codebase. Developers don’t have to manually throw exceptions, which can lead to varying styles and messages. The exception thrown by Objects.requireNonNull() also includes a clear message, making debugging easier when an argument is unexpectedly null.
• Performance Optimization: Java internally optimizes the execution of Objects.requireNonNull(). By relying on this method, you benefit from the JVM’s ability to optimize redundant calls to improve performance. This means that, in the long run, using Objects.requireNonNull() can result in faster execution times, particularly in performance-sensitive applications. The JVM can detect and optimize calls to standard utility methods like requireNonNull(), reducing overhead compared to manual checks.
• Encapsulation of Validation: Using Objects.requireNonNull() promotes the encapsulation of argument validation. This encapsulation not only reduces boilerplate code but also standardizes the validation process across your application. It enforces a consistent approach to checking for null inputs in methods, constructors, and factories. This consistency makes the code easier to maintain and less prone to errors since the same validation pattern is applied throughout the codebase.

1.3 Use Cases and Overloaded Methods

Java provides three overloaded versions of Objects.requireNonNull() to handle different scenarios efficiently.

• Basic Null Check: This version ensures the object is not null and throws a NullPointerException if it is:

  1	String value = Objects.requireNonNull(null);  // Throws NullPointerException

  This approach is best used when no specific error message is required; however, it is not ideal if you need to provide meaningful context in the exception.

• Null Check with Custom Error Message: You can pass a custom error message, making it easier to debug:

  1 2	String value = Objects.requireNonNull(null, "Value cannot be null"); // Throws: java.lang.NullPointerException: Value cannot be null

  This approach helps identify the exact cause of the error and is particularly useful in complex applications where knowing the variable name is crucial. However, the error message is always constructed, even when the object is non-null, which may slightly impact performance.

• Null Check with Supplier for Lazy Evaluation: Instead of eagerly constructing an error message, this version delays its creation until an exception is thrown:

  1 2	String value = Objects.requireNonNull(null, () -> "Generated error message"); // Throws: java.lang.NullPointerException: Generated error message

  This approach is recommended when generating the error message, which involves complex computation, as it avoids unnecessary string concatenation if the object is non-null. However, it has a slightly more complex syntax while offering better performance in certain cases.

1.4 Best Practices

• Use in Constructors: Ensure mandatory parameters are not null:

  1 2 3 4 5 6 7

  public class User {   private final String username;     public User(String username) {     this.username = Objects.requireNonNull(username, "Username is required");   } }

• Use in Method Parameters: Validate method arguments:

  1 2 3 4

  public void processOrder(String orderId) {   Objects.requireNonNull(orderId, "Order ID cannot be null");   System.out.println("Processing order: " + orderId); }

• Use in Factory Methods: Factories often require valid input parameters:

  1 2 3

  public static User createUser(String username) {   return new User(Objects.requireNonNull(username, "Username must not be null")); }

• Use with Java Streams: Ensure non-null values in collections:

  1 2 3 4

  List<String> names = Arrays.asList("Alice", null, "Bob"); names.stream()     .map(name -> Objects.requireNonNull(name, "Name cannot be null"))     .forEach(System.out::println);

1.5 Performance Considerations

Using Objects.requireNonNull() is efficient for several reasons:

• Avoids unnecessary if-else checks: Traditionally, null checks involve writing custom if-else statements that are error-prone and often repetitive. By using Objects.requireNonNull(), you remove the need for manual checks and simplify the code, making it more efficient to execute and easier to maintain.
• The JVM can optimize redundant calls: The Java Virtual Machine (JVM) is capable of optimizing the execution of commonly used methods, including Objects.requireNonNull(). Sometimes, the JVM can reduce the overhead associated with repeated calls, making it more efficient than manually written null checks.
• Using a Supplier prevents expensive message construction: If an exception is not thrown, Objects.requireNonNull() with a Supplier allows the message construction to be deferred until an actual NullPointerException is required. This lazy evaluation avoids the unnecessary overhead of building a string message when the validation passes and no exception is thrown.

1.6 When Not to Use Objects.requireNonNull()

Despite its advantages, there are cases where you should avoid overusing Objects.requireNonNull():

• When handling optional values – use Optional instead: If a value can be null by design and it’s acceptable for the program logic, use Optional to make it explicit. Optional encourages better handling of null values through functional approaches such as map() or filter(), which are less prone to errors than throwing exceptions.
• When default values can be used instead of throwing exceptions: If a parameter or variable can have a reasonable default value when null, it’s often better to assign that default instead of throwing an exception. This avoids the overhead of exception handling and provides a smoother user experience. For example, instead of throwing an exception for a null input, return an empty list or a default value.
• When exceptions need to be handled more gracefully: Throwing a NullPointerException with Objects.requireNonNull() may not be ideal when your program needs to handle exceptions more gracefully. In such cases, you might want to use custom exception-handling mechanisms or fallback strategies instead of immediately throwing a standard exception. This gives you better control over the error-handling flow and user experience.

2. Conclusion

Objects.requireNonNull() is a simple yet powerful tool for ensuring non-null values in Java. It improves code clarity, reduces boilerplate, and provides meaningful exception messages. By following best practices and using it effectively, you can write safer and more robust Java applications.

Do you want to know how to develop your skillset to become a Java Rockstar?

Subscribe to our newsletter to start Rocking right now!

To get you started we give you our best selling eBooks for FREE!

1. JPA Mini Book

2. JVM Troubleshooting Guide

3. JUnit Tutorial for Unit Testing

4. Java Annotations Tutorial

5. Java Interview Questions

6. Spring Interview Questions

7. Android UI Design

and many more ....

I agree to the Terms and Privacy Policy

Sign up

Thank you!

We will contact you soon.