Java8新特性——lambda表达式、函数式接口、方法引用、Stream API与Optional类

1.举例： (o1,o2) -> Integer.compare(o1,o2);
2.格式：-> :lambda操作符或箭头操作符。
              ->左边：lambda形参列表，其实就是接口中的抽象方法的形参列表。
              ->右边：lambda体，其实就是重写的抽象方法的方法体。
3.lambda表达式的使用：6种情况
总结：->左边：lambda形参列表的参数类型可以省略(类型推断)；
           如果lambda形参列表只有一个，那么()可以省略；
           ->右边：lambda体应该使用一对{}包裹；
           如果lambda只有一条执行语句(可能是return语句)，省略return和{}。
4.lambda表达式的本质：作为函数式接口的实例(对象)。
5.如果一个接口中，只声明了一个抽象方法，则此接口就称为函数式接口。可以在接口上使用@FunctionalInterface注解，这样做可以检查它是否是一个函数式接口。
6.所以以前用匿名实现类表示的现在都可以用lambda表达式来写。

(二)lambda示例

@Test
    public void test1() {
        Runnable r1 = new Runnable() {
            @Override
            public void run() {
                System.out.println("hello");
            }
        };
        r1.run();

        System.out.println("----------------------------");
        Runnable r2 = () -> System.out.println("hello_lambda");
        r2.run();
    }

@Test
    public void test2() {
        Comparator<Integer> com1 = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return Integer.compare(o1, o2);
            }
        };
        int compare1 = com1.compare(12, 21);
        System.out.println(compare1);// -1  前面的数小

        System.out.println("----------------------------");
        // lambda表达式
        Comparator<Integer> com2 = (o1, o2) -> Integer.compare(o1, o2);
        int compare2 = com2.compare(12, 21);
        System.out.println(compare2);// -1  前面的数小

        System.out.println("----------------------------");
        // 方法引用
        Comparator<Integer> com3 = Integer::compare;
        int compare3 = com3.compare(12, 21);
        System.out.println(compare3);// -1  前面的数小
    }

(三)lambda用法

1.语法格式一：无参，无返回值

@Test
    public void test1() {
        // 匿名实现类
        Runnable r1 = new Runnable() {
            @Override
            public void run() {
                System.out.println("hello");
            }
        };
        r1.run();

        System.out.println("-------------lambda写法一：---------------");
        // 因为没有参数，所以()内是空的   右边是方法体
        Runnable r2 = () -> {
            System.out.println("hello_lambda");
        };
        r2.run();
    }

2.语法格式二：有参数，无返回值

@Test
    public void test2() {
        Consumer<String> con = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        con.accept("hello");
        System.out.println("-------------lambda写法二：---------------");
        Consumer<String> con1 = (String s) -> {
            System.out.println(s);
        };
        con1.accept("world");
    }

3.数据类型可以省略，因为可由编译器推断得出，称为”类型推断“

@Test
    public void test3() {
        Consumer<String> con1 = (String s) -> {
            System.out.println(s);
        };
        con1.accept("world");

        System.out.println("-------------lambda写法三：---------------");
        Consumer<String> con2 = (s) -> {
            System.out.println(s);
        };
        con2.accept("world3");

        // 类型推断
        ArrayList<String> list = new ArrayList<>();
        int[] arr = {1, 2, 3};
    }

4.语法格式四：lambda若只需要一个参数时，参数的小括号可以省略

@Test
    public void test4() {
        Consumer<String> con2 = (s) -> {
            System.out.println(s);
        };
        con2.accept("world3");
        System.out.println("-------------lambda写法三：---------------");
        Consumer<String> con3 = s -> {
            System.out.println(s);
        };
        con3.accept("world3");
    }

5.语法格式五：lambda需要两个或两个以上的参数，多条执行语句，并且可以有返回值

@Test
    public void test5() {
        Comparator<Integer> com1 = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                System.out.println(o1);
                System.out.println(o2);
                return o1.compareTo(o2);
            }
        };
        com1.compare(2, 3);

        System.out.println("-------------lambda写法四：---------------");
        Comparator<Integer> com4 = (o1, o2) -> {
            System.out.println(o1);
            System.out.println(o2);
            return o1.compareTo(o2);
        };
        com4.compare(4, 3);
    }

