Java基础 - 第十一章 - JDK8新特性

新特性

一、Java8新特性

1.Lambda表达式

Lambda表达式的使用

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表达式的使用举例

LambdaTest1.java

public class LambdaTest1 {
    //语法格式一：无参，无返回值
    @Test
    public void test1(){
        Runnable r1 = new Runnable() {
            @Override
            public void run() {
                System.out.println("我爱北京天安门");
            }
        };
        r1.run(); //我爱北京天安门

        Runnable r2 = () -> {
            System.out.println("我爱北京故宫");
        };
        r2.run(); //我爱北京故宫
    }
    
    //语法格式二：Lambda 需要一个参数，但是没有返回值。
    @Test
    public void test2(){
        Consumer<String> con = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        con.accept("谎言和誓言的区别是什么？"); //谎言和誓言的区别是什么？

        Consumer<String> con1 = (String s) -> {
            System.out.println(s);
        };
        con1.accept("一个是听的人当真了，一个是说的人当真了"); //一个是听得人当真了，一个是说的人当真了
    }
    
    //语法格式三：数据类型可以省略，因为可由编译器推断得出，称为“类型推断”
    @Test
    public void test3(){
        Consumer<String> con1 = (String s) -> {
            System.out.println(s);
        };
        con1.accept("一个是听得人当真了，一个是说的人当真了"); //一个是听得人当真了，一个是说的人当真了

        Consumer<String> con2 = (s) -> {
            System.out.println(s);
        };
        con2.accept("一个是听得人当真了，一个是说的人当真了"); //一个是听得人当真了，一个是说的人当真了
    }
    
    //语法格式四：Lambda 若只需要一个参数时，参数的小括号可以省略
    @Test
    public void test4(){
        Consumer<String> con1 = (s) -> {
            System.out.println(s);
        };
        con1.accept("一个是听得人当真了，一个是说的人当真了"); //一个是听得人当真了，一个是说的人当真了

        Consumer<String> con2 = s -> {
            System.out.println(s);
        };
        con2.accept("一个是听得人当真了，一个是说的人当真了"); //一个是听得人当真了，一个是说的人当真了
    }
    
    //语法格式五：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);
            }
        };
        System.out.println(com1.compare(12,21));
        //12
        //21
        //-1

        Comparator<Integer> com2 = (o1,o2) -> {
            System.out.println(o1);
            System.out.println(o2);
            return o1.compareTo(o2);
        };
        System.out.println(com2.compare(12,6));
        //12
        //6
        //1
    }
    
    //语法格式六：当 Lambda 体只有一条语句时，return 与大括号若有，都可以省略
    @Test
    public void test6(){
        Comparator<Integer> com1 = (o1,o2) -> {
            return o1.compareTo(o2);
        };
        System.out.println(com1.compare(12,6)); //1

        Comparator<Integer> com2 = (o1,o2) -> o1.compareTo(o2);
        System.out.println(com2.compare(12,21)); //-1
    }
}

java内置的4大核心函数式接口

消费型接口 Consumer<T>     void accept(T t)
供给型接口 Supplier<T>     T get()
函数型接口 Function<T,R>   R apply(T t)
断定型接口 Predicate<T>    boolean test(T t)

LambdaTest2.java

public class LambdaTest2 {
    @Test
    public void test1(){
        happyTime(500, new Consumer<Double>() {
            @Override
            public void accept(Double aDouble) {
                System.out.println("矿泉水价格为：" + aDouble); //矿泉水价格为：500.0
            }
        });

        happyTime(400,money -> System.out.println("去喝了口水，价格为：" + money)); //去喝了口水，价格为：400.0
    }

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

    @Test
    public void test2(){
        List<String> list = Arrays.asList("北京","南京","天津","东京","西京","普京");

        List<String> filterStrs = filterString(list, new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.contains("京");
            }
        });
        System.out.println(filterStrs); //[北京, 南京, 东京, 西京, 普京]
        
        List<String> filterStrs1 = filterString(list,s -> s.contains("京"));
        System.out.println(filterStrs1); //[北京, 南京, 东京, 西京, 普京]
    }
    //根据给定的规则，过滤集合中的字符串。此规则由Predicate的方法决定
    public List<String> filterString(List<String> list, Predicate<String> pre){
        ArrayList<String> filterList = new ArrayList<>();
        for(String s : list){
            if(pre.test(s)){
                filterList.add(s);
            }
        }
        return filterList;
    }
}

方法引用

方法引用的使用

1.使用情境：当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用！
2.方法引用，本质上就是Lambda表达式，而Lambda表达式作为函数式接口的实例。所以
  方法引用，也是函数式接口的实例。
3.使用格式：  类(或对象) :: 方法名
4.具体分为如下的三种情况：
   情况1     对象 :: 非静态方法
   情况2     类 :: 静态方法
   情况3     类 :: 非静态方法
5.方法引用使用的要求：要求接口中的抽象方法的形参列表和返回值类型与方法引用的方法的
  形参列表和返回值类型相同！（针对于情况1和情况2）

Employee.java

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() {
		System.out.println("Employee().....");
	}

	public Employee(int id) {
		this.id = id;
		System.out.println("Employee(int 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;
	}
}

