学习Java8--stream

1 为什么引入流

先从一个例子开始，看看为什么在Java8中要引入流(Stream)?
比如实现这么一个需求：在学生集合中查找男生的数量。
传统的写法为：

public  long  getCountsOf MaleStudent(List<Student> students) {      long  count =  0 ;      for  (Student student : students) {          if  (student.isMale()) {              count++;          }      }      return  count; }

看似没什么问题，因为我们写过太多类似的“样板”代码，尽管智能的IDE通过code template功能让这一枯燥过程变得简化，但终究不能改变冗余代码的本质。
再看看使用流的写法：

public  long  getCountsOfMaleStudent(List<Student> students) {      return  students.stream().filter(Student::isMale).count(); }

一行代码就把问题解决了！
虽然读者可能还不太熟悉流的语法特性，但这正是函数式编程思想的体现：

• 回归问题本质，按照心智模型思考问题。
• Stream提供的高阶函数以及链式调用，可以对数据进行更高层的抽象和控制。
• 很容易转成并行流，提供并行计算的能力。
• 延迟加载。
• 简化代码。

2 创建流

创建流的方式可以有很多种，其中最常见的方式是通过Collection的Stream()方法或者Arrays的Stream()方法来生成流。

• 比如：

  List<Integer> numbers = Arrays.asList( 1 ,  2 ,  3 ); Stream<Integer> numberStream = numbers.stream();   String[] words =  new  String[]{ "one" ,  "two" }; Stream<String> wordsStream = Arrays.stream(words);

  当然Stream接口本身也提供了许多和流相关的操作。

  // 创建流 Stream<Integer> numbers = Stream.of( 1 ,  2 ,  3 ); // 创建空流 Stream<String> emptyStream = Stream.empty(); // 创建一个元素为“hi”的无限流 Stream<String> infiniteString = Stream.generate(() ->  "hi" ); // 创建一个从0开始的递增无限流 Stream<BigInteger> integers = Stream.iterate(BigInteger.ZERO, n -> n.add(BigInteger.ONE));

  其中Stream.generate()和Stream.iterate()产生的都是无限流，如果要把他们截取为有限流，可以使用limit()方法，
  比如：

  Stream<Double> top10 = Stream.generate(Math::random).limit( 10 );

  另外，可以通过skip()方法跳过元素，concat()方法连接两个流。

  Stream<Integer> skipedStream = Stream.of( 1 ,  2 ,  3 ,  4 ).skip( 2 );  // 3, 4 Stream<String> concatedStream = Stream.concat(Stream.of( "hello" ), Stream.of( ",world" ));  // hello,world

3 常用的流操作

filter

filter()方法的作用就是根据输入的条件表达式过滤元素。
接口定义如下：

Stream<T> filter(Predicate<?  super  T> predicate);

从中可以看出，输入参数是一个Predicate，也即是一个条件表达式。
一个例子：

Stream.of( "a" ,  "1b" ,  "c" ,  "0x" ).filter(value -> isDigit(value.charAt( 0 )));

过滤出第一个字符是数字的元素。
输出结果为：

1b, 0x

map

map()的主要作用是通过映射函数转换成新的数据。
接口定义如下：

<R> Stream<R> map(Function<?  super  T, ?  extends  R> mapper);

从中可以看出，输入参数是一个Function。
一个例子：

Stream.of( "a" ,  "b" ,  "c" ).map(String::toUpperCase);

把字符串转换成大写。
输出结果：

A, B, C

有状态的转换

在前面介绍的函数中，无论是map还是filter，都不会改变流的状态，也即结果并不依赖之前的元素。
除此之外，Java8也提供了有状态的转换，常用的操作是distinct和sorted。

distinct

distinct()的主要作用是去除流中的重复元素。和Oracle的distinct一个作用。
举例如下：

Stream<String> distinctStream = Stream.of( "one" ,  "one" ,  "two" ,  "three" ).distinct();

去除字符串中的重复元素，返回结果为：

one, two, three

sorted

sorted()的主要作用是对流按照指定的条件进行排序。
接口定义如下：

Stream<T> sorted(Comparator<?  super  T> comparator);

从中可以看出，入参是一个Comparator，也即是一个函数式接口。
一个例子：

Stream<String> sortedStream = Stream.of( "one" ,  "two" ,  "three" ).sorted(Comparator.comparing(String::length).reversed());

对字符串按照长度进行降序排列。
注意，这里使用了Comparator.comparing方法来简化调用。
输出结果为：

[three, one, two]

4 分组操作(groupingBy)

groupingBy操作也是基于collect操作完成的，功能是根据条件进行分组操作，他和partitioningBy不同的一点是，它的输入是一个Function，这样返回结果的Map中的Key就不再是boolean型，而是符合条件的分组值，使用场景会更广泛。
接口定义如下：

public  static  <T, K> Collector<T, ?, Map<K, List<T>>> groupingBy(Function<?  super  T, ?  extends  K> classifier)

一个例子

public  Map<String, List<Student>> studentByName(Stream<Student> students) {      return  students.collect(Collectors.groupingBy(student -> student.getName())); }

按照学生的姓名进行分组。