6.语法格式六：当lambda体只有一条语句时，return与大括号可以省略

@Test
    public void test6() {
        Comparator<Integer> com4 = (o1, o2) -> {
            System.out.println(o1);
            System.out.println(o2);
            return o1.compareTo(o2);
        };
        com4.compare(4, 3);

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

        Comparator<Integer> com5 = (o1, o2) -> o1.compareTo(o2);

        com5.compare(4, 31);
    }

二、函数式接口

(一)函数式接口概述

(二)函数式接口用法示例

@Test
    public void test1() {
        System.out.println("------原始写法：代码比较冗余---------");
        test01(200, new Consumer<Double>() {
            @Override
            public void accept(Double aDouble) {
                System.out.println("学习" + aDouble);
            }
        });

        System.out.println("---------函数式接口，lambda写法--------------");
        test01(800, money -> System.out.println(money.compareTo(5003.2)));
        test01(200, money -> System.out.println("计算机" + money));
    }

    public void test01(double money, Consumer<Double> con) {
        con.accept(money);
    }

@Test
    public void test2() {
        // 调用filter方法
        List<String> list = Arrays.asList("111", "122", "33");
        List<String> filterStr = filter(list, new Predicate<String>() {// 有一个字符串类型的集合，集合中每个字符串经过判定，返回符合条件的
            @Override
            public boolean test(String s) {
                return s.contains("1");// 返回包含1的字符串
            }
        });
        System.out.println(filterStr);

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

        // 因为在方法中的参数列表中，有一个参数是函数式接口，所以可以使用lambda表达式
        // 只有一个参数，省略参数类型、小括号、大括号和return
        List<String> filterStr2 = filter(list, s -> s.contains("2"));
        System.out.println(filterStr2);
    }

 // 根据给定的规则，过滤集合中的字符串。此规则由Predicate的方法决定
    public List<String> filter(List<String> list, Predicate<String> pre) {
        ArrayList<String> filterList = new ArrayList<>();
        // 遍历传入的集合参数
        for (String s : list) {
            if (pre.test(s)) {
                filterList.add(s);
            }
        }
        return filterList;
    }

三、方法引用

(一)创建Employee对象

public class Employee {

	private int id;
	private String name;
	private int age;
	private double salary;

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public double getSalary() {
		return salary;
	}

	public void setSalary(double salary) {
		this.salary = salary;
	}

	public Employee() {

	}

	public Employee(int id) {

		this.id = id;
	}

	public Employee(int id, String name) {
		this.id = id;
		this.name = name;
	}

	public Employee(int id, String name, int age, double salary) {

		this.id = id;
		this.name = name;
		this.age = age;
		this.salary = salary;
	}

	@Override
	public String toString() {
		return "Employee{" + "id=" + id + ", name='" + name + '\'' + ", age=" + age + ", salary=" + salary + '}';
	}

	@Override
	public boolean equals(Object o) {
		if (this == o)
			return true;
		if (o == null || getClass() != o.getClass())
			return false;

		Employee employee = (Employee) o;

		if (id != employee.id)
			return false;
		if (age != employee.age)
			return false;
		if (Double.compare(employee.salary, salary) != 0)
			return false;
		return name != null ? name.equals(employee.name) : employee.name == null;
	}

	@Override
	public int hashCode() {
		int result;
		long temp;
		result = id;
		result = 31 * result + (name != null ? name.hashCode() : 0);
		result = 31 * result + age;
		temp = Double.doubleToLongBits(salary);
		result = 31 * result + (int) (temp ^ (temp >>> 32));
		return result;
	}
}

(二)传值

import java.util.ArrayList;
import java.util.List;
/**
 * 提供用于测试的数据
 */
public class EmployeeData {
	
