JDK8中的Streams API

1.为什么需要stream

  stream作为JDK8的一大亮点,它和IO中的输入流或者输出流不是一个概念。在JDK8中,它是对集合对象的功能增强,针对集合对象它提供了各种非常便利的高效聚合操作,并且配合JDK8的Lambda表达式和函数式编程使得对集合的各种操作更加简单。同时还提供了串行和并行两种模式进行对集合的操作。通常编写并发的代码很容易出错,而使用Stream API只需要简单的添加一行代码就能够达到安全高效的并发操作。当一个Stream是并行化的,就无需在写多变成的代码,它使用JDK1.7的FORK/JOIN框架将数据分成多个段,其中每一个都在不同的线程中处理。

2.什么是stream

  stream不是一种数据结构,它并没有存储数据,它只是类似一个高级的Iterator,从source(数组、集合、IO等)抓取数据,它并不会修改自己封装的底层数据结构的数据。

  流的操作分为两种:

  Intermediate:一个流后面可以跟一个或多个Intermediate操作。其目的主要是打开流,做出某种程度的数据映射/过滤,然后返回一个新的流,交给下一个操作使用。这些操作都是惰性化的,就是仅仅调用到这类方法,还没有开始遍历集合。

  Terminal:一个流只能有一个terminal操作,当这个操作执行完毕后,这个流就被“消费完了”,无法再被操作。所以termainal操作必定是流的最后一个操作,执行了该操作才会对流进行真正的遍历。

  这里要注意的是多个Intermediate并不是多次for循环,而是将该操作先放到一个集合中,在terminal操作中几种处理。

  short-circuiting:

  对于一个 intermediate 操作,如果它接受的是一个无限大(infinite/unbounded)的 Stream,但返回一个有限的新 Stream。

   对于一个 terminal 操作,如果它接受的是一个无限大的 Stream,但能在有限的时间计算出结果。

 

