Understanding Java Method References and Optional: A Practical Guide

The author, a senior architect, introduces two important Java 8 features: method references and the Optional class, demonstrating how they make code more concise and safer.

1. Method References

Method references use the double‑colon :: syntax and serve as a compact way to express functional interfaces. Three types are covered:

Static method reference, e.g., Integer::parseInt .

Instance method reference, e.g., str::substring .

Constructor reference, e.g., User::new .

public final class Integer {
    public static int parseInt(String s) throws NumberFormatException {
        return parseInt(s, 10);
    }
}

public class User {
    private String username;
    private Integer age;
    public User() {}
    public User(String username, Integer age) {
        this.username = username;
        this.age = age;
    }
    @Override
    public String toString() {
        return "User{" + "username='" + username + '\'' + ", age=" + age + '}';
    }
}

public static void main(String[] args) {
    Function
fun = Integer::parseInt;
    Integer value = fun.apply("123");
    System.out.println(value);

    String content = "Hello JDK8";
    Function
func = content::substring;
    String result = func.apply(1);
    System.out.println(result);

    BiFunction
biFunction = User::new;
    User user = biFunction.apply("mengday", 28);
    System.out.println(user.toString());

    sayHello(String::toUpperCase, "hello");
}

private static void sayHello(Function
func, String parameter) {
    String result = func.apply(parameter);
    System.out.println(result);
}

Method references can be assigned to variables of functional interface types, passed as arguments, and used wherever a lambda expression would be appropriate.

2. Optional Class

The Optional class, originally from Guava and now part of Java 8, provides a container that may or may not hold a non‑null value, helping to avoid NullPointerException . Common operations include of , ofNullable , get , isPresent , ifPresent , orElse , and map .

public final class Optional
{
    private static final Optional
EMPTY = new Optional<>();
    private final T value;
    private Optional() { this.value = null; }
    public static
Optional
empty() { return (Optional
) EMPTY; }
    private Optional(T value) { this.value = Objects.requireNonNull(value); }
    public static
Optional
of(T value) { return new Optional<>(value); }
    public static
Optional
ofNullable(T value) { return value == null ? empty() : of(value); }
    public T get() { if (value == null) throw new NoSuchElementException("No value present"); return value; }
    public boolean isPresent() { return value != null; }
    public void ifPresent(Consumer
consumer) { if (value != null) consumer.accept(value); }
    public T orElse(T other) { return value != null ? value : other; }
    public T orElseGet(Supplier
other) { return value != null ? value : other.get(); }
    public
T orElseThrow(Supplier
exceptionSupplier) throws X { if (value != null) return value; else throw exceptionSupplier.get(); }
    // map, flatMap, filter, etc.
}

Typical usage creates an Optional with Optional.of(value) , checks presence with isPresent() , retrieves the value with get() , or provides a fallback with orElse . The class also supports functional transformations via map and flatMap .

Overall, method references and Optional together enable more declarative, null‑safe Java code.