持续创作，加速成长！这是我参与「掘金日新计划 · 6 月更文挑战」的第1天，点击查看活动详情

在工作中经常要对数据结构做各种操作，使用stream来操作数据可以打打提升我们的开发效率

下面我们就来学习一下吧

遍历元素

        List<String> c = new ArrayList<>(Arrays.asList("H", "o", "o", "W"));

        c.stream()
                .map(a -> a + "!!")
                .forEach(System.out::println); //H!! o!! o!! W!!

使用map()方法将字符串添加到每个元素

使用filter过滤器对元素进行判断和提取

        List<String> c = new ArrayList<>(Arrays.asList("H", "o", "o", "W"));

        c.stream()
                .filter(a -> a.startsWith("o"))
                .forEach(System.out::println); //o o

每个元素都通过filter()方法进行判断，如果字符串的开头与参数的值匹配，则startWith()方法返回 true。

去重

        List<String> c = new ArrayList<>(Arrays.asList("H", "o", "o", "W"));

        c.stream()
                .distinct()
                .forEach(System.out::println); //H o W

distinct()去除List中重复的值

排序

        List<String> c = new ArrayList<>(Arrays.asList("H", "o", "o", "W"));

        c.stream()
                .sorted()
                .forEach(System.out::println); // H W o o

       c.stream()
                .sorted(Comparator.reverseOrder())
                .forEach(System.out::println); // o o W H

sorted()默认升序排列，如果将Comparator接口的静态方法的reverseOrder()方法指定为sorted()方法的参数，则输出与默认顺序是相反的

限制数量

        List<String> c = new ArrayList<>(Arrays.asList("H", "o", "o", "W"));

        c.stream()
                .limit(2)
                .forEach(System.out::println); // H o

limit()方法限制元素的数量

跳过元素

        List<String> c = new ArrayList<>(Arrays.asList("H", "o", "o", "W"));
        c.stream()
                .skip(2)
                .forEach(System.out::println); // o W

skip()值为跳过的元素个数

获取元素个数

        List<String> c = new ArrayList<>(Arrays.asList("H", "o", "o", "W"));
        long a = c.stream().count();
        System.out.println(a); // 4

count()返回元素的数量

获取第一个元素

        List<String> c = new ArrayList<>(Arrays.asList("H", "o", "o", "W"));

        Optional list = c.stream().findFirst();
        System.out.println(list.get()); // H

使用findFirst()方法获取第一个元素。

返回List

        List<String> c = new ArrayList<>(Arrays.asList("H", "o", "o", "W"));
        List list = c.stream()
                .map(a -> a + "!!")
                .collect(Collectors.toList());
        System.out.println(list); //[H!!, o!!, o!!, W!!]

使用collect() + toList() 返回一个List列表

所有元素条件匹配

        List<Integer> c = new ArrayList<>(Arrays.asList(3,4,5,6));
        boolean aa = c.stream()
                .allMatch(b -> b > 1); //所有元素都大于1
        System.out.println(aa); //true

        boolean bb = c.stream()
                .allMatch(d -> d > 6); //所有元素都大于6
        System.out.println(bb); //false

如果满足条件，则返回true，否则返回false

任何元素条件匹配

        List<Integer> c = new ArrayList<>(Arrays.asList(3,4,5,6));
        boolean aa = c.stream()
                .anyMatch(b -> b > 1); //任何元素都大于1
        System.out.println(aa); //true

        boolean bb = c.stream()
                .anyMatch(d -> d > 6); //任何元素都大于6
        System.out.println(bb); //false

任何元素的条件匹配，则返回true，否则返回false

任何符合条件的元素（noneMatch）

        List<Integer> c = new ArrayList<>(Arrays.asList(3,4,5,6));
        boolean aa = c.stream()
                .noneMatch(b -> b > 1); //是否含有大于1的元素
        System.out.println(aa); //false

        boolean bb = c.stream()
                .noneMatch(d -> d > 6); //是否含有大于6的元素
        System.out.println(bb); //true

如果没有匹配项，则noneMatch()方法返回 true

并行处理

       List<String> c = new ArrayList<>(Arrays.asList("H", "o", "o", "W"));
        c.parallelStream()
                .map(a -> a + "!!")
                .forEach(System.out::println);

        c.stream()
                .parallel()
                .map(a -> a + "??")
                .forEach(System.out::println);
// o!! W!! H!! o!! o?? H?? W?? o??

在parallelStream()和parallel()中元素是并行处理的，所以返回值的顺序不固定

数组中使用流

要在数组中实例化Stream，需要使用Arrays类的stream()方法。Arrays类是用于操作数组的类。

        String[] arr = {"H", "o", "o", "W"};
        long a = Arrays.stream(arr).count();
        System.out.println(a); // 4

count()返回元素的数量。

使用Java Stream便捷的操作数据