Java8新特性

1. Lambda表达式

使用方法举例

例子1

	public void test1() {
		//常规写法
		Runnable r1 = new Runnable() {			
			@Override
			public void run() {
				// TODO Auto-generated method stub
				System.out.println("我爱北京天安门");
			}
		};
		r1.run();	
		
		//Lambda表达式写法
		Runnable r2 = () -> System.out.println("我爱北京故宫");
		r2.run();
	}

举例2

	public void test2() {
		//常规写法
		Comparator<Integer> com1 = new Comparator<Integer>() {
			
			@Override
			public int compare(Integer o1, Integer o2) {
				// TODO Auto-generated method stub
				return Integer.compare(o1, o2);
			}
		 
		};
		int compare1 = com1.compare(12, 21);
		System.out.println(compare1);
		
		//Lambda表达式写法
		Comparator<Integer> com2 = (o1, o2) -> Integer.compare(o1, o2);
		int compare2 = com2.compare(12, 21);
		System.out.println(compare2);
		
		//方法引用
		Comparator<Integer> com3 = Integer :: compare;
		int compare3 = com3.compare(12, 21);
		System.out.println(compare3);
	}

Lambda表达式的使用

package org.example.lambda;

import java.util.Comparator;
import java.util.function.Consumer;

/**
 * Lambda表达式的使用
 * 
 * 1. 举例： (o1, o2) -> Integer.compare(o1, o2);
 * 2. 格式：
 * ->: lambda操作符 或箭头操作符
 * 操作符左边：lambda形参列表 （其实就是接口中的抽象方法的形参列表）
 * 操作符右边：lambda体 （其实就是重写的抽象方法的方法体）
 *
 *3.lambda表达式的使用：（分6种情况）
 *->左边：lambda形参列表的参数类型可以省略（类型推断）
 *如果形参列表只有一个形参，()可省略
 *->右边：lambda体应该使用一堆{}包裹，如果lambda体只有一条语句（可能时return语句），
 *那么{}可省，return也可省。（当{}省略时，return必须省）
 *
 *
 *4.lambda表达式的本质：作为函数式接口的实例
 *
 *5.如果一个接口中，只声明了一个抽象方法，这么这个接口叫做函数式接口。
 *函数式接口会用注释 @FuctionalInterface 来修饰
 */
public class LambdaTest2 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		LambdaTest2 l2 = new LambdaTest2();
		l2.test1();

	}
	
	public void test1() {
		//语法格式一：无参，无返回值
		
		Runnable r1 = new Runnable() {
			
			@Override
			public void run() {
				// TODO Auto-generated method stub
				System.out.println("我爱北京天安门");
			}
		};
		r1.run();
		
		Runnable r2 = () -> {
			System.out.println("我爱北京天安门");
		};
		r2.run();
		
		//语法格式二：需要一个参数，但是没有返回值。
		Consumer<String> con1 = new Consumer<String>() {

			@Override
			public void accept(String t) {
				// TODO Auto-generated method stub
				System.out.println(t);
			}
			
		}; 
		con1.accept("consumer test");
		
		Consumer<String> con2 = (String s) -> {
			System.out.println(s);
		};
		con2.accept("consumer test2");
		
		//语法格式三：数据类型可以省略，因为可由 编译器推断得出，称为“类型推断”。
		Consumer<String> con3 = (s) -> {
			System.out.println(s);
		};
		con3.accept("consumer test3");
		
		//语法格式四：若只需要一个参数时，参数的小括号可以省略。
		Consumer<String> con4 = s -> {
			System.out.println(s);
		};
		con4.accept("consumer test4");
		
		//语法格式五：需要两个或两个以上的参数，多条执行语句，并且可以有返回值
		Comparator<Integer> com1 = new Comparator<Integer>() {

			@Override
			public int compare(Integer o1, Integer o2) {
				// TODO Auto-generated method stub
				return o1.compareTo(o2);
			}
		};
		System.out.println(com1.compare(12, 21));
		
		Comparator<Integer> com2 = (o1, o2) -> {
			return o1.compareTo(o2);
		};
		
		System.out.println(com2.compare(12, 21));
		
		//语法格式六：当lambda体只有一条语句时，return与大括号都可以省略
		
		Comparator<Integer> com3 = (o1, o2) -> o1.compareTo(o2);
		System.out.println(com3.compare(12, 21));
		
	}

}

