Java8-Stream详解

Java8-Stream

1. Stream

1.1 Stream介绍

1.1.1 介绍

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

  Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。

• Stream API可以极大提高Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。

  这种风格将要处理的元素集合看作一种流， 流在管道中传输， 并且可以在管道的节点上进行处理， 比如筛选， 排序，聚合等。

• 元素流在管道中经过中间操作（intermediate operation）的处理，最后由最终操作(terminal operation)得到前面处理的结果

1.1.2 Stream特点

（1）数据源

• 数据源可以是集合，数组，I/O channel，产生器generator等（Stream本身并不保存数据）

（2）支持聚合操作

• 聚合操作：类似SQL语句一样的操作， 比如filter, map, reduce, find, match, sorted等

（3）Pipelining

• 中间操作都会返回流对象stream本身。 这样多个操作可以串联成一个管道， 如同流式风格（fluent style）。 这样做可以对操作进行优化， 比如延迟执行(laziness)和短路( short-circuiting)

（4）内部迭代

• 以前对集合遍历都是通过Iterator或者For-Each的方式, 显式的在集合外部进行迭代， 这叫做外部迭代。 Stream提供了内部迭代的方式， 通过访问者模式(Visitor)实现

（5）延迟执行

• 中间的操作只是提供了一个操作逻辑，并记录，只有最终求值时才会执行传入的操作

1.1.3 直接对集合遍历操作与使用Stream操作集合的对比

（1）使用循环遍历

• 如果是处理简单数据，进行简单操作，使用循环遍历集合，并没有什么不妥，但是如果是复杂的大型的数据使用循环不仅会使处理效率变得底下，而且会降低代码的可读性

  • 例如下面代码：查找符合条件的学生

    • 以下是通过遍历集合，通过条件判断来对符合条件的数据进行操作

    class Student implements Comparable<Student> {
        int id;
        String name;
        String className;
        int grade;
    
        public Student(int id, String name, String className, int grade) {...}
    
        @Override
        public String toString() {...}
    
        //使用成绩决定排名
        @Override
        public int compareTo(Student o) {
            return this.grade-o.grade;
        }
    }
    
    public class StreamTest {
        public static void main(String[] args) {
            LinkedList<Student> studentList = new LinkedList<Student>();
            studentList.add(new Student(1, "Alice", "1班", 100));
            studentList.add(new Student(2, "Bob", "2班", 85));
            studentList.add(new Student(3, "Coco", "2班", 46));
            studentList.add(new Student(4, "Dav", "3班", 95));
            studentList.add(new Student(5, "Elizabeth", "4班", 81));
            studentList.add(new Student(6, "Fermat", "4班", 69));
            studentList.add(new Student(7, "grace", "4班", 59));
            //选取4班，成绩大于60的人,和其他班成绩大于50的人
            //由于是链表，为了性能，这里使用iterator进行迭代
            Iterator<Student> iter = studentList.listIterator();
            while(iter.hasNext()){
                Student cur = iter.next();
                if("4班".equals(cur.className)){
                    if(cur.grade>60) {
                        System.out.println(cur);
                    }
                }
                else if(cur.grade>50){
                    System.out.println(cur);
                }
            }
        }
    }
    

    • 这只是一个很简单的例子，如果说数据量很大或者涉及几种数据，而且条件设置地比较复杂，代码量以及执行效率会变得非常差

（2）使用Stream操作

• 以下是通过Stream处理集合实例

  studentList.stream().filter(s->{
      if("4班".equals(s.className)){
          return s.grade > 60;
      }else {
          return s.grade > 50;
      }
  }).forEach(s-> System.out.println(s));
  

---

1.2 Stream使用

1.2.1 使用流程

（1）流程

• 当使用一个流时，通常包括三个基本步骤

  获取数据源

  数据转换

  传入需要执行的操作

  操作集合获取想要的结果

• 当一个Stream流执行完终结方法时，就不能再使用该对象了，再次使用会抛出（IllegalStateException）

