Stream使用

Stream

• Stream为Java8的新特性

• Stream是一种流的概念，可以看成集合中的元素依次流过想要执行的操作，相当于一个更高级的迭代器，是程序员的代码更加简洁高效

• Stream提供串行和并行的操作

• 每次执行Stream流操作的时候，不会改变原有的流，而是返回一个新的stream

• Stream的操作分为两种：

  • Intermediate：一个流可以后面跟随零个或多个 intermediate 操作。其目的主要是打开流，操作数据映射/过滤，然后返回一个新的流，交给下一个操作使用。这类操作都是惰性化的（lazy），就是说，仅仅调用到这类方法，并没有真正开始流的遍历
  • Terminal：一个流只能有一个 terminal 操作，当这个操作执行后，流就无法再被操作。所以这必定是流的最后一个操作。Terminal 操作的执行，才会真正开始流的遍历，也就是说Stream会把之前的所有操作一起执行，只进行一次遍历就得到最终结果

生成流

• stream() − 为集合创建串行流。

• parallelStream() − 为集合创建并行流。

List<Student> list = new ArrayList<>();
list.add(new Student(1L, "zhangsan", 23));
list.add(new Student(2L, "lisi", 24));
list.add(new Student(3L, "wangwu", null));
list.add(new Student(4L, "zhaoliu", null));

list.stream(); // 串行流
list.parallelStream(); // 并行流

stream().map()

• map是对每个元素执行相同的操作，映射成新的元素

转换成大写字母

List<String> list1 = Arrays.asList("a", "b", "c");
list1.stream().map(String::toUpperCase).forEach(System.out::println); 
// A B C

平方数

List<Integer> list2 = Arrays.asList(1, 2, 3);
list2.stream().map(n -> n*n).forEach(System.out::println); 
// 1 4 9

stream().filter()

• filter()是将集合中的元素进行筛选

筛选出偶数

List<Integer> list2 = Arrays.asList(1, 2, 3);
list2.stream().filter(n -> n % 2 == 0).forEach(System.out::println); 
// 2

多条件筛选

List<Integer> list2 = Arrays.asList(1, 2, 3, 4);
list2.stream().filter(n -> n % 2 == 0).filter(n -> n > 2).forEach(System.out::println); 
// 4

或者这样写

List<Integer> list2 = Arrays.asList(1, 2, 3, 4);
list2.stream().filter(n -> n % 2 == 0 && n > 2).forEach(System.out::println);

还可以这样

Predicate<Integer> predicate1 = n -> n % 2 == 0;
Predicate<Integer> predicate2 = n -> n > 2;
List<Integer> list2 = Arrays.asList(1, 2, 3, 4);
list2.stream().filter(predicate1.and(predicate2)).forEach(System.out::println);

Predicate更多操作参考这位大佬的博客

stream().peek()

• 和map类似，对每个元素进行操作
• 和map的区别是： map的参数为Function，有返回值，而peek的参数是Consumer，没有返回值

List<Integer> list2 = Arrays.asList(1, 2, 3, 4);
list2.stream().peek(n -> System.out.println(n + 1)).collect(Collectors.toList()); 
// 2 3 4 5

stream().reduce()

• reduce()作用是把 Stream 元素组合起来。它提供一个起始值（种子），然后依照运算规则（BinaryOperator），和前面 Stream 的第一个、第二个、第 n 个元素组合。从这个意义上说，字符串拼接、数值的 sum、min、max、average 都是特殊的 reduce。例如 Stream 的 sum 就相当于Integer sum = integers.reduce(0, (a, b) -> a+b); 或Integer sum = integers.reduce(0, Integer::sum);

String concat = Stream.of("A", "B", "C", "D").reduce("起始值", String::concat);
System.out.println("concat: " + concat); 
// 字符串连接，concat = "起始值ABCD"

double minValue = Stream.of(-1.5, 1.0, -3.0, -2.0).reduce(Double.MAX_VALUE, Double::min);
System.out.println("minValue: " + minValue); 
// 求最小值，minValue = -3.0

int sumValue = Stream.of(1, 2, 3, 4).reduce(10, Integer::sum);
System.out.println("sumValue: " + sumValue); 
// 求和，sumValue = 20, 有起始值

sumValue = Stream.of(1, 2, 3, 4).reduce(Integer::sum).get();
System.out.println("sumValue: " + sumValue); 
// 求和，sumValue = 10, 无起始值

concat = Stream.of("a", "B", "c", "D", "e", "F").filter(x -> x.compareTo("Z") > 0).reduce("起始值", String::concat);
System.out.println("concat: " + concat); 
// 过滤，字符串连接，concat = "起始值ace"

stream().limit()和stream().skip()

• limit()返回前n个元素，skip()去掉前n个元素

List<Integer> list2 = Arrays.asList(1, 2, 3, 4);
list2.stream().limit(3).skip(1).forEach(System.out::println); 
// 2 3

stream().sorted()

List<Integer> list2 = Arrays.asList(2, 4, 1, 3);
list2.stream().sorted().forEach(System.out::println);
// 1 2 3 4

stream().max()和stream().min()

List<Integer> list2 = Arrays.asList(2, 4, 1, 3);
System.out.println(list2.stream().max(Comparator.naturalOrder()).get());
// 4
System.out.println(list2.stream().min(Comparator.naturalOrder()).get());
// 1

stream().distinct()

List<Integer> list2 = Arrays.asList(2, 4, 1, 3, 2, 3, 3);
list2.stream().distinct().forEach(System.out::println);// 2 4 1 3

match

• allMatch：Stream 中全部元素符合传入的 predicate，返回 true
• anyMatch：Stream 中只要有一个元素符合传入的 predicate，返回 true
• noneMatch：Stream 中没有一个元素符合传入的 predicate，返回 true

List<Integer> list2 = Arrays.asList(2, 4, 1, 3, 2, 3, 3);
System.out.println(list2.stream().allMatch(n -> n > 0)); // true
System.out.println(list2.stream().allMatch(n -> n > 1)); // false
System.out.println(list2.stream().anyMatch(n -> n < 0)); // false
System.out.println(list2.stream().anyMatch(n -> n > 1)); // true
System.out.println(list2.stream().noneMatch(n -> n < 0)); // true
System.out.println(list2.stream().noneMatch(n -> n > 1)); // false

stream().mapTo…()

List<String> list1 = Arrays.asList("1", "2", "3", "4");
list1.stream().mapToInt(Integer::parseInt).forEach(System.out::println);
// 字符串转为整型 1 2 3 4

…

参考

https://www.cnblogs.com/kaisadadi/p/9099485.html