EmployeeData.java

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;
	}
}

MethodRefTest.java

public class MethodRefTest {
	// 情况一：对象 :: 实例方法
	//Consumer中的void accept(T t)
	//PrintStream中的void println(T t)
	@Test
	public void test1() {
		Consumer<String> con1 = str -> System.out.println(str);
		con1.accept("北京"); //北京

		PrintStream ps = System.out;
		Consumer<String> con2 = ps::println;
		con2.accept("beijing"); //beijing
	}
	
	//Supplier中的T get()
	//Employee中的String getName()
	@Test
	public void test2() {
		Employee emp = new Employee(1001, "Tom", 23, 5600);

		Supplier<String> sup1 = () -> emp.getName();
		System.out.println(sup1.get()); //Tom

		Supplier<String> sup2 = emp::getName;
		System.out.println(sup2.get()); //Tom
	}

	// 情况二：类 :: 静态方法
	//Comparator中的int compare(T t1,T t2)
	//Integer中的int compare(T t1,T t2)
	@Test
	public void test3() {
		Comparator<Integer> com1 = (t1,t2) -> Integer.compare(t1,t2);
		System.out.println(com1.compare(12, 21)); //-1

		Comparator<Integer> com2 = Integer::compare;
		System.out.println(com2.compare(12, 3)); //1
	}
	
	//Function中的R apply(T t)
	//Math中的Long round(Double d)
	@Test
	public void test4() {
		Function<Double,Long> func = new Function<Double, Long>() {
			@Override
			public Long apply(Double d) {
				return Math.round(d);
			}
		};

		Function<Double,Long> func1 = d -> Math.round(d);
		System.out.println(func1.apply(12.3)); //12

		Function<Double,Long> func2 = Math::round;
		System.out.println(func2.apply(12.6)); //13
	}

	// 情况三：类 :: 实例方法  (有难度)
	// Comparator中的int compare(T t1,T t2)
	// String中的int t1.compareTo(t2)
	@Test
	public void test5() {
		Comparator<String> com1 = (s1,s2) -> s1.compareTo(s2);
		System.out.println(com1.compare("abc", "abd")); //-1

		Comparator<String> com2 = String :: compareTo;
		System.out.println(com2.compare("abd", "abm")); //-9
	}

	//BiPredicate中的boolean test(T t1, T t2);
	//String中的boolean t1.equals(t2)
	@Test
	public void test6() {
		BiPredicate<String,String> pre1 = (s1,s2) -> s1.equals(s2);
		System.out.println(pre1.test("abc", "abc")); //true

		BiPredicate<String,String> pre2 = String :: equals;
		System.out.println(pre2.test("abc", "abd")); //false
	}
	
	// Function中的R apply(T t)
	// Employee中的String getName();
	@Test
	public void test7() {
		Employee employee = new Employee(1001, "Jerry", 23, 6000);

		Function<Employee,String> func1 = e -> e.getName();
		System.out.println(func1.apply(employee)); //Jerry

		Function<Employee,String> func2 = Employee::getName;
		System.out.println(func2.apply(employee)); //Jerry
	}
}

构造器引用和数组引用

一、构造器引用
     和方法引用类似，函数式接口的抽象方法的形参列表和构造器的形参列表一致。
     抽象方法的返回值类型即为构造器所属的类的类型

二、数组引用
     大家可以把数组看做是一个特殊的类，则写法与构造器引用一致。

ConstructorRefTest.java

public class ConstructorRefTest {
	//构造器引用
    //Supplier中的T get()
    //Employee的空参构造器：Employee()
    @Test
    public void test1(){
        Supplier<Employee> sup = new Supplier<Employee>() {
            @Override
            public Employee get() {
                return new Employee();
            }
        };

        Supplier<Employee>  sup1 = () -> new Employee(); //Employee().....
        System.out.println(sup1.get()); //Employee{id=0, name='null', age=0, salary=0.0}

        Supplier<Employee>  sup2 = Employee :: new; //Employee().....
        System.out.println(sup2.get()); //Employee{id=0, name='null', age=0, salary=0.0}
    }

	//Function中的R apply(T t)
    @Test
    public void test2(){
        Function<Integer,Employee> func1 = id -> new Employee(id);
        Employee employee = func1.apply(1001); //Employee(int id).....
        System.out.println(employee); //Employee{id=1001, name='null', age=0, salary=0.0}

        Function<Integer,Employee> func2 = Employee :: new;
        Employee employee1 = func2.apply(1002); //Employee(int id).....
        System.out.println(employee1); //Employee{id=1002, name='null', age=0, salary=0.0}
    }

	//BiFunction中的R apply(T t,U u)
    @Test
    public void test3(){
        BiFunction<Integer,String,Employee> func1 = (id,name) -> new Employee(id,name);
        System.out.println(func1.apply(1001, "Tom")); //Employee{id=1001, name='Tom', age=0, salary=0.0}

        BiFunction<Integer,String,Employee> func2 = Employee :: new;
        System.out.println(func2.apply(1002, "Tom")); //Employee{id=1002, name='Tom', age=0, salary=0.0}
    }

