JAVA8 之 Stream 流(四)

站长

发表文章数:4245

记一次线上 OOM 和性能优化

如果说前面几章是函数式编程的方法论,那么 Stream 流就应该是 JAVA8 为我们提供的最佳实践。

Stream 流的定义

Stream 是支持串行和并行操作的一系列元素。流操作会被组合到流管道中(Pipeline)中,一个流管道必须包含一个源(Source),这个源可以是一个数组(Array),集合(Collection)或者 I/O Channel,会有一个或者多个中间操作,中间操作的意思就是流与流的操作,流还会包含一个中止操作,这个中止操作会生成一个结果。

Stream 流的作用

以函数式编程的方式更好的操作集合。完全依赖于函数式接口。在 java.util.stream 包中。

流的创建方式

  • 使用数组的方式

    //第一种方式,使用 Stream.of 方法
    Stream stream1 = Stream.of("hello","world","hello world");
    
    String[] myArray = new String[]{"hello","world","hello world"};
    Stream stream2 = Stream.of(myArray);
    
    //第二种方式,使用 Arrays.stream()
    Stream stream3 = Arrays.stream(myArray);
  • 使用集合的方式

    Stream 的作用是以函数式编程的方式操作集合,所以对于集合类,一定有更好更方便的方法去创建 Stream 流。

    List<String> list = Arrays.asList(myArray);
    Stream stream4 = list.stream();

    对于集合类,直接调用 stream 方法就可以获得这个集合对应的 Stream 流。通过查看源码我们发现这个方法直接定义在 Collection 接口中,并且是一个默认方法。所以所有 Collection 的子类都可以直接调用这个方法。这也是最为常用的方法。

    default Stream<E> stream() {
      return StreamSupport.stream(spliterator(), false);
    }
  • 使用文件流(基本不会使用,简单了解即可)

    下面是一个直接读取文件中的内容并且转化为 Stream 流,最后输出的过程。

    //文件流
    private static Stream<String> fileStream(){
      Path path = Paths.get("C:\\Users\\abs\\a.txt");
      try(Stream<String> lines = Files.lines(path)){
        lines.forEach(System.out::println);
        return lines;
      }catch(IOException e){
        throw new RuntimeException(e);
      }
    }
  • 其他方式

    最后的方式是用于创建无限流,无限流的意思是如果你不加任何限制,流中的数据是无限。用于创建无限流的方法有 iterator 和 generate。

    generate 方法需要传入一个 Supplier 类型的函数式接口,这个函数式接口用于产生无限流中所需要的数据。

    //全是数字 1 的无限流
    Stream.generate(()->1);
    //随机数字的无限流
    Stream.generate(Math::random);

    iterator 方法需要传入两个参数,第一个给定一个初始值,第二个参数是一个函数式接口 UnaryOperator,这个函数式接口就是输入和输出相同的 Function 接口。

    Stream.iterate(0,n->n+1).limit(10).forEach(System.out::println);

    输出结果:

    0
    1
    2
    3
    4
    5
    6
    7
    8
    9

    上面的 limit 是避免无限流一直产生,到达指定个数就停止。

Steam 流的优势

下面我们通过一个简单的例子来了解一下使用 Stream 流到底有哪些好处。等我们学完 Stream API 后会给大家提供更多的例子,让大家真正了解它。

比如我们给定一个 List 集合,里面放了很多数字,我们想要得到数字的平方然后求和。

以前的写法:

List<Integer> l = Arrays.asList(1,2,3,4,5,6,7);
int res = 0;
for(int i=0;i<l.size();i++){
  res += i*i;
}

使用 Stream 后的写法只需要一行代码:

int r = l.stream().map(i->i+i).reduce(0,Integer::sum);

大家现在可能不明白 map 或者 reduce 的作用,我们稍后会详细讲解这一部分,这里只是想让大家看看区别,以及认识到 Stream 对于函数式编程的使用和好处。

Stream 流的特性和原理

流不存储值,通过管道的方式获取值。对流的操作会生成一个结果,不过并不会修改底层的数据源。集合可以作为流的底层数据源,也可以通过 generate/iterator 方法来生成数据源。

