Java8 Stream 流式编程

简介

Java 8 API添加了一个新的抽象称为流Stream，可以让你以一种声明的方式处理数据。

1.Collection创建流
stream() ： 为集合创建串行流
parallelStream() ： 为集合创建并行流

List<String> list = Arrays.asList("A", "B", "C", "D");
// 创建串行流对象
Stream stream = list.stream();
// 创建并行流对象
Stream parallelStream = list.parallelStream();

2.Stream常用方法
filter
过滤元素，通过设置条件过滤元素

List<String> list = Arrays.asList("A", "", "B", "", "C", "D");
// 过滤掉空元素
List<String> filtered = list.stream().filter(string -> !string.isEmpty()).collect(Collectors.toList());
filtered.forEach(n -> System.out.println(n));

map
元素一对一转换

List<String> list = Arrays.asList("1", "2", "3", "4");
// mapToInt 字符串转int
list.stream().mapToInt(v -> Integer.valueOf(v)).forEach(System.out::println); // 1 2 3 4
// mapToLong 字符串转long
list.stream().mapToLong(v -> Long.valueOf(v)).forEach(System.out::println); // 1 2 3 4
// mapToDouble 字符串转double
list.stream().mapToDouble(v -> Double.valueOf(v)).forEach(System.out::println); // 1.0 2.0 3.0 4.0

peek

List<String> list = Arrays.asList("1", "2", "3", "4");
// peek对Stream中的元素进行操作后，并不会把操作后的数据返回到Stream，所以其中的元素不变。
list.stream().peek(v -> Double.valueOf(v)).forEach(System.out::println); // 1 2 3 4

flatMap
元素一对多转换

List<String> list = Arrays.asList("1,2", "3", "4", "5");
// 元素一对多转换 
List<String> resList = list.stream().flatMap(v -> Stream.of(v.split(","))).collect(Collectors.toList());
resList.forEach(System.out::println); // 1 2 3 4 5

distinct
去掉重复元素

List<String> list = Arrays.asList("1", "1", "2", "3");
// 去重
List<String> resList = list.stream().distinct().collect(Collectors.toList());
resList.forEach(System.out::println);// 1 2 3

sorted
排序

List<Integer> list = Arrays.asList(3, 2, 1, 4);
// 排序
List<Integer> resList = list.stream().sorted().collect(Collectors.toList());
resList.forEach(System.out::println); // 1 2 3 4

limit
返回前n个元素

List<Integer> list = Arrays.asList(1, 2, 3, 4);
// 返回前2个元素
List<Integer> resList = list.stream().limit(2).collect(Collectors.toList());
resList.forEach(System.out::println); // 1 2

skip
跳过前n个元素

List<Integer> list = Arrays.asList(1, 2, 3, 4);
// 跳过前一个元素
List<Integer> resList = list.stream().skip(1).collect(Collectors.toList());
resList.forEach(System.out::println); // 2 3 4

forEach
遍历

List<Integer> list = Arrays.asList(1, 2, 3, 4);
list.stream().forEach(System.out::println); // 1 2 3 4
// 并行 输出顺序不确定
list.parallelStream().forEach(System.out::println);

forEachOrdered
遍历

List<Integer> list = Arrays.asList(1, 2, 3, 4);
list.stream().forEachOrdered(System.out::println); // 1 2 3 4
// 并行 输出顺序确定
list.parallelStream().forEachOrdered(System.out::println);

reduce
进行聚合求值

List<Integer> list = Arrays.asList(1, 2, 3, 4);
// 累计
Optional<Integer> sum = list.stream().reduce((a, b) -> {
    return a + b;
});
 System.out.println(sum.get());  //   10

collect
收集元素

List<Integer> list = Arrays.asList(1, 2, 3, 4);
// 合并成list
List<Integer> a1 = list.stream().collect(Collectors.toList());

count
返回元素个数

List<Integer> list = Arrays.asList(1, 2, 3, 4);
// 返回个数
long count = list.stream().count();

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

List<Integer> list = Arrays.asList(1, 2, 3, 4);
// 判断元素中是否有等于1的 anyMatch 只要有一个元素符合条件时就返回true
boolean anyMatch = list.stream().anyMatch(e -> e == 1);
System.out.println(anyMatch); // true
// 判断元素是否小于5  allMatch 所有元素符合条件才返回true
boolean allMatch = list.stream().allMatch(e -> e < 5);
System.out.println(allMatch);
// 判断元素是否小于5 noneMatch 所有元素都不符合条件时返回true
boolean noneMatch = list.stream().noneMatch(e -> e < 5);
System.out.println(noneMatch);