	//数组引用
    //Function中的R apply(T t)
    @Test
    public void test4(){
        Function<Integer,String[]> func1 = length -> new String[length];
        String[] arr1 = func1.apply(5);
        System.out.println(Arrays.toString(arr1)); //[null, null, null, null, null]

        Function<Integer,String[]> func2 = String[] :: new;
        String[] arr2 = func2.apply(10);
        System.out.println(Arrays.toString(arr2)); //[null, null, null, null, null, null, null, null, null, null]
    }
}

2.Stream API

1. Stream关注的是对数据的运算，与CPU打交道
   集合关注的是数据的存储，与内存打交道

2.
    ①Stream 自己不会存储元素。
    ②Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream。
    ③Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行

3.Stream 执行流程
    ①Stream的实例化
    ②一系列的中间操作（过滤、映射、...)
    ③终止操作

4.说明：
    ①一个中间操作链，对数据源的数据进行处理
    ②一旦执行终止操作，就执行中间操作链，并产生结果。之后，不会再被使用

StreamAPITest.java

public class StreamAPITest {
    //创建 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();
    }

    //创建 Stream方式二：通过数组
    @Test
    public void test2(){
        int[] arr = new int[]{1,2,3,4,5,6};
        //调用Arrays类的static <T> Stream<T> stream(T[] array): 返回一个流
        IntStream stream = Arrays.stream(arr);
        Employee e1 = new Employee(1001, "Tom");
        Employee e2 = new Employee(1002, "Jerry");
        Employee[] arr1 = new Employee[]{e1,e2};
        Stream<Employee> stream1 = Arrays.stream(arr1);
    }
    
    //创建 Stream方式三：通过Stream的of()
    @Test
    public void test3(){
        Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6);
    }

    //创建 Stream方式四：创建无限流
    @Test
    public void test4(){
//      迭代
//      public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f)
        //遍历前10个偶数
        Stream.iterate(0, t -> t + 2).limit(10).forEach(System.out::println);
//      生成
//      public static<T> Stream<T> generate(Supplier<T> s)
        Stream.generate(Math::random).limit(10).forEach(System.out::println);
    }
}

测试Stream的中间操作

StreamAPITest1.java

public class StreamAPITest1 {
    //1-筛选与切片
    @Test
    public void test1(){
        List<Employee> list = EmployeeData.getEmployees();
//        filter(Predicate p)——接收 Lambda ， 从流中排除某些元素。
        Stream<Employee> stream = list.stream();
        //练习：查询员工表中薪资大于7000的员工信息
        stream.filter(e -> e.getSalary() > 7000).forEach(System.out::println);
        //Employee{id=1002, name='马云', age=12, salary=9876.12}
        //Employee{id=1004, name='雷军', age=26, salary=7657.37}
        //Employee{id=1006, name='比尔盖茨', age=42, salary=9500.43}

        System.out.println();
//        limit(n)——截断流，使其元素不超过给定数量。
        list.stream().limit(3).forEach(System.out::println);
        //Employee{id=1001, name='马化腾', age=34, salary=6000.38}
        //Employee{id=1002, name='马云', age=12, salary=9876.12}
        //Employee{id=1003, name='刘强东', age=33, salary=3000.82}

        System.out.println();
//        skip(n) —— 跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素不足 n 个，则返回一个空流。与 limit(n) 互补
        list.stream().skip(3).forEach(System.out::println);
        //Employee{id=1004, name='雷军', age=26, salary=7657.37}
        //Employee{id=1005, name='李彦宏', age=65, salary=5555.32}
        //Employee{id=1006, name='比尔盖茨', age=42, salary=9500.43}
        //Employee{id=1007, name='任正非', age=26, salary=4333.32}
        //Employee{id=1008, name='扎克伯格', age=35, salary=2500.32}

        System.out.println();
//        distinct()——筛选，通过流所生成元素的 hashCode() 和 equals() 去除重复元素
        list.add(new Employee(1010, "刘强东", 40, 8000));
        list.add(new Employee(1010, "刘强东", 41, 8000));
        list.add(new Employee(1010, "刘强东", 40, 8000));
        list.add(new Employee(1010, "刘强东", 40, 8000));
        list.add(new Employee(1010, "刘强东", 40, 8000));

        list.stream().distinct().forEach(System.out::println);
        //Employee{id=1001, name='马化腾', age=34, salary=6000.38}
        //Employee{id=1002, name='马云', age=12, salary=9876.12}
        //Employee{id=1003, name='刘强东', age=33, salary=3000.82}
        //Employee{id=1004, name='雷军', age=26, salary=7657.37}
        //Employee{id=1005, name='李彦宏', age=65, salary=5555.32}
        //Employee{id=1006, name='比尔盖茨', age=42, salary=9500.43}
        //Employee{id=1007, name='任正非', age=26, salary=4333.32}
        //Employee{id=1008, name='扎克伯格', age=35, salary=2500.32}
        //Employee{id=1010, name='刘强东', age=40, salary=8000.0}
        //Employee{id=1010, name='刘强东', age=41, salary=8000.0}
    }

