Stream使用

  • Stream
  • 生成流
  • stream().map()
  • 转换成大写字母
  • 平方数
  • stream().filter()
  • 筛选出偶数
  • 多条件筛选
  • stream().peek()
  • stream().reduce()
  • stream().limit()和stream().skip()
  • stream().sorted()
  • stream().max()和stream().min()
  • stream().distinct()
  • match
  • stream().mapTo...()
  • 参考


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

…

参考