=============================================================================
=============================================================================
涉及到的知识点有：
    0：JDK5 & JDK7 新特性
    1：Java 8 新特性
    2：Java 9 新特性
    3：Java 10 新特性
=============================================================================
=============================================================================
0：JDK5 & JDK7 新特性
    (1) JDK5新特性
        自动装箱和拆箱(day13)
        泛型(day16)
        增强for循环(day16)
        静态导入(day16)
        可变参数(day16)
        枚举(day27)
--------------------------------------        
    (2) JDK7新特性
        二进制字面量(二进制的表现形式)
        数字字面量可以出现下划线(用_分隔数据)
        switch语句的表达式可是用字符串(day04)
        泛型简化(泛型推断(也叫菱形泛型))
        异常的多个catch合并(多catch的使用)(day19)
        try-with-resources 语句(自动释放资源的用法)
-----------------------------------------------------------------------------
1：Java 8 新特性
    (1) 接口中有方法了（可以有默认方法、静态方法、私有方法(JDK9)）。
-----------------------------------------------------------------------------
    (2) Lambda表达式
        A: 接口的实现类的目的是：为了给接口中的方法找方法体。即为了使用方法体，不得不去定义一个实现类。
            你以为这是理所当然的，其实不是。
            
            对于某些场景，我能不能有一种更加先进，更加清亮的方法呢? 
            答：有，函数式编程。(Lambda表达式编程)
--------------------------------------        
        B: 从Java 8 开始，没有实现类的接口，也可以直接使用接口了。如何使用? 
            答：Lambda表达式。
            其实就像Lambda表达式替代了实现类一样。
--------------------------------------        
        C: Java语言中使用Lambda表达式的前提是：必须有"函数式接口"。
    
            函数式接口：有且仅有一个抽象方法的接口，叫做函数式接口。

            如何才能万无一失地检测一下当前接口是不是函数式接口呢?
            用一个固定的格式写在public interface的前一行即可。
            
            格式：
                @FunctionalInterface 
                public interface 函数式接口名 {
                ...
                }
                
                @FunctionalInterface 
                注解：在java.lang包中
                
            注意：
                不管写不写@FunctionalInterface，只要有且仅有一个抽象方法的接口就是函数式接口！
                但是呢？建议永远写上。
--------------------------------------                
        D: Lambda表达式要想使用，一定要有函数式接口的推断环境。
            推断环境?
                方式1. 要么通过方法的参数类型，来确定是哪个函数式接口。
                方式2. 要么通过赋值操作，赋值语句左侧的数据类型，来确定是哪个函数式接口。
                    
                    // 通过方法的参数类型，来确定是哪个函数式接口。
                    // 在调用方法的时候，方法的参数类型是函数式接口，所以Lambda可以推断出来是哪个接口。
                    method((int a, int b) -> {
                        return a + b;
                    });
                    
                    // 通过赋值操作，赋值语句左侧的数据类型，来确定是哪个函数式接口。(赋值语句左侧的类型来进行Lambda上下文推断)
                    Calculator cal = (int a, int b) -> {
                        return a + b;
                    };
                    method(cal);
                    
                    // 错误写法！没有上下文环境，Lambda就无法推断是哪个函数式接口。
                    /*
                    (int a, int b) -> {
                        return a + b;
                    };
                    */
        
            Lambda的格式就是为了将抽象方法，翻译成以下三点：
                1. 一些参数(方法参数)
                2. 一个箭头
                3. 一些代码(方法体)
            例如这个抽象方法：
                public abstract int sum(int a, int b);
                翻译成为Lambda的标准格式：
                (int a, int b) -> { 
                    return a + b; 
                } 
--------------------------------------                
        E: Lambda的简便格式
            在Lambda表达式当中，凡是可以推断的，都是可以省略的。
                1. Lambda表达式当中的参数类型可以省略不写。
                2. 如果参数有且仅有一个，那么可以省略小括号。
                3. 如果语句只有一条，那么大括号、分号和return也可以省略。
                
                // Lambda表达式的标准格式
                method((int x) -> {
                    return ++x;
                });

                // 简化格式1：省略参数类型：Lambda表达式当中的参数类型可以省略不写。
                method((x) -> {
                    return ++x;
                });

                // 简化格式2：再省略小括号：如果参数有且仅有一个，那么可以省略小括号。
                method(x -> {
                    return ++x;
                });

                // 简化格式3：再省略大括号和return：如果语句只有一条，那么大括号、分号和return也可以省略。
                method(x -> ++x);                            
