java入门到精通2：java8Stream流各种使用

❤️ 个人主页：程序员句号
🚀 支持水滴：点赞👍 + 收藏⭐ + 留言💬
🌸 订阅专栏：IntelliJ IDEA 教程：从入门到精通

Stream简介

java 8 中的 Stream 是对集合（Collection）对象功能的增强，它专注于对集合对象进行各种非常便利、高效的聚合操作（aggregate operation），或者大批量数据操作 (bulk data operation)。

Stream API 借助于同样新出现的 Lambda 表达式，极大的提高编程效率和程序可读性。同时它提供串行和并行两种模式进行汇聚操作，并发模式能够充分利用多核处理器的优势，使用 fork/join 并行方式来拆分任务和加速处理过程。

简单来说可以帮助我们更好的对集合进行操作，该文章重实战，不论理论

Stream基础使用

各种API的使用。把代码复制过去，改成你的对象和变量就可以得到结果

Stream流的创建

• 用集合创建流

// Arrays.asList java的基本工具类
List<String> list = Arrays.asList("hello","world","stream");
//创建顺序流
Stream<String> stream = list.stream();
//创建并行流
Stream<String> parallelStream = list.parallelStream();

• 数组转Stream流

String[] array = {"h", "e", "l", "l", "o"};
Stream<String> arrayStream = Arrays.stream(array);

• Stream的静态方法：of()、iterate()、generate()
  of方法可以像数组一样赋值
  iterate方法和generate方法用得不多算是比较高级的了。

Stream<Integer> stream1 = Stream.of(1, 2, 3, 4, 5, 6);
 
Stream<Integer> stream2 = Stream.iterate(0, (x) -> x + 2).limit(3);
stream2.forEach(System.out::println);
 
Stream<Double> stream3 = Stream.generate(Math::random).limit(3);
stream3.forEach(System.out::println)
 
 
//输出结果如下：
 
0
2
4
0.9620319103852426
0.8303672905658537
0.09203215202737569

Stream的filter过滤操作

这个filter是我们经常会用到的API，主要用来过滤我们不需要的元素，也可以在里面做赋值操作，但是有坑，所以不建议使用filter来做赋值操作。

例子：

例子1：最简单的，大于2的元素才要
Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6);
List<Integer> sortedValues = stream.filter(f -> f > 2)
									.collect(Collectors.toList()));
输出结果：[3, 4, 5, 6]

例子2：filter其实是要返回true或者false的，上面例子1是简写
所以复杂操作可以在这里面编写，返回true代表这条元素需要，返回false则过滤掉
Stream<Integer> stream1 = Stream.of(1, 2, 3, 4, 5, 6);
stream1.filter(f -> {
            if (f > 2) {
                return true;
            }
            return false;
        }).collect(Collectors.toList());
输出结果：[3, 4, 5, 6]

Stream流的map操作

map主要用于只需要获取集合中的某一个值再组成新的集合，或对集合中的元素进行操作并赋值

@Data
public class User {
Integer id;
String name;
}
// distinct() 这个是过滤重复id
List<Integer> collect =list.stream()
		.map(User::getId)
		.distinct().collect(Collectors.toList());

Stream的peek操作

peek接收一个Consumer，而map接收一个Function（原理）。
Consumer是没有返回值的，它只是对Stream中的元素进行某些操作，但是操作之后的数据并不返回到Stream中，所以Stream中的元素还是原来的元素。
map和peek比较例子

Stream.of("one", "two", "three","four")
		.map(u -> u.toUpperCase()).forEach(System.out::println);
System.out.println("------------");
Stream.of("one", "two", "three","four")
		.peek(u -> u.toUpperCase()).forEach(System.out::println);
输出结果
ONE
TWO
THREE
FOUR
-------
one
two
three
four
可以看到上面map是有变成大写的，而peek没有变化，但是如果集合里是对象的话情况又不一样了！！！
List<User> userList = Stream.of(new User("a"), new User("b"), new User("c"))
			.peek(u -> u.setName("kkk")).collect(Collectors.toList());

List<User> userList2 = Stream.of(new User("a"), new User("b"), new User("c"))
		.map(u -> {
            u.setName("kkk");
            return u;
        }).collect(Collectors.toList());
这两个返回结果是一样的，这个是因为peek并没有改变对象的地址，只是改变了对象里的值，这个涉及到JVM知识了。
不用深究，记住就行！