    //映射
    @Test
    public void test2(){
//        map(Function f)——接收一个函数作为参数，将元素转换成其他形式或提取信息，该函数会被应用到每个元素上，并将其映射成一个新的元素。
        List<String> list = Arrays.asList("aa", "bb", "cc", "dd");
        list.stream().map(str -> str.toUpperCase()).forEach(System.out::println);
        //AA
        //BB
        //CC
        //DD
//        练习1：获取员工姓名长度大于3的员工的姓名。
        List<Employee> employees = EmployeeData.getEmployees();
        Stream<String> namesStream = employees.stream().map(Employee::getName);
        namesStream.filter(name -> name.length() > 3).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);
        });
        //a
        //a
        //b
        //b
        //c
        //c
        //d
        //d
        System.out.println();
//        flatMap(Function f)——接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流。
        Stream<Character> characterStream = list.stream().flatMap(StreamAPITest1::fromStringToStream);
        characterStream.forEach(System.out::println);
        //a
        //a
        //b
        //b
        //c
        //c
        //d
        //d
    }
    //将字符串中的多个字符构成的集合转换为对应的Stream的实例
    public static Stream<Character> fromStringToStream(String str){ //aa
        ArrayList<Character> list = new ArrayList<>();
        for(Character c : str.toCharArray()){
            list.add(c);
        }
       return list.stream();
    }

    //3-排序
    @Test
    public void test3(){
//        sorted()——自然排序
        List<Integer> list = Arrays.asList(12, 43, 65, 34, 87, 0, -98, 7);
        list.stream().sorted().forEach(System.out::println);
        //-98
        //0
        //7
        //12
        //34
        //43
        //65
        //87
        
        //抛异常，原因:Employee没有实现Comparable接口
//        List<Employee> employees = EmployeeData.getEmployees();
//        employees.stream().sorted().forEach(System.out::println);
        
//        sorted(Comparator com)——定制排序
        List<Employee> employees = EmployeeData.getEmployees();
        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());
           }
        }).forEach(System.out::println);
        //Employee{id=1002, name='马云', age=12, salary=9876.12}
        //Employee{id=1004, name='雷军', age=26, salary=7657.37}
        //Employee{id=1007, name='任正非', age=26, salary=4333.32}
        //Employee{id=1003, name='刘强东', age=33, salary=3000.82}
        //Employee{id=1001, name='马化腾', age=34, salary=6000.38}
        //Employee{id=1008, name='扎克伯格', age=35, salary=2500.32}
        //Employee{id=1006, name='比尔盖茨', age=42, salary=9500.43}
        //Employee{id=1005, name='李彦宏', age=65, salary=5555.32}
    }
}

测试Stream的终止操作

StreamAPITest2.java

public class StreamAPITest2 {
    //1-匹配与查找
    @Test
    public void test1(){
        List<Employee> employees = EmployeeData.getEmployees();
//        allMatch(Predicate p)——检查是否匹配所有元素。
//          练习：是否所有的员工的年龄都大于18
        boolean allMatch = employees.stream().allMatch(e -> e.getAge() > 18);
        System.out.println(allMatch); //false
//        anyMatch(Predicate p)——检查是否至少匹配一个元素。
//          练习：是否存在员工的工资大于 10000
        boolean anyMatch = employees.stream().anyMatch(e -> e.getSalary() > 10000);
        System.out.println(anyMatch); //false
//        noneMatch(Predicate p)——检查是否没有匹配的元素。
//          练习：是否存在员工姓“雷”
        boolean noneMatch = employees.stream().noneMatch(e -> e.getName().startsWith("雷"));
        System.out.println(noneMatch); //false
//        findFirst——返回第一个元素
        Optional<Employee> employee = employees.stream().findFirst();
        System.out.println(employee); //Optional[Employee{id=1001, name='马化腾', age=34, salary=6000.38}]
//        findAny——返回当前流中的任意元素
        Optional<Employee> employee1 = employees.parallelStream().findAny();
        System.out.println(employee1); //Optional[Employee{id=1006, name='比尔盖茨', age=42, salary=9500.43}]
    }
    @Test
    public void test2(){
        List<Employee> employees = EmployeeData.getEmployees();
        // count——返回流中元素的总个数
        long count = employees.stream().filter(e -> e.getSalary() > 5000).count();
        System.out.println(count); //5
//        max(Comparator c)——返回流中最大值
//        练习：返回最高的工资：
        Stream<Double> salaryStream = employees.stream().map(e -> e.getSalary());
        Optional<Double> maxSalary = salaryStream.max(Double::compare);
        System.out.println(maxSalary); //Optional[9876.12]
//        min(Comparator c)——返回流中最小值
//        练习：返回最低工资的员工
        Optional<Employee> employee = employees.stream().min((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));
        System.out.println(employee); //Optional[Employee{id=1008, name='扎克伯格', age=35, salary=2500.32}]
        System.out.println();
//        forEach(Consumer c)——内部迭代
        employees.stream().forEach(System.out::println);
        //Employee{id=1001, name='马化腾', age=34, salary=6000.38}
        //Employee{id=1002, name='马云', age=12, salary=9876.12}
        //Employee{id=1003, name='刘强东', age=33, salary=3000.82}
        //Employee{id=1004, name='雷军', age=26, salary=7657.37}
        //Employee{id=1005, name='李彦宏', age=65, salary=5555.32}
        //Employee{id=1006, name='比尔盖茨', age=42, salary=9500.43}
        //Employee{id=1007, name='任正非', age=26, salary=4333.32}
        //Employee{id=1008, name='扎克伯格', age=35, salary=2500.32}
        System.out.println();
        //使用集合的遍历操作
        employees.forEach(System.out::println);
        //Employee{id=1001, name='马化腾', age=34, salary=6000.38}
        //Employee{id=1002, name='马云', age=12, salary=9876.12}
        //Employee{id=1003, name='刘强东', age=33, salary=3000.82}
        //Employee{id=1004, name='雷军', age=26, salary=7657.37}
        //Employee{id=1005, name='李彦宏', age=65, salary=5555.32}
        //Employee{id=1006, name='比尔盖茨', age=42, salary=9500.43}
        //Employee{id=1007, name='任正非', age=26, salary=4333.32}
        //Employee{id=1008, name='扎克伯格', age=35, salary=2500.32}
    }

