Understanding Java Method References, Optional, and Static Factory Methods

Java method references provide a concise way to refer to existing methods using the double‑colon :: operator. They can be categorized into three forms: static method references (e.g., Integer::parseInt), instance method references (e.g., str::substring), and constructor references (e.g., User::new).

These references are compatible with functional interfaces, allowing them to be assigned to variables such as Function or BiFunction. The following example demonstrates static, instance, and constructor references in action:

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

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

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

    // method reference as a parameter
    sayHello(String::toUpperCase, "hello");
}

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

The Optional class, introduced in Java 8, offers a robust way to handle potentially null values and avoid NullPointerException. It provides factory methods such as of, ofNullable, and empty, as well as operations like get, isPresent, ifPresent, orElse, orElseGet, and orElseThrow. Below is a simplified implementation of Optional:

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 methods omitted for brevity
}

In practice, Optional is used to make code more expressive and safe, as shown in the following main method example:

public static void main(String[] args) {
    String msg = "hello";
    Optional<String> optional = Optional.of(msg);
    boolean present = optional.isPresent();
    String value = optional.get();
    String hi = optional.orElse("hi");
    optional.ifPresent(opt -> System.out.println(opt));
}

Finally, the article promotes a community for architects and encourages readers to share and join discussion groups, but the technical content above stands on its own as a concise guide to method references, the Optional utility, and static factory methods in Java.