Lambda表达式

- > () ：标识符

1：取代了某些匿名内部类的书写，使得更为简化,省略了接口名和方法名

public class MyTest {
    public static void main(String[] args) {
        //传统方式
        Thread thread=new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(\"传统方式：test!!!\");
                System.out.println(\"\");
            }
        });
        //Lambda方式
        Thread thread1=new Thread(
                () -> {
                    System.out.println(\"Lambda方式：test!!!\");
                    System.out.println(\"\");
                }
                );
        thread.start();
        thread1.start();
    }

运行结果完全一样

2：带参数的匿名内部类，情形，如果要给一个字符串列表进行自定义比较器按字符串长度进行排序，不仅省略了接口名和方法名，还省略了接口的参数类型（javac的类推断机制）

  //传统写法
        List<String> list= Arrays.asList(\"1\",\"22\",\"333\",\"4444\");
        Collections.sort(list, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                if (o1==null){
                    return -1;
                }
                if (o2==null){
                    return -1;
                }
                return o2.length()-o1.length();
            }
        });
        //Lambda方式
        List<String> list1=Arrays.asList(\"1\",\"22\",\"333\",\"4444\");
        Collections.sort(list1,(o1,o2) ->
                {
                    if (o1 == null) {
                        return -1;
                    }
                    if(o2==null){
                        return -1;
                    }
                    return o2.length()-o1.length();
                }
        );
        System.out.println(list);
        System.out.println(list1);
    }

函数接口：指内部自有一个抽象方法的接口，java强类型语言，Lambda表达式是依据类型推断机制，在上线文信息足够的情况下，编译器推断出你的参数类型，而不用显示指明

3：自定义函数接口，@FunctionalInterface注解可选，但是加上编译器会检查接口是否符合函数接口的规范

@FunctionalInterface
public interface ConsumerInterface<T>{
    void accept(T t);
}

调用：

     /**
     * 自定义函数接口
     */
    ConsumerInterface<String> consumerInterface=s -> System.out.println(s);

进一步改写第三步

public class MyStream<T> {
    private List<T> list= Arrays.asList((T) \"a\", (T) \"b\");
    public void myForEach(ConsumerInterface<T> consumerInterface){
        for (T t:list){
            consumerInterface.accept(t);
        }
    }

调用：

         /**
         * 进一步改写
         */
        MyStream myStream=new MyStream();
        myStream.myForEach(str -> System.out.println(\"进一步改写\"+str));
    }