    //2-归约
    @Test
    public void test3(){
//        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();
        Stream<Double> salaryStream = employees.stream().map(Employee::getSalary);
//        Optional<Double> sumMoney = salaryStream.reduce(Double::sum);
        Optional<Double> sumMoney = salaryStream.reduce((d1,d2) -> d1 + d2);
        System.out.println(sumMoney.get()); //48424.08
    }

    //3-收集
    @Test
    public void test4(){
//        collect(Collector c)——将流转换为其他形式。接收一个 Collector接口的实现，用于给Stream中元素做汇总的方法
//        练习1：查找工资大于6000的员工，结果返回为一个List或Set
        List<Employee> employees = EmployeeData.getEmployees();
        List<Employee> employeeList = employees.stream().filter(e -> e.getSalary() > 6000).collect(Collectors.toList());
        employeeList.forEach(System.out::println);
        //Employee{id=1001, name='马化腾', age=34, salary=6000.38}
        //Employee{id=1002, name='马云', age=12, salary=9876.12}
        //Employee{id=1004, name='雷军', age=26, salary=7657.37}
        //Employee{id=1006, name='比尔盖茨', age=42, salary=9500.43}
        System.out.println();
        Set<Employee> employeeSet = employees.stream().filter(e -> e.getSalary() > 6000).collect(Collectors.toSet());
        employeeSet.forEach(System.out::println);
        //Employee{id=1001, name='马化腾', age=34, salary=6000.38}
        //Employee{id=1002, name='马云', age=12, salary=9876.12}
        //Employee{id=1006, name='比尔盖茨', age=42, salary=9500.43}
        //Employee{id=1004, name='雷军', age=26, salary=7657.37}
    }
}

3.Optional类

Optional类：为了在程序中避免出现空指针异常而创建的。

常用的方法：ofNullable(T t)
           orElse(T t)

Girl.java

public class Girl {
    private String name;

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

    public String getName() {
        return name;
    }

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

    public Girl() {
    }

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

Boy.java

public class Boy {
    private Girl girl;

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

    public Girl getGirl() {
        return girl;
    }

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

    public Boy() {
    }

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

OptionalTest.java

public class OptionalTest {
/*
Optional.of(T t) : 创建一个 Optional 实例，t必须非空；
Optional.empty() : 创建一个空的 Optional 实例
Optional.ofNullable(T t)：t可以为null
 */
    @Test
    public void test1(){
        Girl girl = new Girl();
//        girl = null;
        //of(T t):保证t是非空的
        Optional<Girl> optionalGirl = Optional.of(girl);
    }

    @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);
        //orElse(T t1):如果单前的Optional内部封装的t是非空的，则返回内部的t.
        //如果内部的t是空的，则返回orElse()方法中的参数t1.
        Girl girl1 = optionalGirl.orElse(new Girl("赵丽颖"));
        System.out.println(girl1);
    }

    public String getGirlName(Boy boy){
        return boy.getGirl().getName();
    }

    @Test
    public void test3(){
        Boy boy = new Boy();
        boy = null;
        String girlName = getGirlName(boy);
        System.out.println(girlName);
    }
    //优化以后的getGirlName():
    public String getGirlName1(Boy boy){
        if(boy != null){
            Girl girl = boy.getGirl();
            if(girl != null){
                return girl.getName();
            }
        }
        return null;
    }

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

    //使用Optional类的getGirlName():
    public String getGirlName2(Boy boy){
        Optional<Boy> boyOptional = Optional.ofNullable(boy);
        //此时的boy1一定非空
        Boy boy1 = boyOptional.orElse(new Boy(new Girl("迪丽热巴")));
        Girl girl = boy1.getGirl();
        Optional<Girl> girlOptional = Optional.ofNullable(girl);
        //girl1一定非空
        Girl girl1 = girlOptional.orElse(new Girl("古力娜扎"));
        return girl1.getName();
    }

