Java基础之stream流最新版,stream流的基本操作
您好，我是码农飞哥（wei158556），感谢您阅读本文，欢迎一键三连哦。
1. Python基础专栏，基础知识一网打尽，9.9元买不了吃亏，买不了上当。 Python从入门到精通
2. 毕业设计专栏，毕业季咱们不慌忙，几百款毕业设计等你选。
❤️ 3. Python爬虫专栏，系统性的学习爬虫的知识点。9.9元买不了吃亏，买不了上当 。python爬虫入门进阶
❤️ 4. Ceph实战，从原理到实战应有尽有。 Ceph实战
❤️ 5. Java高并发编程入门，打卡学习Java高并发。 Java高并发编程入门
文章目录
-
- 1. Stream流是什么？
- 2. Stream流的执行机制
-
- 生成Stream流
- 执行中间操作
- 执行终止操作
- 3.使用示例（中间操作）
-
- 使用filter方法过滤所有红色苹果
- 使用map方法，将所有苹果重量+10，并且输出对应的苹果的产地
- sorted 排序方法
- flatMap的使用
- 去重，合并，跳过，截取（concat，distinct，skip，limit）
- 终止操作
-
- 聚合（max、min、count）
- 统计（counting、averaging）
- 遍历/匹配（foreach、find、match）
- 归集collect(toList、toSet、toMap)
- 分区、分组（partitioningBy、groupingBy）
- 拼接（joining）
1. Stream流是什么？
JDK1.8 中增加了Stream流，Stream流是一种流式的处理数据的风格，也就是将要处理的数据当作流，在管道中进行传输，并在管道的每个节点对数据进行处理，如过滤、排序、转换等。
先来看一个Stream API的使用示例
List<String> sourceList = Arrays.asList("1", "2", "", "12", "5");
int sum = sourceList.stream()
.filter(StringUtils::isNotBlank)
.mapToInt(Integer::valueOf)
.sum();
System.out.println(sum);
这是个很简单的一个Stream使用例子，我们过滤掉空字符串后，转成int类型并对各个元素进行求和，这里有个三个操作：filter，mapToInt，sum。后面会详细介绍。
2. Stream流的执行机制
Stream内部通过流水线（Pipline）的方式来实现的，基本思路就是顺着流水线尽可能执行更多的操作，从而避免多次迭代。
Steam流操作有三个特性：
- Stream流不存储数据：而是按照特定的规则对数据进行计算，一般会输出结果。
- Stream流不改变源数据：通常情况下会产生一个新的集合或一个值。
- Stream流具有延迟执行特性：只有调用终端操作时，中间操作才会执行。
一个Stream流的使用主要包括三步：
-
生成stream流：这就就是将输入的数据源转成Stream流，数据源主要是Collection
、Array等集合数据。 -
执行中间操作：对数据进行处理
-
执行终止操作：返回最终的结果
生成Stream流
生成Stream流的方式有三种，分别是
List<String> sourceList = Arrays.asList("1", "2", "", "12", "5");
//1.创建stream串行流对象
sourceList.stream();
//2.创建可并行执行的stream流对象
sourceList.parallelStream();
//3.通过给定的一系列元素创建一个新的Stream串行流对象
Stream.of("12", "123", "14", "15");
执行中间操作
执行中间操作只是一种标记，只有结束操作才会触发实际计算。调用中间操作会返回一个新的流。 过滤，排序类的操作都是中间操作，中间操作可以有多个，中间操作分为无状态和有状态。
无状态：指元素的处理不受前面元素的影响。下面的方法均是无状态操作
| 方法 | 说明 |
|---|---|
| map() | 将已有元素转换为另一个对象类型，一对一逻辑 |
| filter() | 按照条件过滤符号要求的元素 |
| peek() | 对Stream流中的每个元素进行逐个遍历处理 |
| unodered() | 返回一个无序的流，对于不关心顺序的数据处理和并行配合使用更佳。 |
| mapToInt() | 将已有元素转成Int类型 |
| mapToLong() | 将已有元素转成Long类型 |
| mapToDouble() | 将已有元素转成Double类型 |
| flatMap() | 将已有元素转换为另外对象类型，一对多逻辑 |
| flatMapToInt() | 将已有元素转成Int类型 |
有状态：有状态的中间操作必须等所有元素处理之后才知道最终结果。比如排序是有状态的操作，在读取所有元素之前并不能确定排序结果。下面方法是有状态操作
| 方法 | 说明 |
|---|---|
| distinct() | 对stream中所有元素进行去重 |
| sorted() | 结果排序 |
| limit(n) | 仅保留集合前面指定个数的元素 |
| skip(n) | 跳过集合前面指定个数的元素 |
| concat() | 将两个流合并起来为1个新的流 |
执行终止操作
终止操作就是指定stream流的输出结果。
| 方法 | 说明 |
|---|---|
| count() | 元素个数 |
| max() | 最大值 |
| min() | 最小值 |
| findFirst() | 第一个符合条件 |
| findAny() | 任意一个符合条件 |
| anyMatch() | 判断是否有符合条件元素 |
| allMatch() | 是否所有元素都符合条件 |
| noneMatch() | 是否所有元素都不符合 |
| collect(Collectors进行指定) | 将流转换成指定类型 |
| toArray() | 转换成数组 |
| iterator() | 转换成iterator()对象 |
| foreach() | 逐个遍历 |
3.使用示例（中间操作）
现在定义一个Apple类，此类有价格price，颜色color，重量weight，产地distinct 四个属性。
private static List<Apple> appleList = new ArrayList<>();
static {
appleList.add(new Apple(10, "red", 12, "安徽"));
appleList.add(new Apple(5, "red", 13, "江西"));
appleList.add(new Apple(5, "blue", 10, "江西"));
appleList.add(new Apple(40, "blue", 9, "河南"));
appleList.add(new Apple(15, "blue", 11, "浙江"));
}
}
public class Apple {
private Integer price;
private String color;
private Integer weight;
private String district;
public Apple(Integer price, String color, Integer weight, String district) {
this.price = price;
this.color = color;
this.weight = weight;
this.district = district;
}
省略getter和setter方法
}
-
使用filter方法过滤所有红色苹果
//1.filter（过滤）筛选出所有颜色是红色的苹果 List<Apple> red = appleList.stream().filter(apple -> apple.getColor().equals("red")).collect(Collectors.toList()); -
使用map方法，将所有苹果重量+10，并且输出对应的苹果的产地
//2.map的使用,将所有苹果重量+10，并且输出对应的苹果的产地 appleList.stream() .map(apple -> { apple.setWeight(apple.getWeight() + 10); return apple; }).map(Apple::getDistrict) .collect(Collectors.toList()); -
sorted 排序方法
- sorted()：自然排序，流中元素需实现Comparable接口
- sorted(Comparator com)：Comparator排序器自定义排序
//3.sorted() 排序
//按价格升序排序 自然排序
System.out.println("按价格升序排序 自然排序");
appleList.stream().sorted(Comparator.comparing(Apple::getPrice))
.peek(System.out::println).collect(Collectors.toList());
//按价格倒序排序 reversed()
System.out.println("按价格倒序排序 reversed()");
appleList.stream().sorted(Comparator.comparing(Apple::getPrice).reversed())
.peek(System.out::println).collect(Collectors.toList());
System.out.println("先按价格再按重量升序排序 thenComparing");
//先按价格再按重量升序排序 thenComparing
appleList.stream().sorted(Comparator.comparing(Apple::getPrice)
.thenComparing(Apple::getWeight))
.peek(System.out::println)
.collect(Collectors.toList());
//自定义排序，先按价格再按重量（降序）
System.out.println("自定义排序，先按价格再按年龄（降序）");
appleList.stream().sorted((p1, p2) -> {
if (p1.getPrice() == p2.getPrice()) {
return p2.getWeight() - p1.getWeight();
} else {
return p2.getPrice() - p1.getPrice();
}
}).peek(System.out::println).collect(Collectors.toList());
-
flatMap的使用
- 当使用map（）操作时，不是返回一个值，而是返回一个集合或者一个数组的时候，这时候就可以使用flatMap解决这个问题。就是扁平化将每个元素映射成另一个Stream对象。
，将两个字符数组合并成一个新的字符数组
List<List<Integer>> lists = new ArrayList<>(); List<Integer> list = new ArrayList<>(); list.add(4444); list.add(33333); list.add(444444); lists.add(list); lists.stream().flatMap(Collection::stream).forEach(System.out::println); List<String> strings = Arrays.asList("m,k,l,a", "1,3,4,5"); List<String> listNew = strings.stream().flatMap(s -> { //将每个元素转成一个新的stream String[] split = s.split(","); Stream<String> s2 = Arrays.stream(split); return s2; }).collect(Collectors.toList()); System.out.println(listNew); -
去重，合并，跳过，截取（concat，distinct，skip，limit）
//创建两个流 Stream<String> stream1 = Stream.of("1", "2", "", "12", "5"); Stream<String> stream2 = Stream.of("3", "4", "5", "6"); //concat：合并两个流 //distinct:去重 List<String> lists1 = Stream.concat(stream1, stream2) .distinct().collect(Collectors.toList()); //limit:限制从流中获取前n个数据 List<String> collect = stream1.limit(3).collect(Collectors.toList()); //skip:跳过前n个数据 List<String> collect1 = stream1.skip(2).collect(Collectors.toList());终止操作
-
聚合（max、min、count）
//取出价格最高的苹果 appleList.stream().max(Comparator.comparing(Apple::getPrice)).get(); //取出价格最低的苹果 appleList.stream().min(Comparator.comparing(Apple::getPrice)).get(); //统计元素个数 appleList.stream().count(); -
统计（counting、averaging）
Collectors提供了一系列用于数据统计的静态方法：
-
计数：counting
-
平均值：averagingInt、averagingLong、averagingDouble
-
最值：maxBy、minBy
-
求和：summingInt、summingLong、summingDouble
//求平均重量 Double avg = appleList.stream().collect(Collectors.averagingDouble(Apple::getWeight)); //求和 Integer sum = appleList.stream().collect(Collectors.summingInt(Apple::getWeight)); //统计 List<Integer> orgNums = Arrays.asList(3, 2, 2, 3, 7, 3, 5); IntSummaryStatistics statistics = orgNums.stream().mapToInt((x) -> x).summaryStatistics(); System.out.println("列表中最大的数：" + statistics.getMax()); System.out.println("列表中最小的数：" + statistics.getMin()); System.out.println("所有数之和：" + statistics.getSum()); System.out.println("平均数：" + statistics.getAverage());
-
-
遍历/匹配（foreach、find、match）
//foreach appleList.stream().filter(apple -> apple.getColor().equals("blue")) .forEach(System.out::println); //匹配第一个颜色是blue的苹果 appleList.stream().filter(apple -> apple.getColor().equals("blue")) .findFirst(); //匹配任意一个颜色是blue的苹果 appleList.stream().filter(apple -> apple.getColor().equals("blue")) .findAny(); //是否包含符合特定条件的元素 appleList.stream().anyMatch(apple -> apple.getColor().equals("blue")); -
归集collect(toList、toSet、toMap)
appleList.stream().map(Apple::getDistrict).collect(Collectors.toList()); //调用toMap方法时，如果key重复可以如下处理 Map<String, Apple> collect = appleList.stream().collect(Collectors.toMap(Apple::getDistrict, a->a,(a1,a2)->a1)); //集合去重 Set<Apple> collect1 = appleList.stream().collect(Collectors.toSet()); -
分区、分组（partitioningBy、groupingBy）
-
分区：将stream按条件分为两个Map，比如水果按照价格是否高于12分出两部分。
-
分组：将集合分为多个Map，比如水果按产地分组。有单级分组和多级分组。
//- 分区：将stream按条件分为两个Map，比如水果按照价格是否高于12分出两部分。 Map<Boolean, List<Apple>> collect = appleList.stream().collect(Collectors.partitioningBy(apple -> apple.getPrice() > 12)); //- 分组：将集合分为多个Map，比如水果按产地分组。有单级分组和多级分组。 Map<String, List<Apple>> collect1 = appleList.stream().collect(Collectors.groupingBy(apple -> apple.getDistrict()));
-
-
拼接（joining）
List<String> list = Arrays.asList("1","2","3","4"); //以空字符拼接，输出 1234 String result= list.stream().collect(Collectors.joining()); //以“-”符号拼接，输出1-2-3-4 String result1= list.stream().collect(Collectors.joining("-")); System.out.println(result1);
-
多个参数
joining(CharSequence delimiter, CharSequence prefix, CharSequence suffix) 方法接受一个字符串序列作为拼接符，并在拼接完成后添加传递的前缀和后缀。假如我们传递的分隔符为 “-”，前缀为 “[” ， 后缀为 “]” 。那么输出结果为 [1-2-3-4]
List<String> arrayList = Arrays.asList("1","2","3","4");
String collect = arrayList.stream().collect(Collectors.joining(",", "[", "]"));