lambda表达式使用

介绍：

Lambda表达式可以替代只有一个抽象函数的接口实现 ，告别匿名内部类，代码看起来更简洁易懂，Lambda表达式同时还提升了对集合、框架的迭代、遍历、过滤数据的操作。

特点：

1、函数式编程

 

2、参数类型自动推断

3、代码简洁

应用场景

任何有函数式接口的地方（只有一个抽象方法的接口叫做函数式接口）

 

jdk里面提供了几个函数式接口：

在 java.util.function 包下面

Supplier 代表一个输出

Consumer 代表一个输入

BiConsumer 代表两个输入

Function 代表一个输入一个输出（一般输入和输出是不同类型的） ：

第一个参数必须是输入，第二个参数必须是输出

UnaryOperator 代表一个输入一个输出（输入和输出是相同类型的）

BiFunction 代表两个输入和一个输出（一般输入和输出是不同类型的）

BinaryOpetator 代表两个输入和一个输出（输入和输出是相同类型的）

 

表达式案例：

()->{}

()->{System.out.println();}

()->System.out.println()

()->{return 1;}

()->100

()->null

(int x)->{return x+1;}

(int x)->x+1

(x)->x+1

x->x+1

 

前面都有一个()，括号里面传的是表达式接口中的方法中的参数，可以写类型，也可以不写类型，会自动判断

->：函数式表达式的格式

{}：方法体，如果只有一行代码，可以省略

 

方法引用的分类：

1、静态方法引用 类名::staticMethod

如果函数式接口的实现恰好可以通过静态方法来实现，那么就可以使用静态方法引用

2、实例方法引用 inst::instMethod

如果函数式接口的实现恰好可以通过通用一个实例的实例方法来引用，就可以使用实例方法引用

3、对象方法引用 类名::instMethod

抽象方法的第一个参数类型刚好是实例方法的类型，抽象方法的剩余的参数恰好可以当做实例方法的参数，如果函数式接口的实现能使用上面说的实例方法来调用，就可以使用对象方法引用

4、构造方法引用 类名::new

如果函数式接口恰好可以通过调用一个方法的构造方法来实现，就可以使用构造方法引用

 

下面每个接口都有使用案例

public class LambdaDemo {
    public static void main(String[] args) {
        Function<String,Integer> fun = (str)->{
            return str.length();
        };
        System.out.println(fun.apply("abc"));
        //Supplier  lambda表达式
        Supplier<String> s1 = new Supplier<String>() {
            @Override
            public String get() {
                return "null";
            }
        };
        Supplier<String> s2 = ()->{return "abc";};
        System.out.println(s1.get());
        System.out.println(s2.get());

        Consumer<String> c1 = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        c1.accept("c1");

        Consumer<String> c2 = (str)->System.out.println(str);;
        c2.accept("c3");

        //两个输入
        BiConsumer<String,String> bi = (str1,str2)->{
            System.out.println(str1);
            System.out.println(str2);
        };
        bi.accept("b1","b2");
        //两个输入，内容可以不一样
        BiConsumer<String,Integer> bi2 = (str1,int2)->{
            System.out.println(str1+int2);
        };
        bi2.accept("aaa",12);

        //输入un1  输出 un2
        UnaryOperator<String> un1 = (str)->"un1";
        System.out.println(un1.apply("un2"));

        UnaryOperator<String> un2 = (str)-> {
            return "un2";
        };
        System.out.println(un2.apply("un2"));

        //输入a和b 输出2 两个输入一个输出，类型可以不一样
        BiFunction<String,String,String> bf1 = (str1,str2)->{return str1+str2.length();};
        System.out.println(bf1.apply("a","b"));

        //两个输入一个输出
        BinaryOperator<String> stu = new BinaryOperator<String>() {
            @Override
            public String apply(String s, String s2) {
                return s+s2;
            }
        };
        System.out.println(stu.apply("ab", "cd"));

        //两个输入，一个输出，相同类型
        BinaryOperator<Integer> bui1 = (i,j)->i+j;
        Integer i = bui1.apply(12,13);
        System.out.println(i);
    }
}

public class ConsDemo {
    public static void main(String[] args) {
        Supplier s1 = Cons::new;
        s1.get();
        Consumer<Integer> c1 = Cons::new;
        c1.accept(123456);
        Consumer<String> c2 = Cons::new;
        c2.accept("asss");
    }
}

public class InstenceDemo {
    public static void main(String[] args) {
        new InstenceDemo().get();

        InstenceDemo inst = new InstenceDemo();
        Supplier<String> sp1 = ()->{return new InstenceDemo().put();};
        Supplier<String> sp2 = ()->new InstenceDemo().put();
        Supplier<String> sp3 = new InstenceDemo()::put;
        Supplier<String> sp4 = inst::put;
        System.out.println(sp1.get());
        System.out.println(sp2.get());
        System.out.println(sp3.get());
        System.out.println(sp4);
    }

    public InstenceDemo(){

    }

    public String put(){
        return "put test";
    }

    public void get(){
        System.out.println(put());
    }
}