Java8新特性Stream流实例详解

什么是stream流？

stream流是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。

stream的优点：声明性，可复合，可并行。这三个特性使得stream操作更简洁，更灵活，更高效。

stream的操作有两个特点：可以多个操作链接起来运行，内部迭代。

stream可分为并行流与串行流，stream api 可以声明性地通过 parallel() 与sequential() 在并行流与顺序流之间进行切换。串行流就不必再细说了，并行流主要是为了为了适应目前多核机器的时代，提高系统cpu、内存的利用率，并行流就是把一个内容分成多个数据块，并用不同的线程分别处理每个数据块的流。java1.8并行流使用的是fork/join框架，关于fork/join框架可参考学习。

注意 ：

* 1、stream不会自己存储数据。

* 2、stream不会改变原对象，他们会返回一个新的stream。

* 3、stream操作是延迟的，他们会等到需要的结果时才执行。

* 4、使用并行流并不一定会提高效率，因为jvm对数据进行切片和切换线程也是需要时间的。

本文主要讲 stream的3个操作步骤：1、创建stream 2、中间操作3、终止操作。

创建stream

创建stream，就是将一个数据源 （如：集合、数组）转化为一个流。

1、通过collection系列提供的stream()（串行） 或parallelstream()（并行）获取数据流。

2、通过arrays中的静态方法stream() 获取数据流。

3、通过stream类中的静态方法of()获取数据流。

 //1、通过collection系列提供的stream()（串行） 或parallelstream()（并行）获取
    list<string> list = new arraylist<>();
    stream<string> stream1 = list.stream();//串行流
    stream<string> stream2 = list.parallelstream();//并行流
  //2、通过arrays中的静态方法stream() 获取数据流
    user[] u = new user[2];
    stream<user> stream3 = arrays.stream(u);
  //3、通过stream；类中的静态方法of()
    stream<string> stream4 = stream.of("11","2");

中间操作

中间操作，即对数据源进行一系列的操作处理。
多个中间操作可以连接起来性格一条流水线，除非流水线上触发器终止操作，否则中间操作不会执行任何的处理，而是在终止操作时一次性全部处理，成为惰性求值。

筛选和切片

1、filter(predicate)-接收lambda，从流中排除某些元素。

2、limit(n)-截断流，使其元素不超过给定数量。

3、skip(n)-跳过元素，返回一个扔掉了前n个元素的流。若流中元素不足n个，则返回一个空流，与limit(n)互补。

4、distinct-筛选，通过流所生成元素的hashcode()和equals()去重复元素。

/**
   * 打印年龄大于18的前4位用户信息（不重复）
   * 并跳过第1个用户
   */
@test
  public void test1(){
    list.stream()
    .filter((x)->x.getage()>18)
    .distinct()
    .limit(4)
    .skip(1).foreach(system.out::println);
  }

映射

1、map，接收lambda，将元素转换成其他形式或提取信息。接收一个函数作为参数，该函数会被应用到每一个元素上，并将其映射成一个新的元素。

2、maptodouble/maptoint/maptolong，接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的doublestream/intstream/longstream。

3 、flatmap，接收一个函数作为参数，将流中的每个值都换成一个流，然后把流连接成一个流。

 @test
  public void test2(){
    ///map
    list.stream().map(user::getname)
    .foreach(system.out::println);
    //flatmap
    list<list<user>> list1 = new arraylist<>();
    list1.add(list);
    list1.stream().flatmap(stream::getnames)
    .foreach(system.out::println);
  }
  public static stream<string> getnames(list<user> list){
    list<string> list1 = new arraylist<string>();
    for (user user : list) {
      list1.add(user.getname());
    }
    return list1.stream();
  }

排序

1、sorted()，产生一个新流，其中按自然顺序排序。

2、sorted(comparator)，产生一个新流，其中按比较器顺序排序。

@test
  public void test3(){
    list<string> list =arrays.aslist("aa","bb","cc","dd");
    list.stream().sorted()
    .foreach(system.out::println);
    //
    list.stream().sorted((x,y) -> {
      if(x.equals(y)){
        return 1;
      }else{
        return -1;
      }
    } ).foreach(system.out::println);
  }

终止操作

终止操作是执行中间操作链，并产生结果（一个新流）,数据源本身并不受影响，其结果可以是任何不是流的值。

查找与匹配

1、allmatch,检查是否匹配所有元素。
2、anymatch,检查是否至少匹配一个元素。
3、nonematch,检查是否没有匹配所有元素。
4、findfirst,返回第一个元素。
5、findany,返回当前流中的任意元素。
6、count,返回流中元素的总数。
7、 max,返回流中最大值。
8、min,返回流中最小值。
9、froeach(consumer c) 内部迭代。

@test
  public void test4(){
    boolean b = list.stream().
        nonematch((e) ->
        e.getname().equals("zhao"));
    system.out.println(b);
    optional<user> op = list.parallelstream()
        .filter((x) -> x.getage() == 18)
        .findany();
    system.out.println(op.get());
  }

归约

reduce，可以将流中的值反复结合起来，得到一个值。

@test
  public void test5(){
    //转list
    list<string> list1 =list.stream()
        .map(user::getname)
        .collect(collectors.tolist()) ;
    list1.foreach(system.out::println);
    //转hashset
    hashset<string> set = list.stream().
        map(user::getname)
        .collect(collectors.tocollection(hashset::new));
    set.foreach(system.out::println);
    //总数
    long count = list.stream()
        .collect(collectors.counting());
    system.out.println(count);
    //平均年龄
    double avage = list.stream()
        .collect(collectors.averagingint(user::getage));
    system.out.println(avage); 
    //总年龄
    int toage = list.stream()
        .collect(collectors.summingint(user::getage));
    system.out.println(toage);
    //最大值
    optional<user> u = list.stream()
        .collect(collectors.maxby((e1,e2) 
            -> integer.compare(e1.getage(),e2.getage() )));
    system.out.println(u);
    //平均年龄
    intsummarystatistics collect = list.stream()
        .collect(collectors.summarizingint(user::getage));
    system.out.println(collect.getaverage());
    //分组
    map<integer, list<user>> l= list.stream()
        .collect(collectors.groupingby(user::getage));
    system.out.println(l);
    //多级分组
    map<integer,map<string,list<user>> > ls= list.stream()
        .collect(collectors.groupingby(
            user::getage,collectors.groupingby(user::getsex)));
    system.out.println(ls);
    //分区
    map<boolean,list<user>> map= list.stream()
        .collect(collectors.partitioningby((x) 
            -> x.getage()>18));
    system.out.println(map);
    //连接字符串
    string str = list.stream().map(user::getname)
        .collect(collectors.joining(",","-","-"));
    system.out.println(str);
  }

总结

以上所述是小编给大家介绍的java8新特性stream流实例详解，希望对大家有所帮助