	public static List<Employee> getEmployees(){
		List<Employee> list = new ArrayList<>();
		
		list.add(new Employee(1001, "马化腾", 34, 6000.38));
		list.add(new Employee(1002, "马云", 12, 9876.12));
		list.add(new Employee(1003, "刘强东", 33, 3000.82));
		list.add(new Employee(1004, "雷军", 26, 7657.37));
		list.add(new Employee(1005, "李彦宏", 65, 5555.32));
		list.add(new Employee(1006, "比尔盖茨", 42, 9500.43));
		list.add(new Employee(1007, "任正非", 26, 4333.32));
		list.add(new Employee(1008, "扎克伯格", 35, 2500.32));
		
		return list;
	}
}

(三)方法引用的使用

方法引用的使用：
* 1.使用情境：当要传递给lambda体的操作，已经有实现的方法了，可以使用方法引用！
* 2.方法引用，本质上就是lambda表达式，而lambda表达式作为函数式接口的实例，所以方法引用，也是函数式接口的实例。
* 3.使用格式：类(或对象) :: 方法名
* 4.具体分为如下的三种情况：
*   情况一：    对象 :: 非静态方法(实例方法)
*   情况二：    类 :: 静态方法
*   情况三：    类 :: 非静态方法

1.情况1：对象::实例方法

接口中的抽象方法的形参列表和返回值类型，与方法引用的方法的形参列表和返回值类型相同！

    // 情况一：对象 :: 实例方法
    //Consumer中的void accept(T t)
    //PrintStream中的void println(T t)

    @Test
    public void test1() {
        System.out.println("-------------原始写法-------------");
        Consumer<String> con1 = new Consumer<String>() {
            @Override
            public void accept(String o) {
                System.out.println(o);
            }
        };
        con1.accept("南京");

        System.out.println("----------lambda写法------------");
        Consumer<String> con2 = s -> System.out.println(s);
        con2.accept("北京");

        System.out.println("-------------方法引用------------");
        PrintStream ps = System.out;
        Consumer<String> con3 = ps::println;
        con3.accept("上海");

        Consumer<String> con4 = System.out::println;
        con4.accept("广州");
    }

    //Supplier中的T get()
    //Employee中的String getName()
    // get方法已经由getName方法实现了，参数列表一致
    @Test
    public void test2() {
        Employee emp = new Employee(1001, "Tom", 24, 8000);
        System.out.println("----------------原始写法--------------");
        Supplier<String> sup1 = new Supplier<String>() {
            @Override
            public String get() {
                return emp.getName();
            }
        };
        System.out.println(sup1.get());
        
        
        System.out.println("-----------lambda写法----------------");
        Supplier<String> sup2 = () -> emp.getName();
        System.out.println(sup2.get());

        
        System.out.println("-----------方法引用+lambda写法--------------");
        Supplier<String> sup3 = emp::getName;
        System.out.println(sup3.get());
    }

2.情况二：类 :: 静态方法

     //Comparator中的int compare(T t1,T t2)
    //Integer中的int compare(T t1,T t2)
    @Test
    public void test3() {
        System.out.println("----------原始写法-------------");
        Comparator<Integer> com1 = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1.compareTo(o2);
            }
        };
        System.out.println(com1.compare(45,78));


        System.out.println("----------lambda表达式--------------");
        Comparator<Integer> com2 = (o1,o2)->o1.compareTo(o2);
        System.out.println(com2.compare(12,74));
        

        System.out.println("---------方法引用------------");
        Comparator<Integer> com3 = Integer::compare;
        System.out.println(com3.compare(12, 78));
    }

    //Function中的R apply(T t)
    //Math中的Long round(Double d)
    @Test
    public void test4() {
        System.out.println("------------原始写法--------------");
        Function<Double, Long> fun1 = new Function<Double, Long>() {
            @Override
            public Long apply(Double d) {
                return Math.round(d);
            }
        };
        System.out.println(fun1.apply(12.3));

        System.out.println("------------lambda表达式-------------");
        Function<Double, Long> func1 = d -> Math.round(d);
        System.out.println(func1.apply(12.5));

        System.out.println("------------方法引用---------------");
        Function<Double, Long> func2 = Math::round;
        System.out.println(func2.apply(45.9));
    }

