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

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

    // constructor reference
    BiFunction
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
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
{
    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 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
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.