JAVA8 之 Stream 流(四)

得到流之后,我们可以对流中的数据进行很多操作,比如过滤,映射,排序等等,处理完之后的数据可以再次被收集起来转化为我们需要的数据类型。

JAVA8 之 Stream 流(四)

从上面的图我们可以看出,一个完成的流操作过程是包含两种类型的,一个是中间操作,一个是终止操作。中间操作指的是过滤,排序和映射等中间处理过程的方法,终止操作指的是我们将流处理完毕后返回结果的操作,比如 collect,reduce 和 count 等等。

中间操作:一个流后面可以跟随零个或者多个中间操作。其目的只要是打开流,做出某种程度的数据映射/过滤,然后返回一个新的流,交给下一个操作使用,这些操作都是延迟的,就是说仅仅调用到这些类的方法,并没有真正开始流的遍历。

终止操作:一个流只能有一个终止操作,当这个操作执行后,流就被使用光了,无法再被操作。所以这必定是流的最后一个操作。终止操作的执行,才会是真正开始流的遍历,并且会生成一个结果。

还有一个重要的概念流是惰性的在数据源上的计算只有数据在被终止的时候才会被执行。也就是说所有的中间操作都是惰性求值,不遇到终止操作,中间操作的代码是不会执行的。

举个例子:

我们对于一个数字结合进行一个 map 中间操作,将元素乘以 2,同时我们有一个 System.out 语句用于查看代码是否执行了。

List<Integer> l = Arrays.asList(1,2,3,4,5,6,7);        
l.stream().map(i->{
  i = i*2;
  System.out.println(i);
  return i;
});

最终的执行结果是什么也没打印。

那如果我们给他加一个终止操作那,结果如下:

中间操作:2
终止操作:2
中间操作:4
终止操作:4
中间操作:6
终止操作:6
中间操作:8
终止操作:8
中间操作:10
终止操作:10
中间操作:12
终止操作:12
中间操作:14
终止操作:14

这时中间操作和终止操作都执行了,这证明中间操作是惰性的。

还有一个需要注意的点就是,Stream 其实与 IO Stream 的概念是一致的,是不能重复使用的,关闭(执行终止操作后就关闭了)后也是不能使用的。

//用集合生成一个流并进行过滤,过滤后返回一个 stream s1。
List<Integer> l = Arrays.asList(1, 2, 3, 4, 5, 6, 7);
Stream s1 = l.stream().filter(item -> item > 2);

//因为 filter 是中间操作,流并没有被关闭,所以还可以执行其他操作,distnict 是一个终止操作,执行完毕后流就关闭了
s1.distinct();

//流已经关闭了,再执行操作就会抛出异常 
s1.forEach(System.out::println);
Exception in thread "main" java.lang.IllegalStateException: stream has already been operated upon or closed
    at java.util.stream.AbstractPipeline.evaluate(AbstractPipeline.java:229)
    at java.util.stream.ReferencePipeline.forEach(ReferencePipeline.java:418)
    at com.paul.framework.chapter7.StreamCreate.main(StreamCreate.java:48)

Stream 流的 API 采用了建造者设计模式,这就意味着我们可以在一句代码中连续调用 Stream 的 API。