1.2.2 获取Stream接口对象

（1）Stream接口

• Stream接口是定义在java.util.stream.Stream

• public interface Stream<T> extends BaseStream<T, Stream<T>> {
      ...
  }
  

（2）Stream接口实现对象的获取方式

• Collection实现的stream()与parallelStream()接口方法，创建一个顺序流：

  • java8中将Collection接口中加入了stream()，parallelStream()默认方法，用于获取Stream对象

    public interface Collection<E> extends Iterable<E> {
        ...
        default Stream<E> stream() {
                return StreamSupport.stream(spliterator(), false);
    	}
        
        ...
        default Stream<E> parallelStream() {
            return StreamSupport.stream(spliterator(), true);
        }
        ...
    }
    

    List<String> list = new ArrayList<>();
    Stream<String> stream = list.stream(); //获取一个顺序流
    Stream<String> parallelStream = list.parallelStream(); //获取一个并行流
    

    • 对于Map类型集合可以先获取keyset，再获取键的Stream对象；或者先获取values(),再获取值的Stream对象；也可以获取entrySet()，再获取键值对Stream对象

• Arrays.stream(T[] array)静态方法：

  • public static <T> Stream<T> stream(T[] array) {
    	return stream(array, 0, array.length);
    }
    
    public static <T> Stream<T> stream(T[] array, int startInclusive, int endExclusive{
    	return StreamSupport.stream(spliterator(array,startInclusive,endExclusive), false);
    }
    

    String[] nums = new String[10];
    Stream<String> stream = Arrays.stream(nums);
    

• Stream中的静态方法：

  • public static<T> Stream<T> of(T... values) {
    	return Arrays.stream(values);
    }
    

    • 此方法将通过数组对象获取Stream对象

  • public static<T> Stream<T> generate(Supplier<T> s) {
        Objects.requireNonNull(s);
        return StreamSupport.stream(
            new StreamSpliterators.InfiniteSupplyingSpliterator.OfRef<>(Long.MAX_VALUE, s), false);
    }
    

  • public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f) {...}
    

• BufferedReader对象的lines() 方法

  • public Stream<String> lines(){...}
    

    BufferedReader reader = new BufferedReader(new FileReader("/user/sd/readme.md"));
    Stream<String> lineStream = reader.lines();
    

• 使用 Pattern.splitAsStream() 方法，将字符串分隔成流

  • Pattern pattern = Pattern.compile(",");
    Stream<String> stringStream = pattern.splitAsStream("a,b,c,d");
    stringStream.forEach(System.out::println);
    

参考

1.2.3 延迟方法

• 延迟方法：一般为传入某种函数式接口来表明需要进行的操作，其返回类型依旧为Stream类型，所以可以链式调用（该系列方法并没有执行操作，只是传入函数式接口表明需要进行的操作）

（1）Stream filter(Predicate predicate)

• 该方法通过传入predicate接口对象，作为筛选条件

  List<String> personList = new ArrayList();
  personList.add("Alice");
  personList.add("Bob");
  personList.add("Coco");
  Stream<String> stream = personList.stream()
  stream.filter(s->s.startsWith("A")).forEach(System.out::println);//Alice
  

（2）Stream map(Functionsuper mapper)

• 该接口需要一个Function函数式接口参数，可以将当前流中的T类型数据转换为另一种R类型的流

  Stream<String> stream = Stream.of("1", "2", "3");
  Stream<Integer> result = stream.map(Integer::parseInt);
  

（3）Stream limit(long maxSize)

• 该方法可以对流进行截取，只取用前n个

• 参数是一个long型，如果集合当前长度大于参数则进行截取；否则不进行操作

  stream.limit(2).forEach(System.out::println);//Alice Bob
  

（4）Stream skip(long n)

• 可以使用 skip 方法获取一个跳过n个数据后的新流