3.情况三：类 :: 实例方法

当有两个参数时，第一个参数时作为方法的调用者出现的，这种情况也可以使用方法引用，采用类调用方法。

    // Comparator中的int comapre(T t1,T t2)
    // String中的int t1.compareTo(t2)
    @Test
    public void test5() {
        System.out.println("---------原始写法-----------");
        Comparator<String> com1 = new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.compareTo(o2);
            }
        };
        System.out.println(com1.compare("abc", "xyz"));


        System.out.println("----------lambda表达式-----------");
        Comparator<String> com2 = (s1, s2) -> s1.compareTo(s2);
        System.out.println(com2.compare("aaa", "bbb"));


        System.out.println("-----------方法引用-----------");
        Comparator<String> com3 = String::compareTo;
        System.out.println(com3.compare("a", "l"));
    }

    //BiPredicate中的boolean test(T t1, T t2);
    //String中的boolean t1.equals(t2)
    @Test
    public void test6() {
        System.out.println("-----------原始写法-------------");
        BiPredicate<String, String> pre1 = new BiPredicate<String, String>() {
            @Override
            public boolean test(String s1, String s2) {
                return s1.equals(s2);
//                return s1.contains(s2);
            }
        };
        System.out.println(pre1.test("b", "c"));


        System.out.println("-----------lambda表达式------------");
        BiPredicate<String, String> pre2 = (s1, s2) -> s1.equals(s2);
        System.out.println(pre2.test("w", "k"));


        System.out.println("-----------方法引用------------");
        // 传参类型一致，调用方法一致
        BiPredicate<String, String> pre3 = String::equals;
        System.out.println(pre3.test("p", "k"));
    }

 // Function中的R apply(T t)
    // Employee中的String getName();
    @Test
    public void test7() {
        Employee employee = new Employee(1002, "zs", 25, 10000);

        System.out.println("-----------原始写法--------------");
        Function<Employee, String> fun1 = new Function<Employee, String>() {
            @Override
            public String apply(Employee emp) {
                return emp.getName();
            }
        };
        System.out.println(fun1.apply(employee));


        System.out.println("----------lambda表达式-----------");
        Function<Employee, String> fun2 = e -> e.getName();
        System.out.println(fun2.apply(employee));

        
        System.out.println("-----------方法引用------------");
        Function<Employee, String> fun3 = Employee::getName;
        System.out.println(fun3.apply(employee));
    }

(四)构造器引用

//构造器引用
    //Supplier中的T get()
    // Employee的空参构造器：Employee()
    @Test
    public void test1() {

        System.out.println("------------原始写法--------------");
        Supplier<Employee> sup1 = new Supplier<Employee>() {
            @Override
            public Employee get() {
                return new Employee();
            }
        };
        System.out.println(sup1.get());

        System.out.println("------------lambda写法---------------");
        Supplier<Employee> sup2 = () -> new Employee();
        System.out.println(sup2.get());

        System.out.println("------------方法引用--------------");
        Supplier<Employee> sup3 = Employee::new;
        System.out.println(sup3.get());

    }

//Function中的R apply(T t)
    @Test
    public void test2() {
        System.out.println("-------------原始写法----------------");
        Function<Integer, Employee> fun1 = new Function<Integer, Employee>() {
            @Override
            public Employee apply(Integer id) {
                return new Employee(id);
            }
        };
        System.out.println(fun1.apply(12));

        System.out.println("-----------lambda表达式--------------");
        Function<Integer, Employee> fun2 = id -> new Employee(id);
        System.out.println(fun2.apply(13));


        System.out.println("-------------方法引用----------------");
        Function<Integer, Employee> fun3 = Employee::new;
        System.out.println(fun3.apply(45));
    }

