Java 8 Method References and Optional: Concise Coding with Functional Interfaces

Java 8 introduced method references and the Optional class to make code more concise and null‑safe.

1: Concise

Method references use the :: operator and serve as an alternative syntax for functional interfaces.

Static method reference: ClassName::staticMethod (e.g., Integer::parseInt )

Instance method reference: instance::method (e.g., str::substring )

Constructor reference: ClassName::new (e.g., User::new )

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

Assigning a method reference to a variable of a functional interface type (e.g., Function<String,Integer> fun = Integer::parseInt ) demonstrates that method references are a form of functional interface implementation.

2: Method References in Practice

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());

    // passing method reference as argument
    sayHello(String::toUpperCase, "hello");
}
private static void sayHello(Function
func, String parameter) {
    System.out.println(func.apply(parameter));
}

3: Optional – A Safer Alternative to Null

The Optional class, now part of the Java standard library, provides a container that may or may not hold a non‑null value, helping to avoid NullPointerException .

public final class Optional
{
    private static final Optional
EMPTY = new Optional<>();
    private final T value;
    private Optional() { this.value = null; }
    private Optional(T value) { this.value = Objects.requireNonNull(value); }

    public static
Optional
empty() { return (Optional
) EMPTY; }
    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
Optional
map(Function
mapper) { return isPresent() ? Optional.ofNullable(mapper.apply(value)) : empty(); }
    public
Optional
flatMap(Function
> mapper) { return isPresent() ? Objects.requireNonNull(mapper.apply(value)) : empty(); }
    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(); }
}

Typical usage:

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));

These examples illustrate how method references and Optional can lead to more readable and robust Java code.