java Lambda表达式

函数式接口

是指接口是只有一个方法的接口，用@FunctionalInterface注解可以检测接口是否为函数式接口.
四种基本的函数式接口
他共有四种核心的函数式接口

一、功能性接口：Function 接收一个功能参数t，并返回一个功能结果R。

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<String,String> function = (str) -> "hello,"+str;

        Function<String,String> function = (str) ->{
            return "hello,"+str;
        };
        String str = function.apply("Tassel");
        System.out.println(str);

二、断言性接口：Predicate 主要用到test方法 其中参数t为输入参数，如果输入参数符合断言则返回true，否则false

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

举例子：下面的等价于 “Hello”.equalsIgnoreCase(t) //t:输入参数

    Predicate<String> predicate = "Hello"::equalsIgnoreCase;
    System.out.println(predicate.test("Hello"));

三、供给性接口：Supplier 不接收任何参数 但有返回值

@FunctionalInterface
public interface Supplier<T> {
 
    T get();
}
        Supplier supplier = "Hello"::toLowerCase;
        System.out.println(supplier);

四、消费性接口：Consumer 只接收一个参数t，但是没有返回值。

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<String> consumer = System.out ::println;
        consumer.accept("1111");
        ArrayList<String> arrayList = new ArrayList<>();
        Consumer<ArrayList> consumer = (e)-> e.add("111");

Lambda表达式

用来实例化函数式接口
->的左边（）中 表示方法中的参数
->的右边{ }中的内容表示方法中的方法体

import java.util.function.Consumer;

public class lambda {
    public static void main(String[] args) {
        Consumer<String> consumer = s -> System.out.print(s);
        consumer.accept("my");
    }
}

方法的引用

package my;


import java.util.function.Consumer;

public class lambda {
    public static void main(String[] args) {
        Consumer<String> consumer = System.out::println;
        consumer.accept("my");
    }
}