다인자·기본형 인터페이스

import java.util.ArrayList;
import java.util.List;
import java.util.function.Function;

public final class BoxedNumericPipeline {
    static List<Integer> apply(List<Integer> values, Function<Integer, Integer> operator) {
        List<Integer> result = new ArrayList<>();
        for (Integer value : values) {
            result.add(operator.apply(value));
        }
        return result;
    }

    public static void main(String[] args) {
        System.out.println(apply(List.of(1, 2, 3), value -> value * 2));
    }
}

import java.util.ArrayList;
import java.util.List;
import java.util.function.BiConsumer;
import java.util.function.BiFunction;
import java.util.function.IntPredicate;
import java.util.function.IntUnaryOperator;
import java.util.function.ToIntFunction;

public final class BiAndPrimitiveInterfaces {
    record Item(String name, int price) {
    }

    public static void main(String[] args) {
        BiFunction<Integer, Integer, Integer> discounted = (price, percent) ->
                price - price * percent / 100;
        ToIntFunction<Item> priceOf = Item::price;
        IntPredicate withinBudget = price -> price <= 100;
        IntUnaryOperator addShipping = price -> price + 5;
        List<String> audit = new ArrayList<>();
        BiConsumer<Item, Integer> record = (item, finalPrice) ->
                audit.add(item.name() + "=" + finalPrice);

        for (Item item : List.of(new Item("Book", 80), new Item("Desk", 220))) {
            int sale = discounted.apply(priceOf.applyAsInt(item), 10);
            int finalPrice = addShipping.applyAsInt(sale);
            if (withinBudget.test(finalPrice)) {
                record.accept(item, finalPrice);
            }
        }
        System.out.println(audit);
    }
}

import java.util.Objects;
import java.util.function.Function;

public final class TriFunctionComposition {
    @FunctionalInterface
    interface TriFunction<A, B, C, R> {
        R apply(A first, B second, C third);

        default <V> TriFunction<A, B, C, V> andThen(Function<? super R, ? extends V> next) {
            Objects.requireNonNull(next);
            return (first, second, third) -> next.apply(apply(first, second, third));
        }
    }

    record Quote(int distanceKm, int weightKg, boolean express, int fee) {
    }

    public static void main(String[] args) {
        TriFunction<Integer, Integer, Boolean, Integer> fee = (distance, weight, express) -> {
            int base = 3000 + distance * 20 + weight * 500;
            return express ? base * 2 : base;
        };
        TriFunction<Integer, Integer, Boolean, Quote> quote = (distance, weight, express) ->
                new Quote(distance, weight, express, fee.apply(distance, weight, express));
        TriFunction<Integer, Integer, Boolean, String> summary = quote.andThen(value ->
                value.distanceKm() + "km/" + value.weightKg() + "kg=" + value.fee());
        System.out.println(fee.apply(10, 2, false));
        System.out.println(quote.apply(12, 3, true));
        System.out.println(summary.apply(5, 1, false));
    }
}