2. 函数式（Functional）接口

3. 方法引用与构造器引用

3.1 方法引用

代码举例：

package org.example;

import org.junit.Test;

import java.io.PrintStream;
import java.util.Comparator;
import java.util.function.BiPredicate;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;

/**
 * 方法引用的使用
 * <p>
 * 1. 使用情境：当要传递给lambda体的操作，已经有实现的方法了，可以使用方法引用。
 * <p>
 * 2. 方法引用本质上就是lambda表达式，而lambda表达式作为函数式接口的实例。所以，方法引用也是函数式接口的实例。
 * <p>
 * 3. 使用格式：类（或对象） :: 方法名
 * <p>
 * 4. 具体分为如下的三种情况：
 * 1） 对象 :: 非静态方法
 * 2） 类 :: 静态方法
 * 3） 类 :: 非静态方法
 * <p>
 * 5. 方法引用使用的要求：
 * 接口中的抽象方法的形参列表和返回值类型要与方法引用的方法的形参列表和返回值类型相同。（针对情况1和情况2）
 *
 * @author AmorFati
 * @create 2020/12/18 16:22
 */
public class MethodRefTest {

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

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


    //Supplier中的 T get()
    //Employee中的String getName()
    @Test
    public void test2() {
        //lambda表达式
        Employee emp = new Employee(1001, "Tom", 23, 5600);
        Supplier<String> sup1 = () -> emp.getName();
        System.out.println(sup1.get());

        //方法引用
        Supplier<String> sup2 = emp::getName;
        System.out.println(sup2.get());
    }

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

        //方法引用
        Comparator<Integer> com2 = Integer::compare;
        System.out.println(com2.compare(12, 21));
    }


    //Function中的 R apply(T t)
    //Math中的long round(Double d)
    @Test
    public void test4() {
        //lambda表达式
        Function<Double, Long> fun1 = (t) -> Math.round(t);
        System.out.println(fun1.apply(24.55));

        //方法引用
        Function<Double, Long> fun2 = Math::round;
        System.out.println(fun2.apply(24.55));

    }

    //情况3： 类 :: 实例方法（非静态方法）
    //Comparator中的int compare(T t1, T t2)
    //String中的int t1.compareTo(t2)
    @Test
    public void test5() {
        //lambda表达式
        Comparator<Integer> com1 = (s1, s2) -> s1.compareTo(s2);
        System.out.println(com1.compare(12, 21));

        //方法引用
        Comparator<Integer> com2 = Integer::compareTo;
        System.out.println(com2.compare(12, 21));
    }

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

        //方法引用
        BiPredicate<String, String> pre2 = String::equals;
        System.out.println(pre2.test("ab", "ab"));

    }

    //Function中的R apply(T t)
    //Employee中的String getName()
    @Test
    public void test7() {
        Function<Employee, String> fun1 = (e1) -> e1.getName();
        System.out.println(fun1.apply(new Employee(1001, "Tom", 33, 5433)));
        
        Function<Employee, String> fun2 = Employee::getName;
        System.out.println(fun2.apply(new Employee(1001, "Tom", 33, 5433)));
    }
}

Employee类代码

package org.example;

/**
 * @author AmorFati
 * @create 2020/12/18 16:23
 */
public class Employee {
    private int id;
    private String name;
    private int age;
    private double salary;

    public Employee(int id, String name, int age, double salary) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.salary = 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;
    }

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

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

3.2 构造器引用与数组引用

package org.example;