//BiFunction中的R apply(T t,U u)
    @Test
    public void test3() {
        BiFunction<Integer, String, Employee> fun1 = new BiFunction<Integer, String, Employee>() {
            @Override
            public Employee apply(Integer integer, String s) {
                return new Employee(integer, s);
            }
        };
        System.out.println(fun1.apply(12, "李四"));

        System.out.println("-----------------------");
        BiFunction<Integer, String, Employee> fun2 = (id, name) -> new Employee(id, name);
        System.out.println(fun2.apply(14, "王五"));


        System.out.println("--------------------------");
        BiFunction<Integer, String, Employee> fun3 = Employee::new;
        System.out.println(fun3.apply(56, "赵六"));
    }

(五)数组引用

//数组引用
    //Function中的R apply(T t)
    @Test
    public void test4() {
        System.out.println("----------原始写法-------------");
        Function<Integer,String[]> fun3 = new Function<Integer, String[]>() {
            @Override
            public String[] apply(Integer integer) {
                return new String[integer];
            }
        };
        String[] apply = fun3.apply(5);
        System.out.println(Arrays.toString(apply));


        System.out.println("----------lambda表达式-------------");
        Function<Integer, String[]> fun1 = size -> new String[size];
        System.out.println(Arrays.toString(fun1.apply(3)));// 创建长度为3的数组


        System.out.println("----------方法引用------------------");
        Function<Integer, String[]> fun2 = String[]::new;
        System.out.println(Arrays.toString(fun2.apply(7)));
    }

四、Stream API

(一)Stream的概念

Stream是数据渠道，用于操作数据源(集合、数组等)所生成的元素序列。

“集合讲的是数据，Stream讲的是计算”

注意：

1.Stream自己不会存储元素。

2.Stream不会改变源对象，相反，他们会返回一个持有记过的新Stream。

3.Stream操作时延迟执行的，这意味着他们会等到需要结果的时候才执行。

(二)创建Stream

说明：

1.一个中间操作链，对数据源的数据进行处理

2.一旦执行终止操作，就执行中间操作，并产生结果。之后，不会再被使用。

1.创建Stream方式一：通过集合

    @Test
    public void test1() {
        List<Employee> employees = EmployeeData.getEmployees();
        // default Stream<E> stream(): 返回一个顺序流，按照集合中数据的顺序拿数据
        Stream<Employee> stream = employees.stream();

        // default Stream<E> parallelStream(): 返回一个并行流，不按照顺序拿数据
        Stream<Employee> parallelStream = employees.parallelStream();
    }

2.创建Stream方式二：通过数组

    @Test
    public void test2() {
        // 调用Arrays类的static <T> Stream<T> stream(T[] array):返回一个流
        int[] arr = new int[]{1, 2, 3, 4, 5, 6};
        IntStream stream = Arrays.stream(arr);

        String[] strings = new String[]{"A", "B", "V"};
        Stream<String> stream1 = Arrays.stream(strings);

        Long[] longs = new Long[]{1l, 2l, 3l};
        Stream<Long> stream2 = Arrays.stream(longs);

        // 自定义类型数组
        Employee e1 = new Employee(1001, "bb");
        Employee e2 = new Employee(1002, "cc");
        Employee[] employees = {e1, e2};
        Stream<Employee> stream3 = Arrays.stream(employees);
    }

3.创建Stream方式三：通过Stream的of()

    @Test
    public void test3() {
        // 包装类
        Stream<Integer> stream = Stream.of(12, 3, 4, 8);
    }

4.创建Stream方法四：创建无限流

    @Test
    public void test4() {
        // 迭代
        // 遍历前10个偶数
        Stream.iterate(0, t -> t + 2).limit(10).forEach(System.out::println);

        // 生成
        // 遍历前10个随机数
        Stream.generate(Math::random).limit(10).forEach(System.out::println);
    }

(三)Stream的中间操作

1.筛选与切片