Stream流的sorted操作

stream流排序，comparator也是一个比较器，可以自定义规则
Stream sorted(Comparator<? super T> comparator);

Stream<Integer> stream = Stream.of(3,1,10,16,8,4,9);
stream.sorted().forEach(System.out::println);	
 
//输出
1
3
4
8
9
10
16

Stream的limit和skip操作

skip：跳过第n个元素，返回其后面的元素流
limit：指定个数的元素流
它们联合操作可以组成分页操作

Stream<Integer> stream = Stream.of(3,1,10,16,8,4,9);
stream.limit(3).forEach(System.out::println);
//输出
3
1
10

Stream<Integer> stream = Stream.of(3,1,10,16,8,4,9);
stream.skip(3).forEach(System.out::println);
//输出
16
8
4
9
组合操作
Stream<Integer> stream = Stream.of(3,1,10,16,8,4,9);
stream.skip(3).limit(3).forEach(System.out::println);
//输出
16
8
4

Stream流的anyMatch操作

Stream 中只要有一个元素符合传入的 predicate，返回 true;也就是说判断集合中只要含某个元素就返回true

Stream<Integer> stream = Stream.of(3,1,10,16,8,4,9);
System.out.println(stream.anyMatch(a -> a.equals(1)));
输出：true
Stream<Integer> stream = Stream.of(3,1,10,16,8,4,9);
System.out.println(stream.anyMatch(a -> a.equals(11)));
输出：false

Stream流的allMatch操作

Stream 中全部元素符合传入的 predicate，返回 true;也就是全部符合。

Stream<Integer> stream = Stream.of(3,1,10,16,8,4,9);
System.out.println(stream.allMatch(a -> a.equals(1)));
输出false
Stream<Integer> stream = Stream.of(1,1);
System.out.println(stream.allMatch(a -> a.equals(1)));
输出true

Stream流的findFirst操作

返回符合要求的第一个元素，但是返回值是Optional

Stream<Integer> stream = Stream.of(3,1,10,16,8,4,9);
System.out.println("result="+stream.findFirst().get());
//输出
result=3

//当然，我们还可以结合filter处理
System.out.println("result="+stream.filter(s-> s > 3).findFirst().get());
//输出
result=10

Stream流的collect操作

collect操作被称为收集器，是一个终端操作,它接收的参数是将流中的元素累积到汇总结果的各种方式

工厂方法	返回类型	作用
toList	List	把流中所有元素收集到List中
toSet	Set	把流中所有元素收集到Set中,删除重复项
toCollection	Collection	把流中所有元素收集到给定的供应源创建的集合中
Counting	Long	计算流中元素个数
SummingInt	Integer	对流中元素的一个整数属性求和
averagingInt	Double	Double
Joining	Double	连接流中每个元素的toString方法生成的字符串
maxBy	Optional	一个包裹了流中按照给定比较器选出的最大元素的optional如果为空返回的是Optional.empty()
minBy	Optional	一个包裹了流中按照给定比较器选出的最小元素的optional如果为空返回的是Optional.empty()
groupingBy	Map<K,List>	根据流中元素的某个值对流中的元素进行分组,并将属性值做为结果map的键

Stream流高级操作

下面的代码只要把集合名和变量名换掉就可以实现功能

去重根据对象的某个属性

方法一

 List<Integer> collect = list.stream()
 		.map(User::getId).distinct()
 		.collect(Collectors.toList());

方法二

List<SubjectiveDto> collect = subjectiveDtos.stream().collect(Collectors.collectingAndThen(
                Collectors.toCollection(() -> new TreeSet<>(
                        Comparator.comparing(
                                SubjectiveDto::getClassifyName))), ArrayList::new));

根据对象的某个属性进行操作

方法一
这个可以求每个分组的个数

 Map<ObjectId, Long> distinctTopic = randomEleList.stream().
 		collect(Collectors.groupingBy(TopicDO::getTopicFatherId, Collectors.counting()));

方法二
某个属性对应整个对象

Map<Long, User> map = userInfoList.stream()
		.collect(Collectors.toMap(User::getUserId, user -> user));

方法三
逗号分隔集合成为String

String str =  labels.stream().map(MediaLabel::getName).collect(Collectors.joining(","));