import org.junit.Test;

import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.Supplier;

/**
 * 一、构造器引用
 * <p>和方法引用类似，函数式接口的抽象方法的形参和构造器形参的列表一直。
 * 抽象方法的返回值类型即为构造器所属的类的抽象方法。
 * <p>
 * <p>
 * 二、数组引用
 * 大家可以把数组引用看做事一个特殊的类，则写法与构造器引用的写法一致
 *
 * @author AmorFati
 * @create 2020/12/21 10:49
 */
public class ConstructorRefTest {
    //构造器引用
    //Supplier中的 T get()
    @Test
    public void test1() {
        //常规表达
        Supplier<Employee> sup1 = new Supplier<Employee>() {
            @Override
            public Employee get() {
                return new Employee();
            }
        };

        //lambda表达式
        Supplier<Employee> sup2 = () -> new Employee();

        //构造器引用
        Supplier<Employee> sup3 = Employee::new;
    }

    //Function中的 R apply(T t)
    @Test
    public void test2() {
        //lambda表达式
        Function<Integer, Employee> fun1 = (id) -> new Employee(id);
        System.out.println(fun1.apply(1001));

        //构造器引用
        Function<Integer, Employee> fun2 = Employee::new;
        System.out.println(fun2.apply(1001));

    }

    //BiFunction中的R apply(T t, U u)
    @Test
    public void test3() {
        BiFunction<Integer, String, Employee> bi1 = (id, name) -> new Employee(id, name);
        System.out.println(bi1.apply(1002, "Tom"));

        BiFunction<Integer, String, Employee> bi2 = Employee::new;
        System.out.println(bi2.apply(1002, "Tom"));
    }

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

        Function<Integer, String[]> fun2 = String[]::new;
        System.out.println(fun2.apply(10));

    }

}

4. 强大的Stream API

3.2.1 创建Stream

package org.example;

import org.junit.Test;

import java.util.Arrays;
import java.util.List;
import java.util.stream.IntStream;
import java.util.stream.Stream;

/**
 * 1. stream关注的是对数据的计算，与CPU打交道
 * 集合关注的是数据的存储，与内存打交道
 * 2.
 * ① stream不会自己存储元素。
 * ② stream不会该表原对象，相反，他们会返回一个持有结果的新stream
 * ③ stream操作是延迟的，这意味着他们会等到需要结果的时候才会执行。
 * <p>
 * 3. stream执行流程
 * ① stream的实例化
 * ② 一系列的中间操作（过滤，映射）
 * ③ 终止操作
 * <p>
 * 4.说明
 * ① 一个中间操作链，对数据源的数据进行处理
 * ② 一旦执行终止操作，就执行中间操作链，并产生结果。之后，不会再被使用。
 * <p>
 * 测试Stream的实例化
 *
 * @author AmorFati
 * @create 2020/12/21 11:31
 */
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[] array):返回一个流
        IntStream stream = Arrays.stream(arr);
        Employee e1 = new Employee(1001, "Tom");
        Employee e2 = new Employee(1002, "Jerry");
        Employee[] employees = new Employee[]{e1, e2};
        Stream<Employee> employeeStream = Arrays.stream(employees);

    }

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

    @Test
    public void test3() {
        Stream<Integer> integerStream = 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);
        
    }

}

3.2.2 中间操作

package org.example;

import org.junit.Test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;

/**
 * 测试Stream的中间操作
 *
 * @author AmorFati
 * @create 2020/12/21 14:43
 */
public class StreamAPITest2 {

    //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);
        System.out.println();

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

        //skip(n)--跳过元素，返回一个扔掉前n个元素的流，若流中元素不足n个，则返回一个空流，与limit(n)互补
        list.stream().skip(3).forEach(System.out::println);
        System.out.println();

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

