Java8笔记第一篇（Lambda与Stream API初识）

作为一位大名鼎鼎的程序员，手边也必不可少的一样开发工具就是API文档了，这儿提供一个官方最具权威的API文档，如下：
https://docs.oracle.com/javase/8/docs/api/
当然，英语不好怎么办，这儿有在线的也有离线的API中文文档，如下：
https://blog.csdn.net/Hello_World_QWP/article/details/80242530
我大概的看了一下，里面的语句病句实在是太多，真的是不忍心看下去了，但是离语句的实际意义还是不会太远，懂得（有一句成都话叫：连猜带估）！！！

前端时间，在朋友圈里面闹得沸沸扬扬的，说Java8停止维护了，Java9被抛弃了，Java10才是最具实力的，其实我想说的是然并卵，我到官网去查了一下，Java10要在2020年才正式投入使用，也就是Java8至少也要活跃到2020年，
也就是说在这期间，任然用Java8的公司会很多，包括现在我们新项目的建设都是使用的是Java8，而且现在的Java8也是那么的美丽、漂亮、性感，足以让人陶醉在其中，不是吗？不信来试试！！！

Java8与以前的版本相比有以下几大特点：
速度更快
代码更少（增加了新的语法 Lambda 表达式）
强大的 Stream API
便于并行
最大化减少空指针异常 Optional

其中最为核心的为 Lambda 表达式与Stream API！！！

那么我们为什么要使用 Lambda 表达式：其实很简单，Lambda 是一个匿名函数，我们可以把 Lambda表达式理解为是一段可以传递的代码（将代码像数据一样进行传递）。可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升。

本笔记主要围绕Java8的几个新特性进行实操的笔记，总共分为13篇，每一篇都对应着Java8的一个新特性，在实操的过程中再配上注解，更便于理解。主要内容如下：
第一篇：初探 java8 第 01 篇（ Lambda与Stream API初识 ）
第二篇：深入 java8 第 02 篇（ Lambda表达式基础语法 ）
第三篇：深入 java8 第 03 篇（ 函数式接口，常见的4个函数式接口 ）
第四篇：深入 java8 第 04 篇（ 方法引用与构造器引用 ）
第五篇：深入 java8 第 05 篇（ Stream API 的操作->创建及中间操作 ）
第六篇：深入 java8 第 06 篇（ Stream API 的操作->终止操作 ）
第七篇：深入 java8 第 07 篇（ Stream API 的操作->规约、收集 ）
第八篇：深入 java8 第 08 篇（ Stream API 的综合练习 ）
第九篇：深入 java8 第 09 篇（ Fork/Join 框架的使用及其优势 ）
第十篇：深入 java8 第 10 篇（ 时间新特新 -> DateTimeFormatter 解析与格式化 ）
第十一篇：深入 java8 第 11 篇（ 带时区的时间或日期）
第十二篇：深入 java8 第 12 篇（接口中的默认方法与静态方法 ）
第十三篇：深入 java8 第 13 篇（ 其他新特性 -> Optional 类/重复注解与类型注解 ）

Lambda与Stream API初识

1.1 第一阶段：测试 使用 匿名内部类的写法和 lambda 表达式进行比较， lambda（函数糖） 的写法更为简洁。

    @SuppressWarnings("unused")
    @Test
    public void test01() {
        // 1.1 匿名内部类的写法一
        Comparator<String> comparator = new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {

                return Integer.compare(o1.length(), o2.length());
            }
        };

        TreeSet<String> treeSet = new TreeSet<>(comparator);

        // 1.2 匿名内部类写法二
        TreeSet<String> treeSet2 = new TreeSet<>(new Comparator<String>() {

            @Override
            public int compare(String o1, String o2) {
                return Integer.compare(o1.length(), o2.length());
            }
        });
    }

当使用 Lambda 表达式后，更加简化

    @SuppressWarnings("unused")
    @Test
    public void test02() {
        Comparator<String> comparator = (x, y) -> Integer.compare(x.length(), y.length());
        TreeSet<String> treeSet = new TreeSet<>(comparator);
    }

在实际生产环境中的使用例子
1.1 准备测试的数据

    List<Employee> emps = Arrays.asList(
            new Employee(001, "Emma", 41, 20000, Status.FREE),
            new Employee(002, "Mary", 39, 18000, Status.BUSY),
            new Employee(003, "Allen", 33, 15000, Status.BUSY),
            new Employee(004, "Olivia", 52, 32000, Status.FREE),
            new Employee(005, "Natasha", 27, 13000, Status.BUSY),
            new Employee(006, "Kevin", 25, 10000, Status.FREE)
    );

1.2 需求一：获取公司员工中年龄小于等于 40 岁的员工信息
1.2.1普通写法：

    public List<Employee> screenEmployeeByAge(List<Employee> emps){
        List<Employee> list = new ArrayList<>();

        for (Employee employee : emps) {
            if(employee.getAge() <= 40){
                list.add(employee);
            }
        }
        return list;
    }

    @Test
    public void test03(){
        List<Employee> result = screenEmployeeByAge(emps);
        System.out.println("公司中小于等于40岁的员工有：");
        for (Employee employee : result) {
            System.out.println(employee.getName()+"ttt"+employee.getAge());
        }
    }

1.2.2 优化方式一：使用设计模式中的策略模式

    public List<Employee> strategyEmployeeByAge(List<Employee> emps,Predicate<Employee> P){
        List<Employee> list = new ArrayList<>();

        for (Employee employee : emps) {
            if(P.compare(employee)){
                list.add(employee);
            }
        }
        return list;
    }

    @Test
    public void test04(){
        List<Employee> result = strategyEmployeeByAge(emps, new StrategyEmployeeByAge());
        System.out.println("公司中小于等于40岁的员工有：");
        for (Employee employee : result) {
            System.out.println(employee.getName()+"ttt"+employee.getAge());
        }
    }

1.2.3 优化方式二：使用匿名内部类的方式

    @Test
    public void test05(){
        List<Employee> list = strategyEmployeeByAge(emps, new StrategyEmployeeByAge(){
            @Override
            public boolean compare(Employee t) {

                return t.getAge() <= 40;
            }

        });

        System.out.println("公司中小于等于40岁的员工有：");
        for (Employee employee : list) {
            System.out.println(employee.getName()+"ttt"+employee.getAge());
        }
    }

1.2.4 优化方式三：使用 Lambda 表达式

    @Test
    public void test06(){
        List<Employee> list = strategyEmployeeByAge(emps, (e)->e.getAge()<=40);
        System.out.println("公司中小于等于40岁的员工有：");
        for (Employee employee : list) {
            System.out.println(employee.getName()+"ttt"+employee.getAge());
        }
    }

1.2.5 优化方式四：使用 Stream API

    @Test
    public void test07(){
        System.out.println("公司中小于等于40岁的员工有：");
        emps.stream()
            .filter((e)->e.getAge()<=40)
            .forEach(System.out::println);
    }

源码下载地址：https://download.csdn.net/download/hello_world_qwp/10401249