day07------------------------------------------------------------
        等待唤醒
                线程通信
                        多个线程处理同一个资源，但处理的动作不同
                等待唤醒机制
                        避免多个线程争抢同一个资源
                        wait
                        notify
                        需要用同一个锁对象进行方法调用

        线程池【面试】
                一个容纳多个线程的容器，其中的线程可以反复使用
                JDK1.5之后内置了线程池
               
        堆内存
                年轻代 1
                        eden
                        幸存者
                年老代 2
                        【线程池就在这里】
       
        Lambda表达式(jdk1.8)(用于简化匿名内部类)
                函数式编程思想  -->  只要结果，过程不重要
                lambda表达式的格式
                        1、一些参数
                        2、一个箭头
                        3、一段代码
                        (参数列表) -> {一些【重写方法】的代码};
                ():接口中抽象方法的参数列表，没有参数，为空；有参就写出参数，多个参数分隔使用逗号
                ->:传递
                {}:重写接口的抽象方法体
               
                lambda表达式：是可推导，可以省略
                凡是根据上下文推导出来的内容，都可以省略书写
                可以省略的内容：
                        1.(参数列表)：括号中参数列表的数据类型，可以省略不写
                        2.(参数列表)：括号中的参数如果只有一个，name类型和()都可以省略
                        3.{一些代码}：如果{}中的代码只有一行，无论是否有返回值，都可以省略{}、return、分号
                                注意，要省略只能一起省略
                               
                lambda表达式的使用前提：
                        1. 使用Lambda必须具有接口，且要求接口中有且仅有一个抽象方法。无论是JDK内置的Runnable 、 Comparator 接口还是自定义的接口，只有当接口中的抽象方法存在且唯一时，才可以使用Lambda。
                        2. 使用Lambda必须具有上下文推断。也就是方法的参数或局部变量类型必须为Lambda对应的接口类型，
                           才能使用Lambda作为该接口的实例。
                       
                        备注：有且仅有一个抽象方法的接口，称为“函数式接口”。

                --------------
                聚合
                        Steam：是一系列的元素
                        管道：指的是一系列的聚合操作
                                管道又分三个部分：
                                        管道源：在这个例子里，源是一个List
                                        中间操作
                                                每个中间操作，又会返回一个Stream，比如.filter()又返回一个Stream, 中间操作是“懒”操作，并不会真正进行遍历。
                                                        中间操作比较多，主要分两类
                                                        对元素进行筛选 和 转换为其他形式的流
                                                        对元素进行筛选：
                                                                filter 匹配
                                                                distinct 去除重复(根据equals判断)
                                                                sorted 自然排序
                                                                sorted(Comparator<T>) 指定排序
                                                                limit 保留
                                                                skip 忽略
                                                        转换为其他形式的流
                                                                mapToDouble 转换为double的流
                                                                map 转换为任意类型的流
                                        结束操作
                                                当这个操作执行后，流就被使用“光”了，无法再被操作。所以这必定是流的最后一个操作。
                                                结束操作不会返回Stream，但是会返回int、float、String、 Collection，
                                                或者像forEach，什么都不返回，结束操作才进行真正的遍历行为，在遍历的时候，才会去进行中间操作的相关判断。
                                                        常见结束操作如下：
                                                                forEach() 遍历每个元素
                                                                toArray() 转换为数组
                                                                min(Comparator<T>) 取最小的元素
                                                                max(Comparator<T>) 取最大的元素
                                                                count() 总数
                                                                findFirst() 第一个元素
                        注： 这个Stream和I/O章节的InputStream,OutputStream是不一样的概念。
                --------------
               

day07------------------------------------------------------------
        等待唤醒
                线程通信
                        多个线程处理同一个资源，但处理的动作不同
                等待唤醒机制
                        避免多个线程争抢同一个资源
                        wait
                        notify
                        需要用同一个锁对象进行方法调用

        线程池【面试】
                一个容纳多个线程的容器，其中的线程可以反复使用
                JDK1.5之后内置了线程池
               
        堆内存
                年轻代 1
                        eden
                        幸存者
                年老代 2
                        【线程池就在这里】
       
        Lambda表达式(jdk1.8)(用于简化匿名内部类)
                函数式编程思想  -->  只要结果，过程不重要
                lambda表达式的格式
                        1、一些参数
                        2、一个箭头
                        3、一段代码
                        (参数列表) -> {一些【重写方法】的代码};
                ():接口中抽象方法的参数列表，没有参数，为空；有参就写出参数，多个参数分隔使用逗号
                ->:传递
                {}:重写接口的抽象方法体
               
                lambda表达式：是可推导，可以省略
                凡是根据上下文推导出来的内容，都可以省略书写
                可以省略的内容：
                        1.(参数列表)：括号中参数列表的数据类型，可以省略不写
                        2.(参数列表)：括号中的参数如果只有一个，name类型和()都可以省略
                        3.{一些代码}：如果{}中的代码只有一行，无论是否有返回值，都可以省略{}、return、分号
                                注意，要省略只能一起省略
                               
                lambda表达式的使用前提：
                        1. 使用Lambda必须具有接口，且要求接口中有且仅有一个抽象方法。无论是JDK内置的Runnable 、 Comparator 接口还是自定义的接口，只有当接口中的抽象方法存在且唯一时，才可以使用Lambda。
                        2. 使用Lambda必须具有上下文推断。也就是方法的参数或局部变量类型必须为Lambda对应的接口类型，
                           才能使用Lambda作为该接口的实例。
                       
                        备注：有且仅有一个抽象方法的接口，称为“函数式接口”。

                --------------
                聚合
                        Steam：是一系列的元素
                        管道：指的是一系列的聚合操作
                                管道又分三个部分：
                                        管道源：在这个例子里，源是一个List
                                        中间操作
                                                每个中间操作，又会返回一个Stream，比如.filter()又返回一个Stream, 中间操作是“懒”操作，并不会真正进行遍历。
                                                        中间操作比较多，主要分两类
                                                        对元素进行筛选 和 转换为其他形式的流
                                                        对元素进行筛选：
                                                                filter 匹配
                                                                distinct 去除重复(根据equals判断)
                                                                sorted 自然排序
                                                                sorted(Comparator<T>) 指定排序
                                                                limit 保留
                                                                skip 忽略
                                                        转换为其他形式的流
                                                                mapToDouble 转换为double的流
                                                                map 转换为任意类型的流
                                        结束操作
                                                当这个操作执行后，流就被使用“光”了，无法再被操作。所以这必定是流的最后一个操作。
                                                结束操作不会返回Stream，但是会返回int、float、String、 Collection，
                                                或者像forEach，什么都不返回，结束操作才进行真正的遍历行为，在遍历的时候，才会去进行中间操作的相关判断。
                                                        常见结束操作如下：
                                                                forEach() 遍历每个元素
                                                                toArray() 转换为数组
                                                                min(Comparator<T>) 取最小的元素
                                                                max(Comparator<T>) 取最大的元素
                                                                count() 总数
                                                                findFirst() 第一个元素
                        注： 这个Stream和I/O章节的InputStream,OutputStream是不一样的概念。
                --------------