How do I filter Optional values based on a condition?

By I Wayan Saryada in Util Package 0 Comment

In Java, you can use the Optional API to filter values based on a condition using the filter method. The filter method takes a predicate as an argument and applies it to the value contained in the Optional. If the predicate evaluates to true, the Optional is returned unchanged. If the predicate evaluates to false, an empty Optional is returned.

Here’s an example:

Example:

package org.kodejava.util;

import java.util.Optional;

public class OptionalFilterExample {
   public static void main(String[] args) {
      // Create an Optional with a value
      Optional<String> optionalValue = Optional.of("hello");

      // Filter the Optional value based on a condition
      Optional<String> filteredValue = optionalValue.filter(value -> value.length() > 3);

      // If the value passes the filter, print it
      filteredValue.ifPresent(System.out::println); // Output: hello

      // Example where the filter does not match
      Optional<String> emptyValue = optionalValue.filter(value -> value.length() > 10);
      System.out.println(emptyValue.isPresent()); // Output: false
   }
}

Explanation:

  1. Initial Value: The Optional is created with the value "hello".
  2. Filtering: The filter method takes a predicate (value -> value.length() > 3) and applies it to the contained value.
    • If the predicate is true (length is greater than 3), the Optional retains the value.
    • If the predicate is false (e.g., length is less than 10), the result is an empty Optional.
  3. Accessing Results: The ifPresent method is used to print the value if it is still present, or use isPresent to evaluate if the result is empty.

Summary:

  • Use Optional.filter(Predicate<T>) to conditionally retain the value in an Optional.
  • If the predicate fails, the Optional becomes empty.
  • Combine Optional with ifPresent, isPresent, or orElse to handle the filtered result.

How do I use Optional to refactor nested null checks?

By I Wayan Saryada in Util Package 0 Comment

Using Optional in Java is a great way to refactor nested null checks into more readable and maintainable code. Below, I’ll explain how you can use Optional to replace deeply nested null checks step by step with examples.

Example of Nested Null Checks

Consider this code with deeply nested null checks:

String streetName = null;

if (user != null) {
    Address address = user.getAddress();
    if (address != null) {
        Street street = address.getStreet();
        if (street != null) {
            streetName = street.getName();
        }
    }
}

Here, multiple if statements are used to avoid NullPointerException. This can make the code verbose and harder to read.

Refactoring with Optional

You can refactor this using Optional to create a chain of operations that handle nulls more elegantly:

String streetName = Optional.ofNullable(user)
    .map(User::getAddress)  // get Address if user is not null
    .map(Address::getStreet) // get Street if Address is not null
    .map(Street::getName)    // get Name if Street is not null
    .orElse(null);           // return null if any step is null

This way, you eliminate the explicit null checks and reduce the overall complexity of the code.

Explanation of the Refactored Code

  • Optional.ofNullable(user)
    Wraps the user object in an Optional. If user is null, it creates an empty Optional to safely handle further processing.

  • .map()

    • Applies the method if the value is present; otherwise, it returns an empty Optional.
    • For example, map(User::getAddress) calls getAddress only if user is not null.
  • .orElse(null)
    Provides a fallback value in case the chain results in an empty Optional, i.e., if any intermediate object was null.

Variations

1. Provide a Default Value Instead of Null

You can replace null with any default value like this:

String streetName = Optional.ofNullable(user)
    .map(User::getAddress)
    .map(Address::getStreet)
    .map(Street::getName)
    .orElse("Default Street");

If user or any intermediate object is null, "Default Street" will be assigned to streetName.

2. Throw Exception if Value is Missing

String streetName = Optional.ofNullable(user)
    .map(User::getAddress)
    .map(Address::getStreet)
    .map(Street::getName)
    .orElseThrow(() -> new IllegalArgumentException("Street name not found!"));

This method will throw an exception if any object in the chain is null.

3. Perform an Action if Value Exists

You can perform a side effect or some action if the resulting value isn’t null:

Optional.ofNullable(user)
    .map(User::getAddress)
    .map(Address::getStreet)
    .map(Street::getName)
    .ifPresent(name -> System.out.println("Street: " + name));

This approach avoids the need to explicitly check equality with null.

Benefits of Using Optional for Null Checks

  1. Improved Readability:
    Eliminates nested if statements and reduces verbosity.

  2. Clear Intent:
    It’s evident that the code is handling potentially null objects.

  3. Avoid NullPointerException:
    Safeguards code without explicit null checks by the chaining mechanism.

  4. Encourages Functional Style:
    Methods like map, orElse, and ifPresent allow for a clean, declarative style of programming.