@Test
    public void test1() {
        // filter(Predicate p)——接收lambda，从流中排除某些元素
        // 过滤出工资>7000的员工
        List<Employee> list = EmployeeData.getEmployees();
        list.stream().filter(e -> e.getSalary() > 7000).forEach(System.out::println);

        System.out.println("-----------------------");
        // limit(n)——截断流，使其元素不超过给定数量
        list.stream().limit(3).forEach(System.out::println);

        System.out.println("-----------------------");
        // skip(n) ——跳过元素
        list.stream().skip(3).forEach(System.out::println);
        list.stream().skip(31).forEach(System.out::println);

        System.out.println("---------------------");
        list.add(new Employee(1010, "诸葛亮", 40, 80000));
        list.add(new Employee(1010, "诸葛亮", 40, 80000));
        list.add(new Employee(1010, "诸葛亮", 40, 80000));
        list.add(new Employee(1010, "诸葛亮", 40, 80000));
        list.add(new Employee(1010, "诸葛亮", 40, 80000));
        list.stream().distinct().forEach(System.out::println);

         System.out.println("++++++++++++++++++++=");
        // distinct——去重 注意distinct放入的位置，放在stream后面，和放在条件之后的结果是不一样的
        List<Integer> collect = employees.stream().map(Employee::getAge).distinct().collect(Collectors.toList());
        System.out.println(collect);// [34, 12, 33, 26, 65, 42, 35]
    }

2.映射

@Test
    public void test2() {
        List<String> list = Arrays.asList("aa", "bb", "cc");
        // 小写转为大写
        list.stream().map(str -> str.toUpperCase()).forEach(System.out::println);
        list.stream().map(String::toUpperCase).forEach(System.out::println);

        System.out.println("-------------------------");
        // 获取员工名字长度>3的员工姓名
        List<Employee> employees = EmployeeData.getEmployees();
        Stream<String> nameStream = employees.stream().map(Employee::getName);
        nameStream.filter(name -> name.length() > 3).forEach(System.out::println);

        System.out.println("------------------------");
        //                    先拿到名字列
        employees.stream().map(Employee::getName).filter(name -> name.length() > 3).forEach(System.out::println);

        // 获取工资>7000的员工姓名
        System.out.println("-------------获取工资>7000的员工姓名----------------");
        // 先过滤，再提取
        employees.stream().filter(salary -> salary.getSalary() > 7000).map(Employee::getName).forEach(System.out::println);

        System.out.println("-----------------------------");
        // 练习2
        Stream<Stream<Character>> streamStream = list.stream().map(StreamAPITest1::fromStringToStream);
        streamStream.forEach(s -> s.forEach(System.out::println));

        // flatMap——将流中的每个值都换成另一个流，然后把所有流连接成一个流
        System.out.println("+++++++++++++++++++++++++++++");
        list.stream().flatMap(StreamAPITest1::fromStringToStream).forEach(System.out::println);

    }

    // 将字符串中的多个字符构成的集合转换为对应的Stream的实例
    public static Stream<Character> fromStringToStream(String str) {
        ArrayList<Character> list = new ArrayList<>();
        for (char c : str.toCharArray()) {
            list.add(c);
        }
        return list.stream();
    }

3.排序

@Test
    public void test3() {
        // sorted
        List<Integer> list = Arrays.asList(45, 47, 12, 35);
        list.stream().sorted().forEach(System.out::println);

        // 抛出异常原因：Employee没有实现Comparable接口
        List<Employee> employees = EmployeeData.getEmployees();
//        employees.stream().sorted().forEach(System.out::println);

        System.out.println("-------------------------------");
        // sorted(Comparator com)
        // 根据年龄进行比较
        employees.stream().sorted((e1, e2) -> Integer.compare(e1.getAge(), e2.getAge())).forEach(System.out::println);

        System.out.println("++++++++++++++++++++++++");
        // 年龄一样的比较薪水
        employees.stream().sorted((e1, e2) -> {
            int ageValue = Integer.compare(e1.getAge(), e2.getAge());
            if (ageValue != 0) {
                return ageValue;
            } else {
//                return Double.compare(e1.getSalary(),e2.getSalary());// 升序
                return -Double.compare(e1.getSalary(), e2.getSalary());// 薪资比较降序
            }
        }).forEach(System.out::println);

//        employees.stream().sorted(Comparator.comparingInt(Employee::getAge)).forEach(System.out::println);
    }

(四)Stream的终止操作——匹配、规约、收集

