Stream API
? Java8中有两大最为重要的改变。第一个是Lambda表达:另外一个则是Stream API。
? Stream APl ( java.util.stream)把真正的函数式编程风格引入到Java中。这是目前为止对Java类库最好的补充，因为Stream API可以极大提供Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。
? 使用Stream API 对集合数据进行操作，就类似于使用SQL执行的数据库查询。
? Stream 和Collection集合的区别:Collection是一种静态的内存数据结构，而Stream是有关计算的。前者是主要面向内存，存储在内存中，后者主要是面向CPU，通过CPU 实现计算。
? 集合讲的是数据，Stream讲的是计算
注意:
①Stream自己不会存储元素。
②stream不会改变源对象。相反，他们会返回一个持有结果的新Stream.
③Stream操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。
Stream 的操作三个步骤
-
- 创建Stream
一个数据源(如：集合、数组)，获取一个流，Stream的实例化
-
- 中间操作
一个中间操作链，对数据源的数据进行处理（过滤、映射）
-
- 终止操作(终端操作)
一旦执行终止操作，就执行中间操作链，并产生结果。之后，不会再被使用
Stream的实例化
创建 Stream方式一:
//创建 Stream方式一：通过集合
//EmployeeData里的getEmployees()方法
List<Employee> employees = EmployeeData.getEmployees();
// default Stream<E> stream() : 返回一个顺序流
Stream<Employee> stream = employees.stream();
// default Stream<E> parallelStream() : 返回一个并行流
Stream<Employee> parallelStream = employees.parallelStream();
创建 Stream方式二：
//创建 Stream方式二：通过数组
//调用Arrays类的 static <T> Stream <T> stream(T[] array)：返回一个流
int[] arr = new int[]{1,2,3,4,5};
IntStream stream = Arrays.stream(arr);
创建Stream方式三：
//创建 Stream方式三：通过Stream的of()
Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5);
创建Stream方式四：
//创建 Stream方式四：创建无限流
//迭代
//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的中间操作
- 筛选与切片
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);
//limit(n)———截浙流,使其元素不超过给定数量。
list.stream().limit(3).forEach(System.out::println);
//skip(n) ——跳过元素，返回一个扔掉了前n个元素的流。若流中元素不足n个，则返回一个空流。与limit(n)互补
list.stream().skip(3).forEach(System.out::println);
//distinct0——筛选，通过流所生成元素的hashCode和 equals去除重复元素
list.stream().distinct().forEach(System.out::println);
- 映射
//map(Function f)——接收一个函数，将元素转换成其他形式或提取信息，
// 该函数会被应用到每个元素上，并将其映射成一个新的元素。
List<String> list = Arrays.asList("AA", "BB", "CC", "DD");
list.stream().map(str -> str.toLowerCase()).forEach(System.out::println);
//练习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);
//练习2：
Stream<Stream<Character>> streamStream = list.stream().map(StreamAPITest::fromStringToStream);
streamStream.forEach(s -> {
s.forEach(System.out::println);
});
//flatMap(Function f)—接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流。
Stream<Character> characterStream = list.stream().flatMap(StreamAPITest::fromStringToStream);
characterStream.forEach(System.out::println);
}
public static Stream<Character> fromStringToStream(String str){
ArrayList<Character> list = new ArrayList<>();
for (Character c : str.toCharArray()){
list.add(c);
}
return list.stream();
}
- 排序
//sorted() 自然排序
List<Integer> list = Arrays.asList(89, 58, 485, -11, 0, 7, 552, 11);
list.stream().sorted().forEach(System.out::println);
//报异常，原因：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) -> Integer.compare(e1.getAge(),e2.getAge()))
.forEach(System.out::println);
Stream的终止操作
- 匹配与查找
List<Employee> employees = EmployeeData.getEmployees();
//allMatch(Predicate p)-检查是否匹配所有元素。
// 练习:是否所有的员工的年龄都大于18
boolean allMatch = employees.stream().allMatch(e -> e.getAge() > 18);
System.out.println(allMatch);
//anyMatch(Predicate p)——检查是否至少匹配一个元素。
// 练习:是否存在员工的工资大于10000
boolean match = employees.stream().allMatch(e -> e.getSalary() > 1000);
System.out.println(match);
//noneMatch(Predicate p)—检查是否没有匹配的元素。
// 练习:是否存在员工姓"富
boolean noneMatch = employees.stream().noneMatch(e -> e.getName().startsWith("雷"));
System.out.println(noneMatch);//有返回false
//findFirst—返回第一个元素
Optional<Employee> optional = employees.stream().findFirst();
//findAny———返回当前流中的任意元素
Optional<Employee> optional1 = employees.parallelStream().findAny();
// count—返回流中元素的总个数
long count = employees.stream().filter(e -> e.getSalary() > 5000).count();
System.out.println(count);
//max(Comparator c)—返回流中最大值
// 练习:返回最高的工资:
Stream<Double> salaryStream = employees.stream().map(e -> e.getSalary());
Optional<Double> max = salaryStream.max(Double::compare);
System.out.println(max);
//min(Comparator c—返回流中最小值
// 练习:返向最低工资的员工
Optional<Employee> min = employees.stream().min((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));
//forEach(Consumer c) 内部迭代
employees.stream().forEach(System.out::println);
- 归约
//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);
//reduce(BinaryOperator) 可以将流中元素反复结合起来，得到一个值。返回Optional<T>
//练习2：计算公司所有员工工资的总和
List<Employee> employees = EmployeeData.getEmployees();
Stream<Double> salaryStream = employees.stream().map(Employee::getSalary);
// Optional<Double> sumSalary = salaryStream.reduce(Double::sum);
Optional<Double> sumSalary = salaryStream.reduce((d1,d2) -> d1+d2);
-
收集
? Collector接口中方法的实现决定了如何对流执行收集的操作(如收集到List、Set、Map)。
? 另外，Collectors 实用类提供了很多静态方法，可以方便地创建常见收集器实例，具体方法与实例如下表:
//collect(Collector c)：collect(Collector c)——将流转换为其他形式。接收一个Collector接口的实现，用于给Stream中元素做汇总的方法
//练习1：查找工资大于6000的员工，结果返回为一个list或set
List<Employee> list = EmployeeData.getEmployees();
//有序
List<Employee> employeeList = list.stream().filter(e -> e.getSalary() > 6000).collect(Collectors.toList());
//无序
Set<Employee> employeeSet = list.stream().filter(e -> e.getSalary() > 6000).collect(Collectors.toSet());
employeeList.forEach(System.out::println);
Optional 类
? 到目前为止，臭名昭著的空指针异常是导致Java应用程序失败的最常见原因。以前，为了解决空指针异常，Google公司著名的Guava项目引入了Optional类，Guava通过使用检查空值的方式来防止代码污染，它鼓励程序员写更干净的代码。受到Google Guava的启发，Optional类已经成为Java 8类库的一部分。
? Optional
? Optional类的Javadoc描述如下:这是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true，调用get()方法会返回该对象。
//Optional.of(T t) :创建一个Optional实例，t必须非空;
//of(T t):封装数据t生成Optional对象。要求t非空，否则报错
Girl girl = new Girl();
//报错
//girl = null;
Optional<Girl> optionalGirl = Optional.of(girl);
//get()通常与of()方法发配使用。用于获取内部封装的数据
optionalGirl.get();
// optional.empty :创建的Optional对象内部的value = null
Girl girl = new Girl();
//Optional.ofNullable(T t): t可以为null
//ofNullable(T t):保证 t 可以为null
Optional<Girl> optionalGirl = Optional.ofNullable(girl);
Optional类：为了在程序中避免出现空指针异常而创建的。
常用的方法：ofNullable(T t)
? orElse(T t)
String str = "beijing";
//ofNullable(T t):封装数据t献给Optional内部的value。不要求t非空
Optional<String> op1 = Optional.ofNullable(str);
//orElse(T t1):如果Optional内部的value非空，则返回value值.如果
//value为空，则返回t1
String str2 = op1.orElse("shanghai");
System.out.println(str2);
//使用Optional类的getGirlName();
public String getGirlName2(Boy boy){
Optional<Boy> boyOptional = Optional.ofNullable(boy);
//orElse(T t1):如果当前的Optional内部封装的t是非空的，则返回内部的t
//如果内部的t是空的，则返回orElse()方法中的参数t1
//此时的boy1一定非空
Boy boy1 = boyOptional.orElse(new Boy(new Girl("iu")));
Girl girl = boy1.getGirl();
Optional<Girl> girlOptional = Optional.ofNullable(girl);
//此时的girl1一定非空
Girl girl1 = girlOptional.orElse(new Girl("李知恩"));
return girl1.getName();