Predicate接口（断言）Function接口（函数）Supplier接口（供应商）Consumer接口（消费者）Comparator接口（比较）Optional接口（ 可选）

Optional

// 获取学生姓名
private String getInfoName1(Student student){
  return student.getInfo().getName();
}
// 为了避免空指针异常，Java 8 之前修改为
private String getInfoName2(Student student){
  if(student!=null){
  Info info = student.getInfo();
  if(info!=null){
   String name = info.getName();
   return name;
  }
 }  
 return null;
}
// Java 8 中使用Optional
private String getInfoName3(Student student){
  return Optional.ofNullable(student).map(Student::getInfo).map(Info::getName)
  .orElse("DEFAULT_NAME"); // DEFAULT_NAME 没有默认值，写成null即可
}

Supplier

Supplier 接口可以理解为一个容器，用于装数据的，也可以理解为用来创建对象的，

Supplier<String> supplier = new Supplier() {
  @Override
  public String get() {
   return LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyyMMddHHmmssSSS"))
	 + new Random().nextInt(10);
  }
};
Student student = new Student();
String id = Optional.ofNullable(student).map(Student::getId)
  .orElseGet(supplier); // 获取student的id，如果为null，则按时间戳随机生成一个ID
System.out.println(id);

Consumer（提取forEach）

在进行forEach的时候，forEach所需传入的参数就是一个Consumer,如果这个forEach的内部方法需要多处使用，提取成一个Consumer即可。

Consumer<Integer> consumer = (x) -> {
  int number = x*2;
  System.out.print(number);
};
Stream.of(1,2,3,4,5).forEach(consumer); // 打印246810
Stream.of(6,7,8,9,10).forEach(consumer); // 打印1214161820

Comparator

// 数字直接排序
List<Integer> list = Arrays.asList(1, 4, 2, 6, 2, 8);
list.sort(Comparator.naturalOrder()); // 升序
list.sort(Comparator.reverseOrder()); // 降序
// 对象按属性排序
Supplier<Student> supplier = () -> {
  Student student = new Student();
  student.setAge(new Random().nextInt(20));
  student.setPrice(new Random().nextInt(100));
 return student;
};
List<Student> students = Stream.generate(supplier).limit(10).collect(Collectors.toList());
students.sort(Comparator.comparingInt(Student::getAge).reversed()
  .thenComparingInt(Student::getPrice)); // 先以年龄降序，再以价格升序
System.out.println(students);

Predicate（提取filter）

Predicate就是一个类似于 bool 类型的判断的接口

Predicate<Integer> predicate = (t) -> t > 10;
Stream<Integer> stream = Stream.of(1, 23, 3, 4, 5, 56, 6, 6);
List<Integer> list = stream.filter(predicate).collect(Collectors.toList());
list.forEach(System.out::println); // 输出10以上的数字

Function(提取map)

function作用就是转换作用，将输入数据转换成另一种形式的输出数据

Function<String, Integer> function = new Function<String, Integer>() {
  @Override
  public Integer apply(String s) {
  return s.length();//获取每个字符串的长度，并且返回
  }
};
Stream<String> stream = Stream.of("aaa", "bbbbb", "ccccccv");
Stream<Integer> stream1 = stream.map(function);
stream1.forEach(System.out::println); // 输出字符串的长度