date[2018-12-18]

说明

1. Lambda表达式是一个匿名方法，将行为像数据一样进行传递。
2. Lambda表达式的常见结构： BinaryOperator<Integer> add = (x, y) -> x + y。
3. 函数接口指仅具有单个抽象方法的接口，用来表示 Lambda表达式的类型。

常见函数接口

使用Consumer接口

package java.util.function;

import java.util.Objects;
@FunctionalInterface
public interface Consumer<T> {
    void accept(T t);

    default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}

使用Consumer

    Consumer<String> consumer = (s) -> {
        System.out.println("c:" + s);
    };
    forEach(list, consumer);
        
    public static <T> void forEach(List<T> list, Consumer<T> c) {
        for (T t : list) {
            c.accept(t);
        }
    }

Predicate 接口

package java.util.function;

import java.util.Objects;
@FunctionalInterface
public interface Predicate<T> {
    boolean test(T t);

    default Predicate<T> and(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) && other.test(t);
    }

    default Predicate<T> negate() {
        return (t) -> !test(t);
    }

    default Predicate<T> or(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) || other.test(t);
    }

    static <T> Predicate<T> isEqual(Object targetRef) {
        return (null == targetRef)
                ? Objects::isNull
                : object -> targetRef.equals(object);
    }

    @SuppressWarnings("unchecked")
    static <T> Predicate<T> not(Predicate<? super T> target) {
        Objects.requireNonNull(target);
        return (Predicate<T>)target.negate();
    }
}

使用Predicate

    Predicate<String> moreThan5 = (s) -> s.length() > 5;
    List<String> moreThan5List = filter(list, moreThan5);
    
    public static <T> List<T> filter(List<T> list, Predicate<T> p) {
        List<T> result = new ArrayList<>();
        for (T t : list) {
            if (p.test(t)) {
                result.add(t);
            }
        }
        return result;
    }

Function

package java.util.function;

import java.util.Objects;
@FunctionalInterface
public interface Function<T, R> {
    R apply(T t);
    
    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }
    
    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }
    
    static <T> Function<T, T> identity() {
        return t -> t;
    }
}

使用Function

    Function<String, Integer> function = (s) -> {
                return s.length();
            };
        map(list, function).forEach(
                System.out::println
        );
    public static <T, R> List<R> map(List<T> list, Function<T, R> f) {
        List<R> result = new ArrayList<>();
        for (T t : list) {
            result.add(f.apply(t));
        }
        return result;
    }

其它函数接口

1.png