-----------------------------------------------------------------------------                
    (3) 方法引用
        Lambda表达式的冗余场景：
            在某些场景下，Lambda表达式要做的事情，在另一个地方已经写过了(即已有方法体了，已经实现了)。
            那么此时如果通过Lambda表达式重复编写相同的代码，就是浪费。
    
        那么此时如何才能复用已经存在的方法逻辑呢？
            JDK8中新特性：方法引用（为了简化Lambda而存在）
            即：如果Lambda表达式需要做的事情，在另一个类当中已经做过了，那么就可以直接拿过来替换Lambda。这种方式叫做方法引用。
        
        方法引用的格式：
            1.通过类名引用静态方法，格式：类名::静态方法名    
        方法引用的格式：
            2.通过对象名引用静态方法，格式：对象名::成员方法名    
        还有其他的格式：
            ...
        小结：
            1. 一定要先有函数式接口，才能使用Lambda表达式。
            2. 对于Lambda表达式使用的冗余场景，可以使用方法引用来进行简化。
-----------------------------------------------------------------------------
    (4) Stream API 流式操作
        集合for遍历的冗余场景：
--------------------------------------        
        Stream流式思想概述：
            像流水线操作一般执行。从其他语言中借鉴过来的。可以很方便的操作多个元素。
            即简化了普通的集合操作。
--------------------------------------            
        获取Stream流对象的常用方式：
            Java 8当中的“流”其实就是Stream接口的对象。
            JDK提供了一个流接口：java.util.stream.Stream<T>
        如何获取Stream流对象？
            1. 根据集合获取流对象
                集合名称.stream();
            2. 根据数组获取流对象，数组当中的元素必须是引用类型才行
                Stream.of(数组名称);
--------------------------------------                
        获取Stream流对象后如何使用map方法呢？
            我们获取流对象后，可以使用映射方法：map(用于转换的Lambda表达式)
            映射：就是将一个对象转换成另一个对象，把老对象映射到新对象上。
            举例："赵丽颖,98"    转换成为    "98"    把一个长字符串转换为一个短字符串
                    "98"        转换成为    98        把一个字符串转化成为一个int数字    
--------------------------------------        
        如果希望对流对象当中的元素进行过滤，可以使用过滤方法：filter(能产生boolean结果的lambda表达式)
            如果参数Lambda产生了true，则要该元素；如果产生了false，则不要该元素。    
--------------------------------------
        如果希望在流当中进行元素的遍历操作，可以使用forEach方法：forEach(Lambda表达式)
            意思是：对流当中的每一个元素都要进行操作。
            注意：参数Lambda表达式必须是一个能够消费一个参数，而且不产生数据结果(无返回值)的Lambda表达式。
            例如：
                Lambda：        s -> System.out.println(s);
                方法引用：        System::println            
--------------------------------------        
        流当中的元素如果特别多，那么只有一个人在逐一、挨个处理，肯定比较慢、费劲。
        如果对流当中的元素，使用多个人同时处理，这就是“并行”。
            parallel    并行，平行
        Java 8中将并行进行了优化，我们可以很容易的对数据进行并行操作。
        Stream API可以声明性地通过parallel()与sequential()在并行流与顺序流之间进行切换。            
        
        如何获取“并行流”？
            .parallelStream()        // 直接获取
            .stream.parallel()       // 间接获取

        注意事项：
            1. 使用并行流操作的时候，到底有几个人进行同时操作呢？我们不用管，JDK自己处理。（用的是Fork/Join框架）
            2. 只要正确使用的话，就不会出现多个人抢到同一个元素的情况。    
-----------------------------------------------------------------------------            
2：Java 9 新特性                
    (1) 模块化思想概述
        1. 把整体分成部分(模块)。文件体积变小。
        2. 在模块中增加权限控制。权限控制更精确。
            如下图所示：

(2) 认识module-info.java文件
            如下图所示：
(3) 将Eclipse项目改造为模块
        选择项目右键 --> Configure --> Create module-info.java --> xxx.mod(模块命名不推荐使用数字)
        再配置好module-info.java文件中的exports和requires。
    (4) 设置模块间的依赖关系
        1. 在module-info.java文件中先加入requires语句(最底层包名)。
        2. 选中项目右击 --> Build Path --> Configure Build Path... --> Projects --> Modulepath --> Add... --> 选中所依赖的项目（该步骤是Ecplise所特有的）
-----------------------------------------------------------------------------                
3：Java 10 新特性
    Java 10 新特新链接：https://juejin.im/entry/5ab1c64951882555880545f2
=============================================================================