        list.stream().distinct().forEach(System.out::println);
    }

    //2. 映射
    @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);

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

        //mapToDouble(ToDoubleFunction f) 接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的DoubleStream
        //mapToInt(ToIntFunction f) 接收一个函数作为参数， 该函数会被应用到每个元素上，产生一个新的IntStream
        //mapToLong(ToLongFunction f) 接收一个函数作为参数， 该函数会被应用到每个元素上，产生一个新的LongStream

        //flatMap(Function f) 接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流
        list.stream().flatMap(StreamAPITest2::fromString).forEach(System.out::println);

    }

    //将字符串中的多个字符构成的集合转换为对应的Stream的实例
    public static Stream<Character> fromString(String str) {
        List<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);

        //sorted(Comparator com) 定制排序
        List<Employee> employees = EmployeeData.getEmployees();
        employees.stream().sorted(
                (e1, e2)->Integer.compare(e1.getAge(), e2.getAge())
        ).forEach(System.out::println);
    }

}

3.2.3 终止操作

package org.example;

import org.junit.Test;

import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * 测试Stream的终止操作
 *
 * @author AmorFati
 * @create 2020/12/21 16:31
 */
public class StreamAPITest3 {

    //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);
        System.out.println();

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

        //noneMatch(Predicate p) 检查是否没有匹配的元素
        //练习：是否员工的姓”雷“
        boolean noneMatch = employees.stream().noneMatch(e -> e.getName().startsWith("雷"));
        System.out.println(noneMatch);
        System.out.println();

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

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

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

        //max(Comparator c) 返回流中最大值
        //练习返回最高工资
        Stream<Double> salary = employees.stream().map(e -> e.getSalary());
        Optional<Double> max = salary.max((Double::compare));
        System.out.println(max);


        //min(Comparator c) 返回流中最小值
        //练习返回最低工资的员工：
        Optional<Employee> min = employees.stream().min((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));
        System.out.println(min);

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

    //2. 归约
    @Test
    public void test2() {
        //reduce(T identity, BinaryOperator b) 可以将流中元素反复结合起来，得到一个值，返回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);

        //reduce(BinaryOperator b) 可以将流中元素反复结合起来，得到一个值。返回Optional<T>.
        //练习2：计算公司所有员工工资总和
        //方法一
        List<Employee> employees = EmployeeData.getEmployees();
        Optional<Double> salaries = employees.stream().map(e -> e.getSalary()).reduce(Double::sum);
        System.out.println(salaries);
        //方法二
        Optional<Double> salaries2 = employees.stream().map(Employee::getSalary).reduce((d1, d2) -> d1 + d2);
        System.out.println(salaries2);
    }

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

        collect.forEach(System.out::println);
        
    }

}

5. Optional类

package org.example;

import org.junit.Test;

import java.util.Optional;

/**
 * Optional类：为了在程序中比卖你出现空指针异常而创建的。
 *
 * @author AmorFati
 * @create 2020/12/21 20:23
 */
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();
        Optional<Girl> optionalGirl = Optional.of(girl);
    }

    @Test
    public void test2() {
        Girl girl = null;
        //ofNullable(T t): t可以为null
        Optional<Girl> optionalGirl = Optional.ofNullable(girl);
        System.out.println(optionalGirl);
        //orElse(T t):如果当前的Optional内部封装的t是非空的，则返回内部的t,
        //如果内部的t是空的，则返回orElse()方法中的参数t1
        Girl girl1 = optionalGirl.orElse(new Girl("赵丽颖"));
        System.out.println(girl1);
    }

    @Test
    public void test3() {
        Optional<Object> empty = Optional.empty();
    }

    @Test
    public void test4() {
        Boy boy = new Boy();
        boy = null;
        String girlName = getGirlName(boy);//会报空指针异常
        System.out.println(girlName);
    }

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

    //优化以后的getGirlName();
    public String getGirlName1(Boy boy) {
        if (boy != null) {
            Girl girl = boy.getGirl();
            if (girl != null) {
                return girl.getName();
            }
        }
        return null;
    }

    //使用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();
    }
}