lambda表达式含义

lambda表达式是对某些接口的简单实现，Lambda 规定接口中只能有一个需要被实现的方法，不是规定接口中只能有一个方法，这就是函数式接口。 ** lambda表达式引入“->” 左侧代表参数列表，右侧代表需要的功能，逻辑

Consumer<String> con = (c) -> System.out.println(c);

函数式接口

1.什么是函数式接口

（1）、只包含一个抽象方法的接口，称为函数式接口。 （2）、你可以通过Lambda表达式来创建该接口的对象。（若Lambda表达式抛出一个受检异常，那么该异常需要在目标接口的抽象方法上进行声明）。 （3）、我们可以在任意函数式接口上使用@FunctionalInterface注解，这样做可以检查它是否是一个函数式接口，同时javadoc也会包含一条声明，说明这个接口是一个函数式接口。

2.自定义函数

示例代码一：

@FunctionalInterface
public interface MyNumber{
    public double getValue();
}

示例代码二：函数式接口中使用泛型

@FunctionalInterface
public interface MyFunc<T>{
    public  T  getValue(T t);
}

3.作为参数传递Lambda表达式

示例代码：

public String strHandler(String str, MyFunction mf) {
        return mf.getValue(str);
    }
作为参数传递Lambda表达式：
String trimStr = strHandler("\t\t 你是大傻逼       ", (str) -> str.trim());
String upperStr = strHandler("abcdefg", (str) -> str.toUpperCase());
String newStr = strHandler("我大望江威武", (str) -> str.substring(2, 5));

作为参数传递Lambda表达式：为了将Lambda表达式作为参数传递，接收Lambda表达式的参数类型必须是与该Lambda表达式兼容的函数式接口的类型。

4.四大内置核心函数式接口

一、Consumer：消费型接口（void accept(T t)）

**　　**consumer 接口翻译过来就是消费者,顾名思义，该接口对应的方法类型为接收一个参数，没有返回值，可以通俗的理解成将这个参数'消费掉了'，一般来说使用Consumer接口往往伴随着一些期望状态的改变或者事件的发生,例如最典型的forEach就是使用的Consumer接口，虽然没有任何的返回值，但是却向控制台输出了语句。 Consumer 使用accept对参数执行行为

/**
     * 消费型接口Consumer<T>
     */
    @Test
    public void test1 () {
        consumo(500, (x) -> System.out.println(x));
    }

    public void consumo (double money, Consumer<Double> c) {
        c.accept(money);
    }

以上为消费型接口，有参数，无返回值类型的接口。

二、Supplier：供给型接口（T get（））

Supplier 接口翻译过来就是提供者,和上面的消费者相反，该接口对应的方法类型为不接受参数，但是提供一个返回值，通俗的理解为这种接口是无私的奉献者，不仅不要参数，还返回一个值,使用get()方法获得这个返回值

/**
     * 供给型接口，Supplier<T>
     */
    @Test
    public void test2 () {
        Random ran = new Random();
        List<Integer> list = supplier(10, () -> ran.nextInt(10));

        for (Integer i : list) {
            System.out.println(i);
        }
    }

    /**
     * 随机产生sum个数量得集合
     * @param sum 集合内元素个数
     * @param sup
     * @return
     */
    public List<Integer> supplier(int sum, Supplier<Integer> sup){
        List<Integer> list = new ArrayList<Integer>();
        for (int i = 0; i < sum; i++) {
            list.add(sup.get());
        }
        return list;
    }

上面就是一个供给类型得接口，只有产出，没人输入，就是只有返回值，没有入参

三、Function<T, R>：函数型接口（R apply（T t））

function,顾名思义,函数的意思,这里的函数是指数学上的函数哦,你也可以说是严格函数语言中的函数,例如haskell里的,他接受一个参数,返回一个值,永远都是这样,是一个恒定的,状态不可改变的方法。其实想讲函数这个彻底将明白可以再开一篇博客了,所以这里不详细的说了。    上面说到,函数接口是对行为的抽象,因此我方便大家理解,就用java中的方法作例子。

/**
     * 函数型接口：Function<R, T>
     */
    @Test
    public void test3 () {
        String s = strOperar(" asdf ", x -> x.substring(0, 2));
        System.out.println(s);
        String s1 = strOperar(" asdf ", x -> x.trim());
        System.out.println(s1);
    }

    /**
     * 字符串操作
     * @param str 需要处理得字符串
     * @param fun Function接口
     * @return 处理之后得字符传
     */
    public String strOperar(String str, Function<String, String> fun) {
        return fun.apply(str);
    }

上面就是一个函数型接口，输入一个类型得参数，输出一个类型得参数，当然两种类型可以一致。

四、Predicate：断言型接口（boolean test（T t））

predicate<T,Boolean> 谓语接口，顾名思义，中文中的‘是’与‘不是’是中文语法的谓语，同样的该接口对应的方法为接收一个参数，返回一个Boolean类型值，多用于判断与过滤，当然你可以把他理解成特殊的Funcation<T,R>，但是为了便于区分语义，还是单独的划了一个接口，使用test()方法执行这段行为

/**
     * 断言型接口：Predicate<T>
     */
    @Test
    public void test4 () {
        List<Integer> l = new ArrayList<>();
        l.add(102);
        l.add(172);
        l.add(13);
        l.add(82);
        l.add(109);
        List<Integer> list = filterInt(l, x -> (x > 100));
        for (Integer integer : list) {
            System.out.println(integer);
        }
    }

    /**
     * 过滤集合
     * @param list
     * @param pre
     * @return
     */
    public List<Integer> filterInt(List<Integer> list, Predicate<Integer> pre){
        List<Integer> l = new ArrayList<>();
        for (Integer integer : list) {
            if (pre.test(integer))
                l.add(integer);
        }
        return l;
    }

上面就是一个断言型接口，输入一个参数，输出一个boolean类型得返回值。

总结

四大函数接口和他们引申出的各类接口，终点是对不同种类行为的封装导致了设计出不同的函数接口，另外在使用函数接口或者lambda表达式的时候，要注意lambda对值封闭这个特性。

方法引用与构造器引用

方法引用

当要传递给Lambda体的操作，已经有实现的方法，就可以使用方法引用！ 实现抽象方法的参数列表，必须与方法引用方法的参数列表保持一致 方法引用使用操作符“::”将方法名和对象或者类的名字分隔开来。 三种使用情况： 对象::实例方法 类::静态方法 类::实例方法

例如

BinaryOperator bo=(x,y)->Math.pow(x,y)

等同于：

BinaryOperator<Double> bo=Math::pow;

 /*
    * 类::静态方法
    * Comparator的Compare(T t1,T t2)
    * Integer的Compare(T t1,T t2)
    * */
Comparator<Integer> com1 = (t1,t2) -> Integer.compare(t1,t2);
        System.out.println(com1.compare(21,20));
        System.out.println("------------");
        Comparator<Integer> com2 = Integer::compare;
        System.out.println(com2.compare(12,14));

构造器引用（了解）

格式：ClassName::new 与函数式接口相结合，自动与函数式接口中方法兼容。 可以把构造器引用赋值给定义的方法，与构造器参数列表要与接口中抽象方法的参数列表一直 例如：

Function<Integer,MyClass> fun=(n)->new MyClass(n);

等同于：

Function<Integer,MyClass> fun=MyClass::new;

数组引用（了解）

格式：type[]::new 例如：

Function<Integer,Integer[]> fun=(n)->new Integer[n];

等同于：

Function<Integer,Integer[]> fun=Integer[]::new;