1.匹配

    @Test
    public void test1() {
        List<Employee> employees = EmployeeData.getEmployees();
        // allMatch
        // 是否所有的员工的年龄都>18
        boolean b = employees.stream().allMatch(e -> e.getAge() > 18);
        System.out.println(b);

        // anyMatch——检查是否至少匹配一个元素
        // 练习：是否存在员工的工资>10000
        System.out.println(employees.stream().anyMatch(e -> e.getSalary() > 10000));

        // noneMatch——检查是否没有匹配的元素。返回false说明有匹配的元素
        // 练习：是否存在员工姓“雷”
        System.out.println(employees.stream().noneMatch(e -> e.getName().startsWith("雷")));

        // findFirst——返回第一个元素
        Optional<Employee> first = employees.stream().findFirst();
        System.out.println(first);

        // findAny——返回当前流中的任意元素
        Optional<Employee> any = employees.parallelStream().findAny();
        System.out.println(any);

        // count——返回流元素的总个数
        long count = employees.stream().filter(e -> e.getSalary() > 5000).count();
        System.out.println(count);

        // max(Comparator c) —— 返回流中的最大值
        // 返回最高工资
        Optional<Double> max = employees.stream().map(Employee::getSalary).max(Double::compare);
        System.out.println(max);
        System.out.println("----------------------");

        Stream<Double> doubleStream = employees.stream().map(Employee::getSalary);// 只取工资
        Optional<Double> maxSalary = doubleStream.max(Double::compare);// 工资类型中找最大值
        System.out.println(maxSalary);

        Optional<Double> max2 = employees.stream().map(e -> e.getSalary()).max(Double::compareTo);
        System.out.println(max2);

        // min ——返回流中的最小值
        Optional<Double> min = employees.stream().map(Employee::getSalary).min(Double::compare);
        System.out.println(min);

        Optional<Double> min1 = employees.stream().map(Employee::getSalary).min((e1, e2) -> e1.compareTo(e2));
        System.out.println(min1);

        Optional<Employee> min2 = employees.stream().min((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));
        System.out.println(min2);// Optional[Employee{id=1008, name='扎克伯格', age=35, salary=2500.32}]

        Optional<Double> min3 = employees.stream().map(Employee::getSalary).min((e1, e2) -> Double.compare(e1, e2));
        System.out.println(min3);

        Optional<Employee> min4 = employees.stream().min(Comparator.comparingDouble(Employee::getSalary));
        System.out.println(min4);// Optional[Employee{id=1008, name='扎克伯格', age=35, salary=2500.32}]

        Optional<Double> min5 = employees.stream().map(e -> e.getSalary()).min(Double::compareTo);
        System.out.println(min5);// Optional[2500.32]

        // forEach——内部迭代
        employees.stream().forEach(System.out::println);

        System.out.println("-----------------------");
        employees.forEach(System.out::println);
    }

2.规约

    @Test
    public void test2() {
        // reduce(T identity,BinaryOperator)——可以将流中元素反复结合起来，得到一个值。返回一个T
        // 练习1：计算1-10自然数的和
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        Integer sum = list.stream().reduce(0, Integer::sum);
        System.out.println(sum);// 55

        // reduce(BinaryOperator)——可以将流中元素反复结合起来，得到一个值。返回Optional<T>
        // 练习2：计算公司所有员工工资的总和
        List<Employee> employees = EmployeeData.getEmployees();
        Optional<Double> reduce = employees.stream().map(Employee::getSalary).reduce(Double::sum);
        System.out.println(reduce);// Optional[48424.08]

        // 下面的写法与scala相似
        Optional<Double> reduce1 = employees.stream().map(Employee::getSalary).reduce((e1, e2) -> e1 + e2);
        System.out.println(reduce1);
    }