• 如果流的当前长度大于n，则跳过前n个；否则将会得到一个长度为0的空流

  stream.skip(1).forEach(System.out::println);//Bob Coco
  

（5）Stream distinct()

• 该方法会将重复元素给去除掉

• 该方法使用hashCode()和equals(Object o)方法来比较元素，只有两者都相同才认为是相同的，只会保留第一个所遇到的元素

  public class StreamTest {
  
      public static void main(String[] args){
          List<String> list = new ArrayList();
          StreamTest s = new StreamTest();
          list.add("1");
          list.add("2");
          list.add("1");
          list.add(new String("1"));
          list.stream().distinct().forEach(System.out::println);//1 2
      }
  }
  

• 当我们需要去重时也可以使用Set去重：

  public static void main(String[] args) {
      users.parallelStream().filter(distinctByKey(User::getId))
          .forEach(System.out::println);
  }
  
  
  public static <T> Predicate<T> distinctByKey(Function<? super T, ?> keyExtractor) {
      Set<Object> seen = ConcurrentHashMap.newKeySet();
      return t -> seen.add(keyExtractor.apply(t));
  }
  

  • 通过Function接口处理数据后，将处理后的数据添加尝试添加进Set，如果添加不成功就代表已经有改元素了，返回false,此时过滤器函数会将改元素丢弃，实现去重

（6） Stream map(Function mapper)

• 该方法通过传入Function接口实例将数据元素进行元素转换，构造新的Stream对象

• 此外还有方法XXStream mapToXX(ToXXFunction mapper)等一系列方法，来将数据转换为特定类型

  List<String> list = new ArrayList();
  StreamTest s = new StreamTest();
  list.add("String");
  list.add("哈哈");
  list.add(new String("hello"));
  list.stream().map(String::toUpperCase).forEach(System.out::println);//STRING 哈哈 HELLO
  

（7）Stream sorted(Comparator comparator)

• 该方法使用传入的Comparator进行比较，然后排序，构建排序后的新Stream对象

• 还包含一个无参的构造方法

  list.add("String");
  list.add("哈哈");
  list.add(new String("hello"));
  list.stream().sorted(String::compareTo).forEach(System.out::println);//String hello 哈哈
  

（8）Stream peek(Consumer action)

• 该方法通过传入Consumer接口对元素进行一些操作,并返回新的Stream对象

  class A{
      int var = 0;
  
      void display(){
          System.out.println(var);
      }
  }
  
  List<A> list = new ArrayList();
  StreamTest s = new StreamTest();
  list.add(new A());
  list.add(new A());
  list.add(new A());
  list.stream().peek(o->o.var = 1).forEach(A::display);
  

（7）static Stream concat(Stream a, Stream b)

• 该静态方法可以将两个流合并成一个新Stream对象

• 该方法传入的流的泛型类型要一致

  stream = Stream.concat(stream,Stream.of("1","2"));
  stream.forEach(System.out::println);//Alice Bob Coco 1 2
  

1.2.4 终结方法

• 终止方法：表明已经要求通过之前传入的操作进行数据处理，并给出结果

（1）void forEach(Consumersuper action)

• 该方法接收一个 Consumer 接口对象，会将每一个流元素交给该函数进行处理

  List<String> personList = new ArrayList();
  personList.add("Alice");
  personList.add("Bob");
  personList.add("Coco");
  personList.stream().forEach(s->{
      if(s.startsWith("A")){
          System.out.println(s);
      }
  });//打印以A开头的字符串
  

（2）long count()

• 该方法返回操作后的元素个数+

  System.out.println(stream.filter(s -> s.startsWith("A")).count());//1
  

（3）Object[] toArray()

• 该方法将数据转入到数组中，并返回

  List<String> list = new ArrayList();
  StreamTest s = new StreamTest();
  list.add("String");
  list.add("哈哈");
  list.add(new String("hello"));
  System.out.println(Arrays.toString(list.stream().sorted(String::compareTo).toArray()));//[String, hello, 哈哈]
  

---