표준 함수형 인터페이스

public final class DuplicateFunctionalTypes {
    @FunctionalInterface
    interface Parser<T, R> {
        R parse(T value);
    }

    @FunctionalInterface
    interface Formatter<T, R> {
        R format(T value);
    }

    @FunctionalInterface
    interface Mapper<T, R> {
        R map(T value);
    }

    public static void main(String[] args) {
        Parser<String, Integer> parser = Integer::parseInt;
        Formatter<Integer, String> formatter = value -> "#" + value;
        Mapper<String, String> mapper = String::trim;
        System.out.println(formatter.format(parser.parse(mapper.map(" 7 "))));
    }
}

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;
import java.util.function.UnaryOperator;

public final class StandardFunctionToolkit {
    record Reading(String traceId, int value) {
    }

    public static void main(String[] args) {
        Function<String, String> normalize = String::trim;
        Function<String, Integer> parse = Integer::parseInt;
        Function<String, Integer> normalizedNumber = normalize.andThen(parse);
        UnaryOperator<Integer> calibrate = value -> value + 2;
        Predicate<Integer> accepted = value -> value >= 0 && value <= 100;
        AtomicInteger sequence = new AtomicInteger();
        Supplier<String> traceId = () -> "trace-" + sequence.incrementAndGet();
        List<Reading> sink = new ArrayList<>();
        Consumer<Integer> store = value -> sink.add(new Reading(traceId.get(), value));

        for (String raw : List.of(" 10 ", " 120 ", " -3 ", " 40 ")) {
            int value = calibrate.apply(normalizedNumber.apply(raw));
            if (accepted.test(value)) {
                store.accept(value);
            }
        }
        System.out.println(sink);
        System.out.println("generatedIds=" + sequence.get());
    }
}

import java.util.Objects;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.Supplier;

public final class LazySupplierMemoizer {
    static <T> Supplier<T> memoizeSuccessful(Supplier<? extends T> source) {
        Objects.requireNonNull(source);
        return new Supplier<>() {
            private boolean initialized;
            private T value;

            @Override
            public synchronized T get() {
                if (!initialized) {
                    T created = Objects.requireNonNull(source.get(), "supplier returned null");
                    value = created;
                    initialized = true;
                }
                return value;
            }
        };
    }

    public static void main(String[] args) {
        AtomicInteger calls = new AtomicInteger();
        Supplier<String> source = () -> {
            int call = calls.incrementAndGet();
            if (call == 1) {
                throw new IllegalStateException("temporary failure");
            }
            return "value-" + call;
        };
        Supplier<String> cached = memoizeSuccessful(source);
        try {
            cached.get();
        } catch (IllegalStateException exception) {
            System.out.println(exception.getMessage());
        }
        System.out.println(cached.get());
        System.out.println(cached.get());
        System.out.println("sourceCalls=" + calls.get());
    }
}