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<String, Integer> fun = Integer::parseInt;
    Integer value = fun.apply("123");
    System.out.println(value);

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

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

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

private static void sayHello(Function<String, String> 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<T> {
    private static final Optional<?> EMPTY = new Optional<>();
    private final T value;
    private Optional() { this.value = null; }
    public static <T> Optional<T> empty() { return (Optional<T>) EMPTY; }
    private Optional(T value) { this.value = Objects.requireNonNull(value); }
    public static <T> Optional<T> of(T value) { return new Optional<>(value); }
    public static <T> Optional<T> 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<? super T> consumer) { if (value != null) consumer.accept(value); }
    public T orElse(T other) { return value != null ? value : other; }
    public T orElseGet(Supplier<? extends T> other) { return value != null ? value : other.get(); }
    public <X extends Throwable> T orElseThrow(Supplier<? extends X> 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.