Java8 Stream笔记

什么是Stream？

Java 8 中的 Stream 是对数组和集合（Collection）对象功能的增强，
专注于对集合对象进行各种非常便利、高效的聚合操作，或者大批量数据操作。

Stream的特性？

➢ 不存储数据。Stream 是基于数据源的对象，它本身不存储数据元素，而是通过管道将数据源的元素传递给操作。

➢ 函数式编程。Stream 的操作不会修改数据源，例如filter不会将数据源中的数据删除。

➢ 延迟操作。Stream 的很多操作如filter，map等中间操作是延迟执行的，只有到终点操作才会将操作顺序执行。

➢ 可以解绑。对于无限数量的流，有些操作是可以在有限的时间完成的，比如limit(n) 或 findFirst()，
这些操作可是实现”短路”(Short-circuiting)，访问到有限的元素后就可以返回。

➢ 纯消费。Stream 的元素只能访问一次，类似Iterator，操作没有回头路，
如果新访问流的元素，得重新生成一个新的流。

Stream的类型

➢ 串行流Collection.stream() 创建的串行流IntStream.range(int, int) 创建的串行流sequential() 方法可以将并行流转换成串行流。➢ 并行流Collection.parallelStream() 为集合创建并行流parallel() 方法可以将串行流转换成并行流

Stream的操作类型

流的操作类型分为：中间操作、终止操作、短路操作

➢ 中间操作

一个流可以后面跟随零个或多个中间(intermediate) 操作。
其目的主要是打开流，做出某种程度的数据映射/过滤，然后返回一个新的流，交给下一个操作使用。
这类操作都是惰性化的（lazy），就是说，仅仅调用到这类方法，并没有真正开始流的遍历。

   ○ map (mapToInt, flatMap 等) 映射，输入一个T类型的元素，返回一个R类型的元素；
       如果返回的类型是也是Stream类型，会直接把Stream放入原Stream中
   ○ filter 筛选，匹配符合规则的元素
   ○ distinct 筛选，通过hashcode 和 equals去除重复元素
   ○ sorted 排序，按自然顺序排序，产生一个新流
   ○ peek 用于查看每个元素，但不改变流的操作的方法。
       它接收一个Consumer类型的参数，该参数用于针对每个元素执行副作用操作。
       该方法返回一个与原始流相同的新流，因此可以进行链式操作。
   ○ limit 筛选，取不超过给定数量的元素
   ○ skip 筛选，跳过前n个元素，若流中元素不足n个则返回空流
   ○ parallel 将串行流转换成并行流
   ○ sequential 将并行流转换成串行流
   ○ unordered 除去排序约束

➢ 终止操作

一个流只能有一个终止(terminal) 操作，当这个操作执行后，流就被使用“光”了，无法再被操作。
所以这必定是流的最后一个操作。Terminal 操作的执行，才会真正开始流的遍历，
并且会生成一个结果，或者一个副作用(side effect)。

   ○ forEach 遍历并逐个消费元素
   ○ forEachOrdered 当多个线程并行处理时，按source原有的顺序输出
   ○ toArray 把流转为数组
   ○ reduce 规约，将流中元素按照指定规则合并成一个元素
   ○ collect 收集，将流中元素收集到一个集合中
   ○ min 返回流中最小的元素
   ○ max 返回流中最大的元素
   ○ count 统计流中元素个数
   ○ anyMatch 流中元素是否有一个匹配规则p,有匹配返回true，无则false
   ○ allMatch 流中元素是否全部匹配规则p,全部匹配返回true，否则false
   ○ noneMatch 流中元素是否全部不匹配规则p
   ○ findFirst 取流中第一个元素
   ○ findAny 从流中任取一个元素
   ○ iterator 将流转换为迭代器

➢ 短路操作

对于一个中间(intermediate) 操作，如果它接受的是一个无限流，它可以返回一个有限的新 Stream。
对于一个终止(terminal) 操作，如果它接受的是一个无限流，但能在有限的时间计算出结果。

如何创建Stream

Stream可以通过集合、数组或Stream自带的静态方法 of()、iterate()、generate() 来创建。

➢ 通过集合创建流


List<String> list = Arrays.asList("a", "b", "c");// 创建顺序流
Stream<String> stream = list.stream();// 创建并行流
Stream<String> parallelStream = list.parallelStream();

➢ 通过数组创建流

int[] array={1,3,5,6,8};IntStream stream = Arrays.stream(array);

➢ 通过Stream自带的静态方法 of()、iterate()、generate() 创建流

// Stream.of 为给定元素创建顺序流
Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6);// Stream.iterate 第一个参数是新流中的初始元素，
// 然后使用该数据做第二个参数也就是UnaryOperator函数的入参去计算第二元素，
// 然后把新计算得到的第二个元素作为入参继续计算第三个元素，以此循环可以制造无限个元素，
// 在实际使用中一般使用limit（n）方法去获取包含n个的流。
Stream<Integer> stream2 = Stream.iterate(0, (x) -> x + 3).limit(4);
stream2.forEach(System.out::println);// Stream.generate 方法主要用于生成一个无限连续的无序流，流中的元素由用户定义的supplier函数生成。
Stream<Double> stream3 = Stream.generate(Math::random).limit(3);
stream3.forEach(System.out::println);

常用Api实例

➢ map