When Not to Use Optional

While Optional is a powerful tool, it’s not meant to replace all null checks. Avoid using Optional:

  1. For fields in entities/classes (use only for method return values).
  2. When null checks aren’t deeply nested (a simple if might be more appropriate).

With Optional, you get safer and cleaner null handling in your Java code, making it easier to maintain and debug!

How do I conditionally execute code with Optional’s ifPresent and ifPresentOrElse?

By I Wayan Saryada in Util Package 0 Comment

In Java, the Optional class provides methods for handling values that may or may not be present. The methods ifPresent and ifPresentOrElse are particularly useful for executing code conditionally based on whether a value is present in the Optional.

1. Using ifPresent

The ifPresent method executes a Consumer when the value is present (i.e., it’s not null). If the Optional is empty, it does nothing. This is useful when you only want to handle the presence of a value and don’t need any fallback action when the value is absent.

Example:

package org.kodejava.util;

import java.util.Optional;

public class OptionalIfPresentExample {
    public static void main(String[] args) {
        // Create an Optional with a value
        Optional<String> optionalValue = Optional.of("Hello, Optional!");

        // Execute only if a value is present
        optionalValue.ifPresent(value -> System.out.println("Value is: " + value));

        // Create an empty Optional
        Optional<String> emptyOptional = Optional.empty();

        // Nothing happens here
        emptyOptional.ifPresent(value -> System.out.println("This won't be printed."));
    }
}

Output:

Value is: Hello, Optional!

2. Using ifPresentOrElse

The ifPresentOrElse method executes a Consumer if the value is present, and executes a Runnable if the value is absent. This is helpful if you want to handle both cases (presence and absence) explicitly.

Example:

package org.kodejava.util;

import java.util.Optional;

public class OptionalIfPresentOrElseExample {
    public static void main(String[] args) {
        // Create an Optional with a value
        Optional<String> optionalValue = Optional.of("Hello, Optional!");

        // Execute the consumer if the value is present, otherwise execute the runnable
        optionalValue.ifPresentOrElse(
                value -> System.out.println("Value is: " + value),
                () -> System.out.println("Value is not present")
        );

        // Create an empty Optional
        Optional<String> emptyOptional = Optional.empty();

        // Handle the absence of value
        emptyOptional.ifPresentOrElse(
                value -> System.out.println("This won't be printed."),
                () -> System.out.println("Value is not present")
        );
    }
}

Output:

Value is: Hello, Optional!
Value is not present

Key Differences:

  1. ifPresent: Only executes when the value is present. It doesn’t account for the absent case.
  2. ifPresentOrElse: Handles both the presence and absence cases, allowing you to define fallback behavior when the value is missing.

Use case:

  • Use ifPresent when you only care about taking action if the value is present.
  • Use ifPresentOrElse when you also want to explicitly perform some alternate action if the value is absent.

How do I throw exceptions if Optional is empty using orElseThrow?

By I Wayan Saryada in Util Package 0 Comment

In Java, you can throw exceptions when an Optional is empty using the orElseThrow method. This method accepts a Supplier that provides the exception to be thrown if the Optional is empty.

Here’s the syntax and an example:

package org.kodejava.util;

import java.util.Optional;

public class Main {
   public static void main(String[] args) {
      Optional<String> optionalValue = Optional.empty();

      // Throws an exception if Optional is empty
      String value = optionalValue.orElseThrow(() -> new IllegalArgumentException("Value is not present"));

      System.out.println(value);
   }
}

Explanation:

  1. orElseThrow():
    • This method is used to retrieve the value from an Optional.
    • If the Optional is empty (Optional.empty()), it throws the exception provided by the Supplier.
  2. Key Points:
    • orElseThrow takes a lambda expression or method reference as its argument. This lambda (or Supplier) returns the exception to be thrown.
    • Example of a custom exception:
    Optional<String> optionalValue = Optional.empty();

String value = optionalValue.orElseThrow(() -> new MyCustomException("Custom message"));
  3. Method Reference Example:
    If the exception has a default constructor, you can use a method reference:

    Optional<String> optionalValue = Optional.empty();

String value = optionalValue.orElseThrow(MyCustomException::new);
  4. When Optional is not empty:
    If the Optional contains a value (i.e., Optional.of("value")), the value is retrieved instead of throwing an exception.

    Optional<String> optionalValue = Optional.of("Hello");