3.流的使用详解

 流的创建:

 public static void main(String[] args) {
        // 单个元素
        Stream stream = Stream.of("a", "b", "c");
        // 数组
        String[] arr = new String[]{"a", "b", "c"};
        stream = Arrays.stream(arr);
        stream = Stream.of(arr);
        // 集合
        List<String> list = Arrays.asList(arr);
        stream = list.stream();
        /**
         * Stream提供了IntStream、LongStream、DoubleStream来专门处理基本数值类型
         * 当然也可以使用Stream<Integer>、Stream<Long>、Stream<Double>来处理,但是
         * 自动装箱和拆箱会额外耗费性能
         */
       IntStream.of(1,2,3).forEach(System.out::println);
 }

  流的转换:

 public static void main(String[] args) {
        Stream<String> stream = Arrays.stream(new String[]{"a","b","c"});
        // 数组
        String[] arr1 = stream.toArray(String[]::new);
        // 集合
        List<String> list1 = stream.collect(Collectors.toList());
        ArrayList<String> list2 = stream.collect(Collectors.toCollection(ArrayList::new));
        Set<String> collect = stream.collect(Collectors.toSet());
        Stack<String> stack = stream.collect(Collectors.toCollection(Stack::new));
        // String
        String string = stream.collect(Collectors.joining()).toString();
 }

  流的操作:

  Intermediate:

  map(mapToInt,flatMap等)、filter、distinct、sorted、peek、limit、skip、parallel、sequential、unordered

  Terminal:

  forEach、 forEachOrdered、 toArray、 reduce、 collect、 min、 max、 count、 anyMatch、 allMatch、 noneMatch、 findFirst、 findAny、 iterator

  short-circuiting:

  anyMatch、 allMatch、 noneMatch、 findFirst、 findAny、 limit

 

  map:

    /**
     * 将下列集合中的所有数字乘以10,并得到新集合[1, 20, 63, 58, 185, 60, 59, 20]
     */
    @Test
    public void show4(){
        Integer[] nums = {1, 20, 63, 58, 185, 60, 59, 20};
        Integer[] integers = Arrays.stream(nums).map(i -> i * 10).toArray(Integer[]::new);
        Arrays.stream(integers).forEach(System.out::println);
    }

  从上面的例子可以看出,map是1对1映射,将每个输入的元素都按照规则转换成输出的元素。有些场景需要一对多映射,那么就可以使用flatMap

  @Test
    public void test14(){
        Stream<List<Integer>> inputStream = Stream.of(
                Arrays.asList(1),
                Arrays.asList(2, 3),
                Arrays.asList(4, 5, 6)
        );
        Stream<Integer> outputStream = inputStream.
                flatMap((childList) -> childList.stream());
        List<Integer> collect = outputStream.collect(Collectors.toList());
    }


 filter:

 filter 对原始 Stream 进行某项测试,通过测试的元素被留下来生成一个新 Stream。

    /**
     * 将数组或者集合中不小于50的数输出出来
     */
    @Test
    public void show() {
        int[] a = {1, 20, 63, 58, 185, 60, 59, 20};
        Arrays.stream(a).filter(value -> {return value>=50;}).forEach(System.out::print);
    }

 

 forEach:
  forEach 方法接收一个 Lambda 表达式,然后在 Stream 的每一个元素上执行该表达式。

    /**
     * 输出下列集合中相同的字符串
     */
    @Test
    public void show3(){
        String[] s1 = {"qwer", "asdf", "zxcv", "fgh", "jum", "rfv"};
        String[] s2 = {"edc", "zse", "asdf", "zxcv", "yhnj"};
        Arrays.stream(s1).forEach(x->{Arrays.stream(s2).filter(y->{return x.equals(y);}).forEach(System.out::println);});
    }

 reduce:

 这个方法的主要作用是把 Stream 元素组合起来。它提供一个起始值(种子),然后依照运算规则(BinaryOperator),和前面 Stream 的第一个、第二个、第 n 个元素组合。从这个意义上说,字符串拼接、数值的 sum、min、max、average 都是特殊的 reduce。

    @Test
    public void test15() {
        // 字符串连接,concat = "ABCD"
        String concat = Stream.of("A", "B", "C", "D").reduce("", String::concat);
        // 求最小值,minValue = -3.0
        double minValue = Stream.of(-1.5, 1.0, -3.0, -2.0).reduce(Double.MAX_VALUE, Double::min);
        // 求和,sumValue = 10, 有起始值
        int sumValue = Stream.of(1, 2, 3, 4).reduce(0, Integer::sum);
        // 求和,sumValue = 10, 无起始值
        sumValue = Stream.of(1, 2, 3, 4).reduce(Integer::sum).get();
    }

 limit/skip:

 limit 返回 Stream 的前面 n 个元素;skip 则是扔掉前 n 个元素(它是由一个叫 subStream 的方法改名而来)。

    /**
     * 取出下列集合中的第3到7个值,加上5,得到新的集合[1, 20, 63, 58, 185, 60, 59, 20]
     */
    @Test
    public void show5() {
        Integer[] nums = {1, 20, 63, 58, 185, 60, 59, 20};
        Integer[] integers = Arrays.stream(nums).skip(2).limit(5).map(i -> i + 5).toArray(Integer[]::new);
        System.out.println(Arrays.toString(integers));
    }

  sorted:

  对 Stream 的排序通过 sorted 进行,它比数组的排序更强之处在于你可以首先对 Stream 进行各类 map、filter、limit、skip 甚至 distinct 来减少元素数量后,再排序,这能帮助程序明显缩短执行时间。

    /**
     * 将下列名字转换为大写,再排序输出("Fred Edwards", "Anna Cox", "Deborah Patterson", "Ruth Torres", "Shawn Powell")
     */
    @Test
    public void test10() {
        String[] str = {"Fred Edwards", "Anna Cox", "Deborah Patterson", "Ruth Torres", "Shawn Powell"};
        Arrays.stream(str).map(p -> p.toUpperCase()).sorted().forEach(System.out::println);
    }

 min/max/distinct:

 min 和 max 的功能也可以通过对 Stream 元素先排序,再 findFirst 来实现,但前者的性能会更好,为 O(n),而 sorted 的成本是 O(n log n)。同时它们作为特殊的 reduce 方法被独立出来也是因为求最大最小值是很常见的操作。

    /**
     * 输出下列集合的最小值[1, 20, 63, 58, 185, 60, 59, 20]
     */
    @Test
    public void show6() {
        int[] nums = {1, 20, 63, 58, 185, 60, 59, 20};
        System.out.println(Arrays.stream(nums).min().getAsInt());
    }

  Match:

  allMatch: Stream中所有元素全部匹配才返回true

  anyMatch:Stream中只要一个元素匹配就返回true

  noMatch: Stream中没有一个元素匹配才返回true

    /**
     * 判断下列数组或集合中的数是否全部大于50
     */
    @Test
    public void show2() {
        int[] a = {1, 20, 63, 58, 185, 60, 59, 20};
        boolean b = Arrays.stream(a).allMatch(value -> value > 50);
        System.out.println(b);
    }

reduce:

 public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("s1");
        list.add("s2");
        list.add("s3");
        list.add("s4");
        // reduce会返回一个Optional对象
        Optional<String> reduce = list.stream().reduce((s, s2) -> s.concat(s2.toUpperCase())); 
        reduce.ifPresent(System.out::println);//s1S2S3S4
    }

并行stream:使用stream()方法获得的流是串行操作,如果考虑性能可以使用并行parallelStream

  public static void main(String[] args) {
        int max = 1000000;
        List<String> list = new ArrayList<>();
        for (int i = 0; i < max; i++) {
            list.add(UUID.randomUUID().toString());
        }

        long begin = System.currentTimeMillis();
        //long count = list.stream().sorted().count();//625ms
        long count = list.parallelStream().sorted().count();//375ms
        long end = System.currentTimeMillis();
        System.out.println(String.format("cost %dms",end - begin));
    }
 
  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值