Скачать или смотреть How to Use Optional in Java to Handle Null and Empty String Values

Learn how to effectively use `Optional` in Java to check for null or empty strings and return a default value.
---
This video is based on the question https://stackoverflow.com/q/66569063/ asked by the user 'flamant' ( https://stackoverflow.com/u/5032020/ ) and on the answer https://stackoverflow.com/a/66569127/ provided by the user 'Benjamin M' ( https://stackoverflow.com/u/1321564/ ) at 'Stack Overflow' website. Thanks to these great users and Stackexchange community for their contributions.

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: Optional that test if a value is not null AND not empty

Also, Content (except music) licensed under CC BY-SA https://meta.stackexchange.com/help/l...
The original Question post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license, and the original Answer post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license.

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Handling Null and Empty Strings in Java with Optional

In Java programming, dealing with null and empty strings can sometimes be tricky. A common scenario arises when you want to return a default value when your string is either null or empty. For example, if a value is not provided, you might want to return a placeholder like "TOTO". This post will walk you through how to effectively use the Optional class in Java to manage such situations in a clean and efficient manner.

The Problem

Imagine you have a situation where a string variable might be null or an empty string. Your objective is clear: if the string is null or empty, you should return the default value "TOTO". Otherwise, you should return the actual value of the string. Below is a simple representation of this scenario:

[[See Video to Reveal this Text or Code Snippet]]

The goal is to derive a solution that ensures that if s is null or empty, "TOTO" is returned.

Traditional Approach

Before the advent of the Optional class in Java 8, handling such cases typically required straightforward conditional checks. Here’s how you would do it:

[[See Video to Reveal this Text or Code Snippet]]

This method works but can become cumbersome in more complex scenarios and does not utilize some of the features introduced in Java 8.

Modern Approach with Optional

With the introduction of the Optional class in Java 8, you can handle nullability more elegantly. Optional allows for a more functional style of programming and helps avoid null pointer exceptions. Here’s how to use Optional to solve our problem:

Step-by-Step Breakdown:

Creating an Optional:

Use Optional.ofNullable(s) to wrap the string variable s. This will allow it to handle a null value gracefully.

Filtering the Value:

Utilize the filter method to check whether the string is not empty: filter(str -> !str.isEmpty()). This ensures that only non-empty strings pass through.

Providing a Default Value:

Use orElse("TOTO") to specify the default value that should be returned if the condition fails (i.e., if s was null or empty).

Final Code

Here’s what the final implementation looks like using Optional:

[[See Video to Reveal this Text or Code Snippet]]

In this implementation, if s is either null or an empty string, result will be assigned the value "TOTO". If s contains a valid string, it will be returned as is.

Conclusion

Using Optional not only makes your code cleaner but also enhances readability and maintainability. By avoiding null checks scattered throughout your code, you establish a clearer contract of what your program expects, and it becomes easier to manage values that might be absent. Utilizing Optional is a powerful technique that every Java developer should consider adopting in their coding practices.

By following this approach, you are ensuring that your program remains robust and free from unnecessary null pointer errors. Happy coding!