Stream-基础知识

想成为架构师 / 2023-08-08 / 原文

1.是什么

Stream是什么了？

Stream它是java8中的一个新的新的功能点，它能够让代码的编写更加的简洁，它提供了对数据的过滤、排序、去重、映射、聚合、分页、计算等操作，能极大减少我们开发中循环的使用，使我们的日常开发更加便捷和高效。
Stream它能对流数据进行处理，但是并不会改变源数据，通常情况会产生一个新的集合，他本身不对数据进行存储，而是按在要求对数据进行输出。
Stream的操作是具有延迟性，只有当终止操作执行时候，中间的操作才会进行执行。

2.为什么

为什么要使用stream流了？

简化开发：Stream提供一系列对数组的操作，让代码的编写和开发更加简洁。
性能方法：for循环比Stream迭代器性能好，但是Stream不仅支持串行操作，同时还能支持并行操作，在一些比较复杂的操作上面使用并行操作，在性能上面比for循环效率高。

3.怎么用

3.1.Stream执行流程

Stream流执行操作有三部分组成，依次分别是开始操作->中间操作->终止操作。

开始操作：创建Stream流。
中间操作：对源数据进行处理。
终止操作：执行中间操作，并产生结果，随后当前的Stream流将不会被使用、如果要在使用需要重新创建。

3.2.开始操作

3.2.1.stream

创建stream串行流对象

eg:

List<TestEntity> listData = new ArrayList<TestEntity>();
listData.add(new TestEntity(1,"小明",20));
listData.add(new TestEntity(2,"小红",4));
listData.add(new TestEntity(1,"小王",26));
listData.add(new TestEntity(2,"小东",17));
listData.stream().foreach(item->System.out.println(item));

3.2.2.parallelStream

　　创建stream串行流对象

eg:

array.parallel();

3.3.3.Stream.of

　　通过给定一系列元素创建一个新的Stream串行流对象

eg:

Stream<Integer> array = Stream.of(new Integer[]{1,2,3,4,5,6,7,8,9,10});

3.3.中间操作

3.3.1.filter

　　对数据进行过滤。

eg:过滤流中，以“郭”开头的数据。

Stream<String> streamList = Stream.of("黄药师", "冯蘅", "郭靖", "黄蓉", "郭芙", "郭襄", "郭破虏");
List<String> list = streamList.filter(item -> item.startsWith("郭")).collect(Collectors.toList());
System.out.println(list);

//结果：
[郭靖, 郭芙, 郭襄, 郭破虏]

3.3.2.map

将已有的元素数据转换为另外一个对象类型，一对一逻辑

eg:把Integer类型数据转换成Double类型数据

List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
List<Double> listStr = list.stream().map(item->Double.valueOf(item)).collect(Collectors.toList());
System.out.println(listStr);
//结果：
//[1,2,3]

3.3.3.flatMap

将已有的元素数据转换为另外一个对象类型，一对多逻辑

3.3.4.limit

作用：保留集合前指定元素个数/截取前多少个元素

eg:截取集合前三个元素

List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
list.add(6);
List<Integer> collect = list.stream().limit(3).collect(Collectors.toList());
System.out.println(collect);

//结果：
//[1, 2, 3]

3.3.5.skip

跳过集合前多少个元素，保留之后的元素

eg:跳过前面3个元素

List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
list.add(6);
List<Integer> collect1 = list.stream().skip(3).collect(Collectors.toList());
System.out.println(collect1);

//结果：
//[4, 5, 6]

3.3.6.concat

将两个流合并成一个新的流

eg:将两个集合的数据进行合并

List<TestEntity> manList = new ArrayList<TestEntity>();
manList.add(new TestEntity(1,"林和明",20));
manList.add(new TestEntity(2,"林小额红",4));
List<TestEntity> womanList = new ArrayList<TestEntity>();
womanList.add(new TestEntity(1,"林小红",20));
womanList.add(new TestEntity(2,"小丽",4));
List<TestEntity> collect1 = Stream.concat(manList.stream(), womanList.stream()).collect(Collectors.toList());
System.out.println(collect1);

//结果：
//[TestEntity(id=1, name=林和明, age=20), TestEntity(id=2, name=林小额红, age=4), TestEntity(id=1, name=林小红, age=20), TestEntity(id=2, name=小丽, age=4)]

3.3.7.dictinct

过滤重复的数据

eg:过滤两个集合中重复的数据。

List<TestEntity> list1 = new ArrayList<TestEntity>();
list1.add(new TestEntity(1,"小明",20));
list1.add(new TestEntity(2,"小红",4));
list1.add(new TestEntity(1,"小王",26));
list1.add(new TestEntity(1,"小明",20));