3.收集

 @Test
    public void test3(){
        // collect(Collector c)——将流转换为其他形式，接收一个Collector接口的实现，用于给Stream中元素做汇总的方法
        // 练习1：查找工资大于6000的员工，结果返回为一个List或Set
        List<Employee> employees = EmployeeData.getEmployees();
        List<Employee> list = employees.stream().filter(e -> e.getSalary() > 5000).collect(Collectors.toList());
        for (Employee employee : list) {
            System.out.println(employee);
        }

        System.out.println("-------------------------------");
        Set<Employee> set = employees.stream().filter(e -> e.getSalary() > 5000).collect(Collectors.toSet());
        set.forEach(System.out::println);

        System.out.println("----------------------");
        ArrayList<Employee> collect = employees.stream().filter(e -> e.getSalary() > 5000).collect(Collectors.toCollection(ArrayList::new));
        collect.forEach(System.out::println);
    }

五、Optional类

(一)Optional概念

Optional类是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true，调用get()方法会返回该对象，避免空指针异常。

(二)Optional常用方法

(三)Optional使用举例

1.创建一个Girl类

public class Girl {
    private String name;

    public Girl() {
    }

    public Girl(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Girl{" +
                "name='" + name + '\'' +
                '}';
    }
}

2.创建一个Boy类

public class Boy {
    private Girl girl;

    public Boy() {
    }

    public Boy(Girl girl) {
        this.girl = girl;
    }

    public Girl getGirl() {
        return girl;
    }

    public void setGirl(Girl girl) {
        this.girl = girl;
    }

    @Override
    public String toString() {
        return "Boy{" +
                "girl=" + girl +
                '}';
    }
}

3.of方法的使用

 @Test
    public void test1() {
        Girl girl = new Girl();
//        girl=null;
        // of(T t)：保证t是非空的
        Optional<Girl> optionalGirl = Optional.of(girl);
        System.out.println(optionalGirl);// Optional[Girl{name='null'}]
    }

4.ofNullable方法的使用

@Test
    public void test2() {
        Girl girl = new Girl();
        girl = null;
        // ofNullable(T t): t可以为null
        Optional<Girl> optionalGirl = Optional.ofNullable(girl);
        System.out.println(optionalGirl);// 相当于调用Optional.empty方法

        // orElse(T t1):如果当前的Optional内部封装的t是非空的，则返回内部的t
        // 如果内部的t是空的，则返回orELse()方法中的参数t1
        Girl girl1 = optionalGirl.orElse(new Girl("222"));
        System.out.println(girl1);
    }

5.空指针现象

// 使用Optional之前可能会出现空指针的情况
    public String getGirlName(Boy boy) {
        return boy.getGirl().getName();
    }

    @Test
    public void test3() {
        Boy boy = new Boy();
        String girlName = getGirlName(boy);
        System.out.println(girlName);// 如果对象内没有参数，会出现空指针异常
    }

6.程序中空指针常规优化

// 常规优化girlName，避免出现空指针异常
    public String getGirlName1(Boy boy) {
        if (boy != null) {
            Girl girl = new Girl();
            if (girl != null) {
                return girl.getName();
            }
        }
        return null;
    }

    @Test
    public void test4() {
        Boy boy = new Boy();
        boy = null;
        String girlName1 = getGirlName1(boy);
        System.out.println(girlName1);// null
    }

7.程序中空指针Optional的优化

// 使用Optional类来优化
    public String getGirlName2(Boy boy) {
        Optional<Boy> boyOptional = Optional.ofNullable(boy);
        // 此时的boy1一定是非空
        Boy boy1 = boyOptional.orElse(new Boy(new Girl("boy")));
        Girl girl = boy1.getGirl();

        Optional<Girl> girlOptional = Optional.ofNullable(girl);
        // girl1一定非空
        Girl girl1 = girlOptional.orElse(new Girl("girl"));
        return girl1.getName();
    }

    @Test
    public void test5() {
        Boy boy = null;
        String girlName2 = getGirlName2(boy);
        System.out.println(girlName2);// boy
    }

    @Test
    public void test6() {
        Boy boy = null;
        boy = new Boy();
        String girlName2 = getGirlName2(boy);
        System.out.println(girlName2);// girl
    }

    @Test
    public void test7() {
        Boy boy = null;
        boy = new Boy();
        boy = new Boy(new Girl("girlName"));
        String girlName2 = getGirlName2(boy);
        System.out.println(girlName2);// girlName
    }