NUHMAN.com

The provided Java code demonstrates various methods of handling null values, specifically for String objects. It uses a combination of Java utility classes like Objects and Optional, along with functional interfaces like Supplier. Below is a breakdown of each part of the code, including the commented-out sections, to understand how null values are managed in Java.

1. Package Declaration

java

package com.nuhman.coding.test;

• The package keyword declares the package com.nuhman.coding.test. This is used to organize classes in a namespace.

2. Import Statements

java

import java.time.LocalDate;
import java.util.Objects;
import java.util.Optional;
import java.util.function.Supplier;

• LocalDate is imported for working with date values.
• Objects provides utility methods, such as requireNonNull, to handle object operations like null checks.
• Optional helps handle null values more gracefully by providing methods like orElse and orElseGet.
• Supplier is a functional interface used to provide values, particularly useful in delayed evaluation scenarios.

3. Class Declaration

java

public class AppUtils {

• The AppUtils class is declared as public, meaning it can be accessed by other classes.

4. Method testStringNulls

java

public static void testStringNulls(String str) {

• This static method takes a String parameter str and tests different ways to handle potential null values for the string.

5. Commented-Out Code: Various Ways to Handle Nulls

Several lines of code are commented out in this method. These demonstrate different null-handling techniques.

Direct Assignment

java

//String str2 = str;

• This line simply assigns str to str2. If str is null, str2 will also be null.

Using Objects.requireNonNull

java

//String str2 = Objects.requireNonNull(str);

• This throws a NullPointerException if str is null.

With a Custom Error Message

java

//String str2 = Objects.requireNonNull(str, "So you need to supply non null values");

• This version of requireNonNull throws a NullPointerException with a custom error message if str is null.

Using Objects.requireNonNullElse

java

//String str2 = Objects.requireNonNullElse(str, "Hi, I am a Default string");

• This returns the value of str if it's non-null. Otherwise, it returns the provided default string "Hi, I am a Default string".

Using Objects.requireNonNullElseGet

java

Supplier<String> strSupplier = () -> LocalDate.now().toString();
//String str2 = Objects.requireNonNullElseGet(str, strSupplier);

• A Supplier<String> is created to provide the current date as a string. If str is null, this supplier is used to generate a fallback value.

Alternative Supplier Usage

java

//String str2 = Objects.requireNonNullElseGet(str, () -> LocalDate.now().toString());

• This line is similar to the previous one but uses a lambda expression directly for the supplier instead of a separate variable.

6. Active Code: Using Optional for Null Handling

java

String str2 = Optional.ofNullable(str).orElse("nonNull");
System.out.println(str2);

• Optional.ofNullable(str) creates an Optional object from str, which can either contain the value of str or be empty if str is null.
• .orElse("nonNull") returns the value of str if it's not null. Otherwise, it returns the string "nonNull".
• This line effectively handles the case where str is null by providing a fallback string "nonNull".
• The result is printed to the console.

7. Main Method

java

public static void main(String[] args) {
    testStringNulls(null);
}

• The main method is the entry point of the program.
• It calls testStringNulls(null), passing null as the argument. This will invoke the null handling logic inside the testStringNulls method.

Execution Flow

1. When the main method is executed, it calls testStringNulls with null as the argument.
2. Inside testStringNulls, Optional.ofNullable(null).orElse("nonNull") is evaluated.

• Since str is null, the "nonNull" string is returned.

1. The value "nonNull" is printed to the console.

Conclusion

This code demonstrates various ways to handle null values in Java, offering both simple and more advanced approaches:

• Objects.requireNonNull is useful for throwing exceptions when a value is unexpectedly null.
• Objects.requireNonNullElse provides a default value if a string is null.
• Objects.requireNonNullElseGet allows for dynamic fallback values, such as generating the current date.
• Optional is a powerful tool for managing nullable values in a clean, readable way without explicit null checks.

Each of these methods provides a different way to deal with potential null values, making the code more robust and preventing NullPointerExceptions.