映射，输入一个T类型的元素，返回一个R类型的元素；map(Function<? super T, ? extends R> mapper);// 映射到其他对象
List<User> userList = list.stream().map(iteam -> {User user = new User();user.setSkuId(...)return user;}).collect(Collectors.toList());// 取对象list中的一个属性为新的list
List<Integer> list2 = userList.stream().map(User::getAge).collect(Collectors.toList());// 将字符串list中的字符串全大写
List<String> collect = strs.stream().map(String::toUpperCase).collect(Collectors.toList());// 将字符串list中的字符长度
List<Integer> lengths = strs.stream().map(String::length).collect(Collectors.toList());

➢ reduce

归约是将集合中的所有元素经过指定运算，折叠成一个元素输出，
如：求最值、平均数等，这些操作都是将一个集合的元素折叠成一个元素输出。reduce((T, T) -> T);
reduce(T, (T, T) -> T);// 有初始值，计算年龄总和，两种写法都可:
int age = list.stream().reduce(0, (user1, user2) -> user1.getAge() + user2.getAge());
int sum = list.stream().map(User::getAge).reduce(0, (a, b) -> a + b);
int sum = list.stream().map(User::getAge).reduce(0, Integer::sum);// 无初始值，此时返回的是Optional 类型
Optional sum = list.stream().map(User::getAge).reduce(Integer::sum);

➢ collect

收集Stream流到集合和指定集和中

//1.收集数据到list集合中
stream.collect(Collectors.toList())//2.收集数据到set集合中
stream.collect(Collectors.toSet())//3.收集数据到指定的集合中
stream.collect(Collectors.toCollection(HashSet::new))

数据聚合操作

//最大值
Collectors.maxBy();//最小值
Collectors.minBy();//总和
Collectors.summingInt();
Collectors.summingDouble();
Collectors.summingLong();//平均值
Collectors.averagingInt();
Collectors.averagingDouble();
Collectors.averagingLong();//总个数
Collectors.counting();//或者使用lambda表达式取最大值
Optional<User> maxCollect2 = userList.stream().collect(Collectors.maxBy((s1, s2) -> s1.getJgid() - s2.getJgid()));//或者使用lambda表达式取最小值
Optional<User> minCollect = userList.stream().collect(Collectors.minBy((s1, s2) -> s1.getJgid() - s2.getJgid()));//或者使用lambda表达式取jgid总和
Integer sumCollect2 = userList.stream().collect(Collectors.summingInt(User::getJgid));//或者使用lambda表达式取jgid平均值
Double avgScore2 = userList.stream().collect(Collectors.averagingInt(User::getJgid));//(聚合)统计数量
Long count = userList.stream().collect(Collectors.counting());

分组操作

//接收一个 Function 参数
groupingBy(Function<? super T, ? extends K> classifier)//或者使用lambda表达式
Map<Integer, List<User>> jgidMap2 = userList.stream().collect(Collectors.groupingBy(User::getJgid));//jgid奇数一组偶数一组
Map<String, List<User>> jgidMap3 = userList.stream().collect(Collectors.groupingBy(s -> {if (s.getJgid() % 2 == 0) {return "jgid为偶数";} else {return "jgid为奇数";}
}));//根据jgid分组，且规定为最大一组(规约：reducing)
Map<Integer, Optional<User>> jgidMap4 = userList.stream().collect(Collectors.groupingBy(User::getJgid,Collectors.reducing(BinaryOperator.maxBy(Comparator.comparing(User::getJgid)))));

多级分组操作

//接收两个参数: 1.Function 参数  2.Collector多级分组
groupingBy(Function<? super T, ? extends K> classifier,Collector<? super T, A, D> downstream) Map<Integer, Map<String, List<User>>> collect = userList.stream().collect(Collectors.groupingBy(User::getJgid,Collectors.groupingBy(user -> {if (user.getId() % 2 == 0) {return "id是偶数";} else {return "id是奇数";}})));

分区操作

根据返回值是否为 true，把集合分为两个列表，一个 true 列表，一个 false 列表。
和分组的区别在于分组可以有多个组，分区只会有两个区( true 和 false)//1.一个参数
partitioningBy(Predicate<? super T> predicate)//2.两个参数(多级分区)
partitioningBy(Predicate<? super T> predicate, Collector<? super T, A, D> downstream)Map<Boolean, List<User>> collect = userList.stream().collect(Collectors.partitioningBy(s -> {return s.getJgid() % 2 == 0;}));stream.collect(Collectors.partitioningBy(s -> s % 2 == 0));

拼接操作

//无参数--等价于 joining("");
joining()//一个参数，拼接符
joining(CharSequence delimiter)//三个参数(拼接符+前缀+后缀)
joining(CharSequence delimiter, CharSequence prefix,CharSequence suffix)String collect1 = userList.stream().map(User::getName).collect(Collectors.joining());
String collect2 = userList.stream().map(User::getName).collect(Collectors.joining(","));
String collect3 = userList.stream().map(User::getName).collect(Collectors.joining(",", "开始<", ">结束"));

toArray

toArray();
toArray(IntFunction<A[]> generator);//1.使用无参,收集到数组,返回值为 Object[](Object类型将不好操作)
Object[] objects = userList.stream().toArray();//2.使用有参,可以指定将数据收集到指定类型数组,方便后续对数组的操作
User[] user = userList.stream().toArray(User[]::new);