String value = optionalValue.orElseThrow(() -> new IllegalArgumentException("Value is not present"));

System.out.println(value); // Prints "Hello"

Custom Exception Example:

If you want to define your own custom exception:

class MyCustomException extends RuntimeException {
    public MyCustomException(String message) {
        super(message);
    }
}

And use it with orElseThrow:

Optional<String> optionalValue = Optional.empty();

String value = optionalValue.orElseThrow(() -> new MyCustomException("Custom exception message"));

Using orElseThrow is a clean and concise way to handle empty Optional values by throwing appropriate exceptions.

How do I use listeners like ServletContextListener for lifecycle management?

By I Wayan Saryada in Servlet 0 Comment

In Jakarta EE (formerly Java EE), you can use listeners like ServletContextListener to manage the lifecycle of a web application’s ServletContext. It provides hooks to execute logic during the initialization and destruction stages of the application. This can be useful for resource initialization, cleanup, or logging purposes.

Here’s how you can use ServletContextListener:

1. Implementing ServletContextListener

Create a class that implements the ServletContextListener interface. There are two main methods you can override:

  • contextInitialized(): This method is triggered when the ServletContext is initialized (before the web application starts serving requests).
  • contextDestroyed(): This method is triggered when the ServletContext is about to be destroyed (e.g., when the server shuts down or the application is undeployed).

Example

package org.kodejava.servlet;

import jakarta.servlet.ServletContextEvent;
import jakarta.servlet.ServletContextListener;
import jakarta.servlet.annotation.WebListener;

@WebListener
public class AppLifecycleListener implements ServletContextListener {

    @Override
    public void contextInitialized(ServletContextEvent sce) {
        // Code to execute during application startup
        System.out.println("Web application starting up...");
        // Example: Initialize resources, setup logging, load configuration, etc.
    }

    @Override
    public void contextDestroyed(ServletContextEvent sce) {
        // Code to execute during application shutdown
        System.out.println("Web application shutting down...");
        // Example: Release resources, close connections, etc.
    }
}

2. Registering the Listener

There are two ways to associate the listener with your web application:

a) Using the @WebListener Annotation

The simplest way is to annotate the class with @WebListener. This automatically registers the listener in your application without requiring any additional configuration.

@WebListener
public class AppLifecycleListener implements ServletContextListener {
    // Implementation as shown previously
}

b) Declaring in web.xml

Alternatively, you can declare the listener in the web.xml deployment descriptor:

<web-app xmlns="https://jakarta.ee/xml/ns/jakartaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="https://jakarta.ee/xml/ns/jakartaee https://jakarta.ee/xml/ns/jakartaee/web-app_6_0.xsd"
         version="6.0">
    <listener>
        <listener-class>com.example.AppLifecycleListener</listener-class>
    </listener>
</web-app>

3. Common Use Cases

Here are a few common scenarios where you might use ServletContextListener:

  1. Loading Configuration Files: Load configuration settings from a file or database when the application starts. 
    @Override
public void contextInitialized(ServletContextEvent sce) {
   ServletContext context = sce.getServletContext();
   context.setAttribute("config", "some config value or object");
}
  2. Resource Initialization and Cleanup: Initialize shared resources (e.g., database connections, thread pools) in contextInitialized() and close them in contextDestroyed(). 
    @Override
public void contextInitialized(ServletContextEvent sce) {
   System.out.println("Initializing database connection...");
   // Initialize DB connection pool
}

@Override
public void contextDestroyed(ServletContextEvent sce) {
   System.out.println("Closing database connection...");
   // Close DB connection pool
}
  3. Setting Context Attributes: Use ServletContext object to set attributes accessible by the entire application. 
    sce.getServletContext().setAttribute("appName", "My Application");
  4. Third-Party Integrations: Initialize third-party libraries or services during startup and dispose of them during shutdown.

Key Points to Remember

  • The contextInitialized() method is invoked before the application starts serving requests.
  • The contextDestroyed() method ensures proper cleanup when the application is shutting down.
  • Use the @WebListener annotation for easy configuration or declare the listener in web.xml for manual control.
  • Avoid long-running or blocking operations inside lifecycle methods as it might delay the application startup or shutdown process.

By efficiently using ServletContextListener, you can centralize important application lifecycle tasks and manage resources effectively.

Maven dependencies

<dependency>
    <groupId>jakarta.servlet</groupId>
    <artifactId>jakarta.servlet-api</artifactId>
    <version>6.1.0</version>
    <scope>provided</scope>
</dependency>

Maven Central