    @Test
    public void test5(){
        Boy boy1 = null;
        Boy boy2 = new Boy();
        Boy boy3 = new Boy(new Girl("苍老师"));
        
        String girlName1 = getGirlName2(boy1);
        String girlName2 = getGirlName2(boy2);
        String girlName3 = getGirlName2(boy3);
        
        System.out.println(girlName1); //迪丽热巴
        System.out.println(girlName2); //古力娜扎
        System.out.println(girlName3); //苍老师
    }
}

二、Java9新特性

1.JDK 和 JRE 目录结构的改变

2.模块化系统: Jigsaw -> Modularity

3.Java的REPL工具：jShell命令

4.语法改进：接口的私有方法

MyInterface.java

public interface MyInterface {
    //如下的三个方法的权限修饰符都是public
    void methodAbstract();

    static void methodStatic(){
        System.out.println("我是接口中的静态方法");
    }

    default void methodDefault(){
        System.out.println("我是接口中的默认方法");
        methodPrivate();
    }
    //jdk9中允许接口中定义私有的方法
    private void methodPrivate(){
        System.out.println("我是接口中的私有方法");
    }
}

MyInterfaceImpl.java

public class MyInterfaceImpl implements MyInterface {
    @Override
    public void methodAbstract() {
    }

    @Override
    public void methodDefault() {
        System.out.println("实现类重写了接口中的默认方法");
    }

    public static void main(String[] args) {
        //接口中的静态方法只能由接口自己调用
        MyInterface.methodStatic(); //我是接口中的静态方法
        //接口的实现类不能调用接口的静态方法
//        MyInterfaceImpl.methodStatic();
        MyInterfaceImpl impl = new MyInterfaceImpl();
        impl.methodDefault(); //实现类重写了接口中的默认方法
        //接口的私有方法，不能在接口外部调用
//        impl.methodPrivate();
    }
}

5.语法改进:钻石操作符使用升级

@Test

    @Test
    public void test() {
        //钻石操作符与匿名内部类在java8中不能共存。在java9可以。
        Comparator<Object> com = new Comparator<>() {
            @Override
            public int compare(Object o1, Object o2) {
                return 0;
            }
        };
        //jdk7中的新特性：类型推断
        ArrayList<String> list = new ArrayList<>();
    }

6.语法改进：try语句

