list.parallelStream()操作线程不安全的数据集合时存在线程不安全的问题。

解决list.parallelStream()并行流线程安全的方式：

List<Integer> list4 = list1.parallelStream().collect(Collectors.toList());

或者直接使用线程安全的集合来保证线程安全 collect()/reduce()等线程安全的终断操作来保证线程安全问题

结论：

Stream并行安全的问题，在业务处理的过程中，主要通过自定义编码添加线程锁的方式，或者使用Stream api中提供的线程安全的终端操作来完成执行过程，但是在更多的场景中，如果我们遇到多线程问题会直接使用线程安全的集合来规范数据源。

jvm在内部生成一个静态方法，也生成了一个匿名内部类且实现了Lambda的目标类型接口，然后调用了一下生成的静态方法。

总结：

1. lambda表达式中变量操作优化了匿名内部类型中this关键字；

2. 不在单独建立对象作用域，表达式本身就是所属类型对象的一部分，在语法语义上使用更加简洁。
   

JDK8中为什么要提供lambda表达式这种新技术的语法糖呢？

因为在项目开发中，我们经常会有代码质量控制这样的要求，让编写的代码更加趋于数据的有效处理，也就是编码即数据的开发模式，也就是Model Code as Data。

Model Code as Data尽可能轻量级的将代码封装为数据。这种操作模式在传统的编码中通过接口以及实现类的方式（或者匿名内部类的方式）完成功能的处理，但传统的这种模式下存在大量的问题。

- 语法冗余：在传统的编码中和数据处理无关的代码较多；

- this关键字：在匿名内部类处理方式中，this关键字在内部类型中，它的变量绑定以及变量访问存在很大的误区；

- 变量捕获：匿名内部类型中对于当前在内部类型的处理会有特殊的要求；

- 数据控制：并不是特别的友好。

函数式接口和Lambda表达式的关系

stream 操作集合数据下

stream操作集合获取stream方法

stream常用api

1

方法重载对lambda表达式的影响。也可以使用lambad


/**
 * 方法重载对lambda表达式的影响
 */
public class App4 {
    interface Param1 {
        void outInfo(String info);
    }

    interface Param2 {
        void outInfo(String info);
    }


    interface Param3 {
        void outInfo(String info, int index);
    }

    interface Param4 {
        void outInfo(String info, int index);
    }


    public void lambdaMethod_1(Param1 param) {
        param.outInfo("hello param1 imooc");
    }

    public void lambdaMethod_1(Param2 param) {
        param.outInfo("hello param1 imooc");
    }

    public void lambdaMethod_2(Param1 param, int index) {
        param.outInfo("hello param1 imooc---" + index);
    }

    public void lambdaMethod_2(Param2 param, int index) {
        param.outInfo("hello param1 imooc---" + index);
    }


    public void lambdaMethod_3(Param3 param, int index) {
        param.outInfo("hello Param3 imooc", index);
    }

    public void lambdaMethod_3(Param4 param, int index) {
        param.outInfo("hello param4 imooc", index);
    }

    public static void main(String[] args) {
        App4 app = new App4();

        app.lambdaMethod_1(new Param1() {
            @Override
            public void outInfo(String info) {
                System.out.println(info);
            }
        });
        app.lambdaMethod_1(new Param2() {
            @Override
            public void outInfo(String info) {
                System.out.println(info);
            }
        });
        app.lambdaMethod_2(new Param1() {
            @Override
            public void outInfo(String info) {
                System.out.println(info);
            }

        }, 1);

        app.lambdaMethod_2(new Param2() {
            @Override
            public void outInfo(String info) {
                System.out.println(info);
            }
        }, 2);
        app.lambdaMethod_3(new Param3() {
            @Override
            public void outInfo(String info, int index) {
                System.out.println(info + "#############" + index);
            }
        }, 3);

        app.lambdaMethod_3(new Param4() {
            @Override
            public void outInfo(String info, int index) {
                System.out.println(info + "#############" + index);
            }
        }, 4);

        System.out.println("--------------------------------------------------------------------------");

        app.lambdaMethod_1((Param1) info -> {
            System.out.println(info);
        });
        app.lambdaMethod_1((Param2) info -> {
            System.out.println(info);
        });


        app.lambdaMethod_2((Param1) info -> {
            System.out.println(info);
        }, 3);

        app.lambdaMethod_2((Param2) info -> {
            System.out.println(info);
        }, 4);

        app.lambdaMethod_3((Param3) (info, index) -> {
            System.out.println(info + "#############" + index);
        },5);

        app.lambdaMethod_3((Param4) (info, index) -> {
            System.out.println(info + "#############" + index);
        },5);

    }
}

无参数

jdk原生里面原来就有这么多很棒的封装，很厉害。

/**
* java.util.function 包提供了大量函数式接口
*
* 1. Predicate     接收参数T对象，返回boolean类型的结果
* 2. Consumer      接收参数T对象，没有返回值
* 3. Function      接收参数T对象，返回R对象
* 4. Supplier      不接收任何参数，直接通过get()获取指定值
* 5. UnaryOperator 接口参数T对象，执行业务处理后，返回更新后的T对象
* 6. BinaryOperator 接口接收两个T对象，执行业务处理后，返回T对象
*/

2

1

1

1