【笔记】Java的Stream

发表于 更新于 分类于 阅读次数：

前言

Java的Stream学习笔记

获取Stream对象

通过List对象获取Stream对象

1
2
3
List<Object> list = new ArrayList<>();

Stream<Object> stream = list.stream();

通过Random对象获取Stream对象

  • 通过Random对象获取的Stream对象中元素数量是无穷尽的

boxed()：将流中所有基本类型转换为包装类型

1
2
3
Random random = new Random();

Stream<Object> stream = random.ints().boxed();

通过String对象获取Stream对象

  • 通过String对象获取的Stream对象中元素为字符串中每个字符
1
2
3
String str = new String();

Stream<Object> stream = str.chars();

流式处理数据

  • Java通过Stream流式处理数据时，每次数据完成数据都会返回处理后的Stream数据，可以链式调用，链式调用时采用流水线编排数据处理操作，比传统循环遍历处理数据更高效

过滤

  • Lambda表达式返回true的数据会被保留，返回false的数据会被移除
1
2
3
stream = stream.filter((item) -> {
    return true;
});

映射

  • 将原始数据映射为新数据，新数据数据类型可以改变
1
2
3
stream = stream.map((item) -> {
    return item;
});

扁平化元素

  • Stream.of()中传递扁平化后的单个元素
1
2
3
stream = stream.flatMap((item) -> {
    return Stream.of(<item_1>, <item_2>);
});

去重

1
stream = stream.distinct();

排序

正序排序

1
stream = stream.sorted();

倒序排序

1
stream = stream.sorted(Comparator.reverseOrder());

指定排序规则

1
2
3
stream = stream.sorted((item1, item2) -> {
    return item1.compareTo(item2);
})

消费数据

  • 数据消费后不会丢失
1
2
3
stream = stream.peek((item) -> {
    System.out.println(item);
});

限制数量

1
stream = stream.limit(<num>);

跳过数量

1
stream = stream.skip(<num>);

收尾操作

将Stream中的所有元素转换为List集合

1
List<Object> list = stream.collect(Collectors.toList());

将Stream中的所有元素转换为Set集合

1
List<Object> list = stream.collect(Collectors.toCollection(HashSet::new));

将Stream中的所有元素转换为Map集合

  • 通过分类器将Stream对象转换为Map集合
  • Lambda表达式返回当前元素把什么作为转换后的Map的键
1
2
3
Map<Object, Object> map = stream.collect(Collectors.groupingBy((item) -> {
    return item.hashCode();
}));

将Stream中的所有元素转换为字符串

  • 通过字符串拼接将所有元素拼接为一个字符串
1
String str = stream.collect(Collectors.joining());
  • 指定字符串拼接时的连接符、前缀、后缀
1
String str = stream.collect(Collectors.joining(",", "[", "]"));

将Stream中的所有元素汇总为一个值

  • 遍历第1和第2元素时，item1为第1个元素，item2为第2个元素
  • 之后遍历第三个元素时，item1为前一次遍历的结果，item2为当前元素
1
2
3
Optional<Object> result = stream.collect(Collectors.reducing((item1, item2) -> {
    return item1 + item2;
}));

求平均值

  • Lambda表达式返回当前元素把什么作为求值的数据
1
2
3
Optional<Double> result = stream.collect(Collectors.averagingDouble((item) -> {
    return 0;
}));

求最大值

1
Optional<Object> result = stream.max(Comparator.naturalOrder());
1
2
3
Optional<Object> result = stream.max((o1, o2) -> {
    return o1.compareTo(o2);
});

求最小值

1
Optional<Object> result = stream.min(Comparator.naturalOrder());
1
2
3
Optional<Object> result = stream.min((o1, o2) -> {
    return o1.compareTo(o2);
});

获取元素总数

1
long result = stream.count();

遍历Stream中的所有元素

1
2
3
stream.forEach((item) -> {
    System.out.println(item);
});

统计数据

将Stream对象转换为IntSummaryStatistics对象

  • 先通过mapToInt()方法将Stream对象转换为IntStream对象，再通过summaryStatistics()方法将IntStream对象转换为IntSummaryStatistics对象
  • mapToInt()方法传递的Lambda表达式返回当前元素把什么作为转换后的数值
1
2
3
IntSummaryStatistics statistics = stream.mapToInt((item) -> {
    return 0;
}).summaryStatistics();
1
2
3
LongSummaryStatistics statistics = stream.mapToLong((item) -> {
    return 0;
}).summaryStatistics();
1
2
3
DoubleSummaryStatistics statistics = stream.mapToDouble((item) -> {
    return 0;
}).summaryStatistics();

求最大值

1
int max = statistics.getMax();

求最小值

1
int min = statistics.getMin();

求平均值

1
double avg = statistics.getAverage();

求和

1
long sum = statistics.getSum();

求元素总数

1
long count = statistics.getCount();

完成