main()

    public static void main(String[] args) {
        //java8之前的资源关闭的操作
//        InputStreamReader reader = null;
//        try {
//            reader = new InputStreamReader(System.in);
//            char[] cbuf = new char[20];
//            int len;
//            if((len = reader.read(cbuf)) != -1){
//                String str = new String(cbuf, 0, len);
//                System.out.println(str);
//            }
//        } catch (IOException e) {
//            e.printStackTrace();
//        } finally {
//            if(reader != null){
//                try {
//                    reader.close();
//                } catch (IOException e) {
//                    e.printStackTrace();
//                }
//
//            }
//        }

        //java8中资源关闭操作: Java 8 中，可以实现资源的自动关闭
        //要求自动关闭的资源的实例化必须放在try的一对小括号中
//        try(InputStreamReader reader = new InputStreamReader(System.in)){
//            char[] cbuf = new char[20];
//            int len;
//            if((len = reader.read(cbuf)) != -1){
//                String str = new String(cbuf, 0, len);
//                System.out.println(str);
//            }
//        } catch (IOException e) {
//            e.printStackTrace();
//        }

        //java9中资源关闭操作：需要自动关闭的资源的实例化可以放在try的一对小括号外。
        //此时的资源属性是常量，声明为final的，不可修改
        InputStreamReader reader = new InputStreamReader(System.in);
        try (reader) {
            char[] cbuf = new char[20];
            int len;
            if((len = reader.read(cbuf)) != -1){
                String str = new String(cbuf, 0, len);
                System.out.println(str);
            }
//            reader = null; //错误
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

7.String存储结构变更

动机：
String类的当前实现将字符存储在char数组中，每个字符使用两个字节(16位)。
从许多不同应用程序收集的数据表明，字符串是堆使用的一个主要组件，而且，
大多数字符串对象只包含Latin-1字符。这样的字符只需要一个字节的存储，
因此这样的字符串对象的内部char数组中有一半的空间没有使用。

描述：
我们建议将String类的内部表示形式从UTF-16 char数组更改为字节数组加上编码标志字段。
新的String类将根据字符串的内容存储编码为ISO-8859-1/Latin-1(每个字符一个字节)
或UTF-16(每个字符两个字节)的字符。编码标志将指示使用哪种编码。

8.集合工厂方法：快速创建只读集合

@Test

    //java8中的写法：
    @Test
    public void test1() {
        List<String> namesList = new ArrayList<>();
        namesList.add("Joe");
        namesList.add("Bob");
        namesList.add("Bill");
        //返回的namesList是一个只读的集合
        namesList = Collections.unmodifiableList(namesList);
        namesList.add("Tom");  //执行报错
        System.out.println(namesList);
    }

    @Test
    public void test2() {
        List<String> list = Collections.unmodifiableList(Arrays.asList("a", "b", "c"));
        Set<String> set = Collections.unmodifiableSet(new HashSet<>(Arrays.asList("a", "b", "c")));
        // 如下操作不适用于jdk8及之前版本,适用于jdk 9
        Map<String, Integer> map = Collections.unmodifiableMap(new HashMap<>() {
            {
                put("a", 1);
                put("b", 2);
                put("c", 3);
            }
        });
        map.forEach((k, v) -> System.out.println(k + ":" + v));
        //a:1
        //b:2
        //c:3
    }

    @Test
    public void test3() {
        //此时得到的集合list也是一个只读集合。
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
        //报异常
        list.add(6);
    }

    //java9新特性八：集合工厂方法：创建只读集合
    @Test
    public void test4() {
        List<Integer> list1 = List.of(1, 2, 3, 4, 5);
        //不能添加
//        list1.add(6);
        System.out.println(list1); //[1, 2, 3, 4, 5]

        Set<Integer> set1 = Set.of(23, 3, 54, 65, 43, 76, 87, 34, 46);
        //不能添加
//        set1.add(4);
        System.out.println(set1); //[76, 3, 54, 34, 87, 65, 46, 43, 23]

        Map<String, Integer> map1 = Map.of("Tom", 23, "Jerry", 54, "HanMeimei", 12);
        //不能添加
        //map1.put("Lilei",34);
        System.out.println(map1); //{Tom=23, Jerry=54, HanMeimei=12}

        Map<String, Integer> map2 = Map.ofEntries(Map.entry("Tom", 34), Map.entry("Jerry", 21));
        //不能添加
//        map2.put("Lilei",34);
        System.out.println(map2); //{Jerry=21, Tom=34}
    }

9.InputStream 加强

@Test

    //java9中InputStream的新方法:tranferTo()
    @Test
    public void test() {
        ClassLoader cl = this.getClass().getClassLoader();
        try (InputStream is = cl.getResourceAsStream("hello.txt");
             OutputStream os = new FileOutputStream("src\\hello1.txt")) {
            is.transferTo(os); //把输入流中的所有数据直接自动地复制到输出流中
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

10.增强的 Stream API

@Test

    @Test
    public void test1(){
        List<Integer> list = Arrays.asList(23, 43, 45, 55, 61, 54, 32, 2, 45, 89, 7);
        //takeWhile 返回从开头开始的按照指定规则尽量多的元素
        list.stream().takeWhile(x -> x < 60).forEach(System.out::println);
        //23
        //43
        //45
        //55
        System.out.println();
        //dropWhile():与 takeWhile 相反，返回剩余的元素。
        list.stream().dropWhile(x -> x < 60).forEach(System.out::println);
        //61
        //54
        //32
        //2
        //45
        //89
        //7
    }

    @Test
    public void test2(){
        //of()参数中的多个元素，可以包含null值
        Stream<Integer> stream1 = Stream.of(1, 2, 3, null);
        stream1.forEach(System.out::println);
        //1
        //2
        //3
        //null

        //of()参数不能存储单个null值。否则，报异常
//        Stream<Object> stream2 = Stream.of(null);
//        stream2.forEach(System.out::println);
        Integer i = 10;
        i = null;
        //ofNullable()：形参变量是可以为null值的单个元素
        Stream<Integer> stream3 = Stream.ofNullable(i);
        long count = stream3.count();
        System.out.println(count); //0
    }

    @Test
    public void test3(){
        Stream.iterate(0, x -> x + 1).limit(10).forEach(System.out::println);
        //0
        //1
        //2
        //3
        //4
        //5
        //6
        //7
        //8
        //9
        //java9中新增的重载的方法
        Stream.iterate(0, x -> x < 10, x -> x + 1).forEach(System.out::println);
        //0
        //1
        //2
        //3
        //4
        //5
        //6
        //7
        //8
        //9
    }

11.Optional获取Stream的方法

@Test

    //java9中Optional提供了新的方法stream()
    @Test
    public void test4(){
        List<String> list = new ArrayList<>();

        list.add("Tom");
        list.add("Jerry");
        list.add("Tim");

        Optional<List<String>> optional = Optional.ofNullable(list);
        Stream<List<String>> stream = optional.stream();
//        long count = stream.count();
//        System.out.println(count); //1
        stream.flatMap(x -> x.stream()).forEach(System.out::println);
        //Tom
        //Jerry
        //Tim
    }

12.Javascript引擎升级：Nashorn

三、Java10新特性

1.局部变量类型推断

@Test

    @Test
    public void test1() {
        //1.声明变量时，根据所附的值，推断变量的类型
        var num = 10;

        var list = new ArrayList<Integer>();
        list.add(123);

        //2.遍历操作
        for (var i : list) {
            System.out.println(i); //123
            System.out.println(i.getClass()); //class java.lang.Integer
        }

        //3.普通的遍历操作
        for (var i = 0; i < 5; i++) {
            System.out.println(i);
        }
        //0
        //1
        //2
        //3
        //4
    }

    @Test
    public void test2() {
        //在局部变量中使用时，如下情况不适用：
        //1.局部变量不赋值，就不能实现类型推断
        int num = 123;
//        var num ;

        //2.lambda表示式中，左边的函数式接口不能声明为var
        Supplier<Double> sup = () -> Math.random();
//        var sup = () -> Math.random();

        //3.方法引用中，左边的函数式接口不能声明为var
        Consumer<String> con = System.out::println;
//        var con = System.out::println;

        //4.数组的静态初始化中，注意如下的情况也不可以
        int[] arr = {1, 2, 3, 4};
//        var arr = {1,2,3,4};
    }

    @Test
    public void test3() {
        //不适用以下的结构中：
//        情况1：没有初始化的局部变量声明
//        var s = null;
        
//        情况6：catch块
//        try{
//        }catch(var e){
//            e.printStackTrace();
//        }
    }
    //情况2：方法的返回类型
//    public var method1(){
//        return 0;
//    }
    //情况3：方法的参数类型
//    public void method2(var num){
//    }
    //情况4：构造器的参数类型
//    public Java10Test(var i){
//    }
    //情况5：属性
//    var num;
    
    @Test
    public void test4() {
        try {
            var url = new URL("http://www.atguigu.com");
            var connection = url.openConnection();
            var reader = new BufferedReader(new InputStreamReader(connection.getInputStream()));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

2.集合新增创建不可变集合的方法

@Test

    //java10集合中新增的copyOf()，用于创建一个只读的集合
    @Test
    public void test5(){
        //示例1：
        var list1 = List.of("Java", "Python", "C");
        var copy1 = List.copyOf(list1);
        System.out.println(list1 == copy1); //true

        //示例2：
        var list2 = new ArrayList<String>();
        list2.add("aaa");
        var copy2 = List.copyOf(list2);
        System.out.println(list2 == copy2); //false

        //示例1和2代码基本一致，为什么一个为true,一个为false?
        //结论：copyOf(Xxx coll):如果参数coll本身就是一个只读集合，则copyOf()返回值即为当前的coll
        //如果参数coll不是一个只读集合，则copyOf()返回一个新的集合，这个集合是只读的。
    }

四、Java11新特性

1.新增了一系列字符串处理方法

@Test

    @Test
    public void test1(){
//        isBlank():判断字符串是否为空白
        System.out.println("  \t  \t  \n  ".isBlank()); //true
//        strip():去除首尾空白
        System.out.println("-----" + "  \t abc \t  \n  ".strip() + "-------"); //-----abc-------
        System.out.println("-----" + "  \t abc \t  \n  ".trim() + "-------"); //-----abc-------
//        stripTrailing():去除尾部空格
        System.out.println("-----" + "  \t abc \t  \n  ".stripTrailing() + "-------"); //-----  	 abc-------
//        stripLeading():去除首部空格
        System.out.println("-----" + "  \t abc \t  \n  ".stripLeading() + "-------"); //-----abc
                                                                                      //  -------
//        repeat(int count):复制字符串
        String str1 = "abc";
        String str2 = str1.repeat(5);
        System.out.println(str2); //abcabcabcabcabc

//        lines().count():行数统计
        String str3 = "abc\ndef\ng";
        System.out.println(str3.lines().count()); //3
    }

2.Optional加强

@Test

    @Test
    public void test2(){
        var op = Optional.empty();
        System.out.println(op.isPresent()); //判断内部的value是否存在 //false
        System.out.println(op.isEmpty()); //判断内部的value是否为空 //true

        op = Optional.of("abc");
        //orElseThrow():value非空，返回value；否则抛异常NoSuchElementException
        var obj = op.orElseThrow();
        System.out.println(obj); //abc

        Optional<String> op1 = Optional.of("hello");
//        op = Optional.empty();
        //or:value非空，返回对应的Optional；value为空，返回形参封装的Optional
        Optional<Object> op2 = op.or(() -> op1);
        System.out.println(op2); //Optional[abc]
    }

3.局部变量类型推断升级

@Test

    @Test
    public void test3(){
        //错误的形式: 必须要有类型, 可以加上var
//       Consumer<String> con1 = (@Deprecated t) -> System.out.println(t.toUpperCase());
        //正确的形式:
        //使用var的好处是在使用lambda表达式时给参数加上注解
         Consumer<String> con2 = (@Deprecated var t) -> System.out.println(t.toUpperCase());
    }

4.全新的HTTP客户端API

@Test

    //java11中HttpClient替换原有的HttpURLConnection。
    @Test
    public void test4(){
        try {
            HttpClient client = HttpClient.newHttpClient();
            HttpRequest request = HttpRequest.newBuilder(URI.create("http://127.0.0.1:8080/test/")).build();
            HttpResponse.BodyHandler<String> responseBodyHandler = HttpResponse.BodyHandlers.ofString();
            HttpResponse<String> response = client.send(request, responseBodyHandler);
            String body = response.body();
            System.out.println(body);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Test
    public void test5(){
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder(URI.create("http://127.0.0.1:8080/test/")).build();
        HttpResponse.BodyHandler<String> responseBodyHandler = HttpResponse.BodyHandlers.ofString();
        CompletableFuture<HttpResponse<String>> sendAsync = client.sendAsync(request, responseBodyHandler);
        sendAsync.thenApply(t -> t.body()).thenAccept(System.out::println);
        //HttpResponse<String> response = sendAsync.get();
        //String body = response.body();
        //System.out.println(body);
    }

5.更简化的编译运行程序

6.废弃Nashorn引擎

7.ZGC

8.其它新特性