中间操作 API

  • filter

    顾名思义,filter 就是过滤的意思。参数需要我们传入一个 Predicate 类型的函数式接口。不符合 Predicate 函数式接口的条件的流将被过滤出去。

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

    我们需要筛选出分数大于 60 分的学生:

    public static void main(String[] args) {
      List<Student> lists = new ArrayList<>();
      lists.add(new Student("wang",80,"Female"));
      lists.add(new Student("li",95,"Male"));
      lists.add(new Student("zhao",100,"FeMale"));
      lists.add(new Student("qian",54,"Male"));
    
      // filter 是一个中间操作,返回过滤后的 Stream 流。forEach 是一个终止操作,对 filter 过滤之后的流进行处理。
      lists.stream().filter(s->s.getMark()>60).forEach((s)-> System.out.println(s.getName()));
    }
    
    //上一个例子我们对过滤后的流进行了打印操作,我们其实也可以把过滤后的流整理成一个集合
    List<Student> l = lists.stream().filter(s->s.getMark()>60).collect(Collectors.toList());
    l.forEach(s-> System.out.println(s.getName()));

    两次打印的结果是相同的:

    在win64上使用bypy进行百度网盘文件上传

    //第一次打印的结果
    wang
    li
    zhao
    
    //第二次打印的结果
    wang
    li
    zhao

    filter 函数为我们提供了最为简单的方法去过滤集合,避免了重复代码,逻辑也更易懂。

  • map

    通过流的方式对集合中的元素进行匹配操作。参数需要我们传入一个 Function 类型的函数式接口。Function 类型的函数式接口需要一个输入和一个输出,对应映射之前需要的元素和映射之后得到的元素。

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

    比如集合中的元素是学生类,我们最终想要得到的结果是学生的分数,就可以使用 map 方法。

    List<Student> lists = new ArrayList<>();
    lists.add(new Student("wang",80,"Female"));
    lists.add(new Student("li",95,"Male"));
    lists.add(new Student("zhao",100,"FeMale"));
    lists.add(new Student("qian",54,"Male"));
    lists.stream().map(s->s.getMark()).collect(Collectors.toList()).forEach(System.out::println);

    将 list 转换为 stream 后,通过 map 方法将学生类转换成学生成绩的 int 类型,然后通过 collect 方法将流转换为集合,最后通过 forEach 方法将学生成绩打印出来。

    打印的结果:

    80
    95
    100
    54

    比如我们想将集合中的字符串转换成大写字母。

    List<String> list = Arrays.asList("hello","world","helloworld","test");
    list.stream().map(String::toUpperCase).collect(Collectors.toList()).forEach(System.out::println);

    map 方法里我们通过方法引用(将字符串转为大写的方法 String 类已经定义好了,所以我们直接使用方法引用,而不是写一个匿名函数的 Lambda 表达式)将集合中的字符串转换成大写,然后通过 collect 将流转换为集合,最终使用 forEach 方法打印转换后的字符串。

    打印结果:

    HELLO
    WORLD
    HELLOWORLD
    TEST
  • mapTo*

    如果我们的 map 方法返回值是 int,long 或者 double 的话,我们可以直接使用 Stream API 为我们提供了 mapToInt,mapToLong,mapToDouble 方法。这几个方法返回的是 IntStream,LongStream 和 DoubleStream。

    mapToInt, mapToLong 和 mapToDouble 是为了避免自动拆装箱带来的性能损耗。大家应该知道,像 int,long,double 这种基本数据类型是不能使用面向对象相关操作的,为此 Java 引入了自动拆装箱的功能,能够在需要使用面向对象的特性时帮我们将基本数据类型 int,long 和 double 转换为 Integer,Long 和 Double 等包装类型。在需要使用基本数据类型时(比如计算),又可以将包装类型 Integer,Long 和 Double 转换为基本数据类型 int,long 和 double。

    如果我们使用的不对,就会有一些自动拆装箱的性能损耗。

    如果我们需要得到基本数据类型的结果,就可以使用 mapToInt, mapToLong 和 mapToDouble,这样的到的是基本数据类型的流,可以方便我们进行计算等等操作。

    int sum = lists.stream().mapToInt(s->s.getMark()).sum();
    System.out.println(sum);
  • flatMap

    flat 的意思是扁平化,这个函数式的作用是将我们 map 之后的集合或者数组等等元素打散成我们想要的元素。

    flatMap 方法需要返回一个 Stream 数据类型。T 是输入的集合类型元素,R 是打散之后的元素类型,是 Stream 类型。

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

    来看一个例子:

    比如我们的流中以前有三个 ArrayList,map 之后依然后会有三个 ArrayList,flatMap 会将三个 ArrayList 合并到一个 ArrayList 中。

    Stream<List<Integer>> stream = Stream.of(Arrays.asList(1),ArrayList.asList(2,3), ArrayList.asList(4,5,6));
    
    // 将 stream 里面的每一个 list 再次转化为 stream<Integer>,然后在进行 map 操作。
    stream.flatMap(theList->theList.stream()).map(item->item*item).forEach(System.out::println);

    这个例子中,List 代表打散之前的元素,Integer 代表我们打散之后的元素类型。

    JAVA8 之 Stream 流(四)

    在看另外一个例子,字符串去重复。

    List<String> list = Arrays.asList("hello welcome","world hello","hello world hello","hello welcome");
    
    //错误的写法, 这是对 String[] 的 distinct
    List<String[]> result = list.stream().map(item->item.split(" ")).distinct().collect(Collectors.toList());

    split 方法输入的是字符串,返回的是一个字符串数组,所以最后返回的是 String 数组流 Stream<String[]>。

    我们使用 flatMap 将 String 数组打散成 String。

    //正确的写法,要用 flatmap 将 String[] 打散成 String
    List<String> result = list.stream().map(item->item.split(" ")).flatMap(Arrays::stream).distinct().collect(Collectors.toList());

    JAVA8 之 Stream 流(四)

  • flatMapTo*

    flatMapTo* 也有许多具体的实现实现,和 mapTo* 用法类似,这里就不再赘述了。

  • limit

    limit 方法可以对流中需要返回的元素加以限制,因为流中元素的方法执行是严格按照顺序进行的,limit 方法就相当于取前几个元素。

    我们通过下面这个例子来了解 limit 和无限流。

    IntStream.iterate(0, i->(i+1)%2).distinct().limit(6).forEach(System.out::println);

    IntStream.iterate(0, i->(i+1)%2) 不断产生 0,1,0,1,0,1….. 这样的无限流,distinct 方法去除重复,limit 方法虽然限制流中只有 6 个元素,但是 distinct 方法先执行它会对无限流一致执行去复操作,所以方法永远不会结束。这个 limit 在这里也失去了作用。

    JAVA8 之 Stream 流(四)

    执行结果虽然只显示了 0,1。但是方法一直不会结束。

    正确的写法:

    IntStream.iterate(0, i->(i+1)%2).limit(6).distinct().forEach(System.out::println);

    先调用 limit 方法,限制流中只有 6 个元素,然后去重,结果打印 0,1。程序结束。

    JAVA8 之 Stream 流(四)

  • skip

    skip 方法和 limit 方法的用法类似,可以跳过流中的前几个元素。

    IntStream.iterate(0, i->i+1).limit(10).skip(3).forEach(System.out::println);

    首先通过 iterate 和 limit 产生 10 Integer 个元素的流,通过 skip 跳过前三个。最终的结果如下:

    3
    4
    5
    6
    7
    8
    9
  • sort

    sort 方法有两个实现,一个是不需要传入参数的,另一个是需要我们传入 Comparator。

    //根据自然顺序排序
    Stream<T> sorted();
    //根据 Comparator 的规则进行排序
    Stream<T> sorted(Comparator<? super T> comparator);

    我们以前对集合排序时通常会使用 JDK 中 Collection 接口的 sort 方法:

    List<String> names = Arrays.asList("java8","lambda","method","class");
    
    //以前的写法
    Collections.sort(names, new Comparator<String>() {
      @Override
      public int compare(String o1, String o2) {
        return o2.compareTo(o1);
      }
    });

    使用 Lambda 表达式对上面的写法进行一下改进:

    Collections.sort(names,(o1,o2)-> o2.compareTo(o1));

    现在我们还可以使用 Stream API 中的 sorted 方法:

    names.stream().sorted().forEach(System.out::println);
    names.stream().sorted((o1,o2)-> o2.compareTo(o1)).forEach(System.out::println);

    结果:

    class
    java8
    lambda
    method 

曹工杂谈–使用mybatis的同学,进来看看怎么在日志打印完整sql吧,在数据库可执行那种

未经允许不得转载:www.xssyun.com作者:站长, 转载或复制请以 超链接形式 并注明出处 xss云之家-资源网,新人技术交流平台,一个湖北娃的个人博客
原文地址:《JAVA8 之 Stream 流(四)》 发布于2020-01-01

分享到:
赞(0) 生成海报

长按图片转发给朋友

投稿赚钱
2020年在家赚取零花钱
切换注册

登录

忘记密码 ?

您也可以使用第三方帐号快捷登录

Q Q 登 录
微 博 登 录
切换登录

注册