List<TestEntity> list2 = new ArrayList<TestEntity>();
list2.add(new TestEntity(1,"小明",20));
list2.add(new TestEntity(2,"小红",4));
list2.add(new TestEntity(1,"小王",26));
list2.add(new TestEntity(1,"小明",20));
list1.addAll(list2);
List<TestEntity> collect2 = list1.stream().distinct().collect(Collectors.toList());
System.out.println(collect2);

//结果：
[TestEntity(id=1, name=小明, age=20), TestEntity(id=2, name=小红, age=4), TestEntity(id=1, name=小王, age=26)]

3.3.8.sorted

排序

eg:升序，降序，默认升序

List<Integer> list = new ArrayList<>();
list.add(1);
list.add(5);
list.add(2);
list.add(4);
list.add(6);
list.add(3);
//正序排序（不屑排序的方式默认就是自然排序，即正序排序）/升序
List<Integer> collect = list.stream().sorted().collect(Collectors.toList());
System.out.println(collect);

//自然排序/升序
List<Integer> collect2 = list.stream().sorted(Comparator.naturalOrder()).collect(Collectors.toList());
System.out.println(collect2);

//反序/倒序
List<Integer> collect3 = list.stream().sorted(Comparator.reverseOrder()).collect(Collectors.toList());
System.out.println(collect3);

//结果：
[1, 2, 3, 4, 5, 6]
[1, 2, 3, 4, 5, 6]
[6, 5, 4, 3, 2, 1]

3.4.终止操作

3.4.1.count

统计元素个数

eg:过滤大于5的数据，并统计个数

Stream<Integer> array = Stream.of(new Integer[]{1,2,3,4,5,6,7,8,9,10});
long count = array.filter(item->item>5).count();
System.out.println("count="+count);

3.4.2.max

计算最大值

eg：从一堆数据中和获取最大值

//方式1
Stream<Integer> array = Stream.of(new Integer[]{1,2,3,4,5,6,7,8,9,10});
Optional<Integer> max1 = array.max((arg0, arg1) -> arg0 - arg1);
System.out.println("max1="+max1.get());
//方式2
array = Stream.of(new Integer[]{1,2,3,4,5,6,7,8,9,10});
Optional<Integer> max2 = array.max(Integer::compareTo);
System.out.println("max2="+max2.get());

3.4.3.min

计算最大值

eg：从一堆数据中和获取最小值

//方式1
Stream<Integer> array = Stream.of(new Integer[]{1,2,3,4,5,6,7,8,9,10});
Optional<Integer> min1 = array.min((arg0, arg1) -> arg0 - arg1);
System.out.println("min1="+min1.get());
//结果：
//10

//方式2
array = Stream.of(new Integer[]{1,2,3,4,5,6,7,8,9,10});
Optional<Integer> min2 = array.min(Integer::compareTo);
System.out.println("min2="+min2.get());
//结果：
//1

3.4.4.findFirst

获取第一个元素

eg:

List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
Optional<Integer> first = list.stream().findFirst();
System.out.println(first.get());
结果：
//1

3.4.5.findAny

匹配任意一个符合条件的元素

List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(1);
list.add(4);
list.add(2);
Integer num2 = list.stream().findAny().get();
System.out.println("num2="+num2);
//结果
//num2=1

3.4.6.anyMatch

判断是否有符合条件的元素

eg:

List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(1);
list.add(4);
list.add(2);
boolean b = list.stream().anyMatch(item -> item == 2);
System.out.println("是否匹配到等于2："+b);
//结果：
//是否匹配到等于2：true

3.4.7.allMatch

判断是否都符合条件元素

eg:

List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(1);
list.add(4);
list.add(2);
boolean b1 = list.stream().allMatch(item -> item >= 1);
System.out.println("是否完全匹配>=1："+b1);
//结果：
//是否完全匹配>=1：true

3.4.8.noneMatch

判断是否都不符合条件元素

eg:

List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(1);
list.add(4);
list.add(2);
boolean b3 = list.stream().noneMatch(item -> item == 0);
System.out.println("是否完全不匹配==0："+b3);
//结果
/是否完全不匹配==0：true

3.4.9.collect

将流转换成指定的数据类型，通过Collectors来指定类型

eg:

list.collect(Collectors.toList())
list.collect(Collectors.toSet())

3.4.10.toArray

转换成数组

eg:

Stream<Integer> arr = Stream.of(new Integer[]{1,2,3,4,5,6,7,8,9,10});
Object[] array = arr.toArray();

3.4.11.iterator

转换成iterator

eg:

Iterator<Integer> iterator = array.iterator();

3.4.12.foreach

逐个遍历

eg：

Stream<Integer> array = Stream.of(new Integer[]{1,2,3,4,5,6,7,8,9,10});
array.forEach(item-> System.out.println(item));