java stream优雅的操作流,stream的常见操作

导读:本篇文章讲解 java stream优雅的操作流,stream的常见操作,希望对大家有帮助,欢迎收藏,转发!站点地址:www.bmabk.com

关于stream流的操作网上有很多教程,

比如流里的 filter、map、flatMap、collect、reduce、limit、distinct、skip、findFirst、count等常用操作。

如对基本概念不熟,可参考其他博客:
JAVA8 Stream接口,map操作,filter操作,flatMap操作
java8 stream流操作的flatMap(流的扁平化)
Java 8 Stream 的终极技巧——Collectors 操作

本文主要讲开发中常用的流操作,熟练使用可简化代码、使代码更简洁优雅。

目录:

List<String> 转 List<Integer>
List<String> 转 Integer[]
String[] 转 List<String>
String[] 转  Integer [] 
int [] 转 List<Integer>
int [] 转 Integer [] 
int [] 最大、最小值、平均值,求和
String[] 对每个元素分割并转换为其他类型
List<String> 逗号拼接为一个字符串
List<Integer> 逗号拼接为一个字符串
生成指定范围的数组
判断数组中是否含有某一值
数组或 List 求和
两个数组合并为一个新的数组
两个数组合并为一个 List
两个 List合 并为一个新的 List
List<Integer>求交集、并集、差集
Map 的 value 保存为 List、Set
Map<String, List<Integer>>获取所有的values为一个List<Integer>
String[] 中的元素转大写并转为 List<String>
List<String> 中统计首字母是j的个数
List<String> 中获取第一个首字母是j的元素
List<String> 统计各字符串出现的次数
List 去除重复元素
List<List<String>> 转List<String>
List<Object> 转 Map<String, Object>
List<Object> 针对某一成员变量获取最大、小值的 Object
List<Object> 获取某个成员变量最大、最小值、平均值,求和
List<Integer> 获取最大、最小值、平均值,求和

List<String> 转 List<Integer>

如果 strList 中全是数字字符串,可通过如下转换为 integerList

        List<String> strList = new ArrayList<>(Arrays.asList("7","8","9"));
        List<Integer> integerList = strList.stream().map(v -> Integer.valueOf(v)).collect(Collectors.toList());

List<String> 转 Integer[ ]

如果 strList 中全是数字字符串,可通过如下转换为 intergerArry

        List<String> strList = new ArrayList<>(Arrays.asList("7","8","9"));
        Integer[] intergerArry = strList.stream().map(v -> Integer.valueOf(v)).toArray(Integer[]::new);

String[ ] 转 List<String>

        String[] array = new String[]{"aa","bb","cc"};
        List<String> strList = Arrays.stream(array).collect(Collectors.toList());

String[ ] 转 Integer [ ]

        String[] strArry = new String[]{"5", "6", "1", "4", "9"};
        Integer[] integerArry = Arrays.stream(strArry).map(Integer::parseInt).toArray(Integer[]::new);

int [ ] 转 List<Integer>

        int[] intArry = new int[]{5,6,1,4,9};
        List<Integer> integerList = Arrays.stream(intArry).boxed().collect(Collectors.toList());

int [ ] 转 Integer [ ]

        int[] intArry = new int[]{5, 6, 1, 4, 9};
        Integer[] integerArry = Arrays.stream(intArry).boxed().toArray(Integer[]::new);

int [] 最大、最小值、平均值,求和

        int[] intArray = {12,3,34,67,100,99};
        IntStream intStream = IntStream.of(intArray);
        IntSummaryStatistics statistics = intStream.summaryStatistics();
        System.out.println("the max:" + statistics.getMax());
        System.out.println("the min:" + statistics.getMin());
        System.out.println("the average:" + statistics.getAverage());
        System.out.println("the sum:" + statistics.getSum());
        System.out.println("the count:" + statistics.getCount());

String[] 对每个元素分割并转换为其他类型

        String[] array = {"a-1", "b-2", "c-3"};
        
        //"-分割后获取字母,转为新数组
        String[] strArray = Arrays.stream(array).map(v -> v.split("")[0]).flatMap(Stream::of).toArray(String[]::new);
        //"-分割后获取字母,转List
        List<String> list = Arrays.stream(array).map(v -> v.split("")[0]).flatMap(Stream::of).collect(Collectors.toList());
        //"-分割后获取字母,用逗号拼接为字符串
        String str = Arrays.stream(array).map(v -> v.split("")[0]).flatMap(Stream::of).collect(Collectors.joining(","));

        System.out.println(Arrays.toString(strArray));//[a, b, c]
        System.out.println(list);//[a, b, c]
        System.out.println(str);//a,b,c

List<String> 逗号拼接为一个字符串

        List<String> strList = new ArrayList<>(Arrays.asList("a","b","c"));
        String str = strList.stream().collect(Collectors.joining(","));
        System.out.println(str);//a,b,c

List<Integer> 逗号拼接为一个字符串

        List<Integer> integerList = Arrays.asList(7, 8, 9);
        String str = integerList.stream().map(v->String.valueOf(v)).collect(Collectors.joining(","));
        System.out.println(str);//7,8,9

生成指定范围的数组

  • 生成[0,100)的 int[ ]
        int[] intArray = IntStream.range(0, 100).toArray();
  • 生成[0,100]的 int[ ]
        int[] intArray1 = IntStream.rangeClosed(0, 100).toArray();

判断数组中是否含有某一值

  • 字符串数组
        String[] values = {"AB","BC","CD","AE"};
        boolean contains = Arrays.stream(values).anyMatch("AE"::equals);
  • int数组
        int[] a = {1,2,3,4};
        boolean contains = IntStream.of(a).anyMatch(x -> x == 4);

数组或List求和

  • 数组求和
        int[] intArray = {11, 5, 3, 2, 1};
        int sum = Arrays.stream(intArray).reduce(0, Integer::sum);
  • List求和
        List<Integer> list = new ArrayList<>(Arrays.asList(5, 1, 7, 10));
        int sum = list.stream().reduce(0, Integer::sum);

两个数组合并为一个新的数组

  • 两个字符串数组合并为一个新的数组
        String[] a = {"a", "b", "c"};
        String[] b = {"1", "2", "3"};
        String[] c = Stream.of(a,b).flatMap(Stream::of).toArray(String[]::new);
  • 两个 int 型数组合并为一个新的 int 型数组
        int[] a = new int[]{1,3};
        int[] b = new int[]{2,4};
        int[] c =  IntStream.concat(Arrays.stream(a), Arrays.stream(b)).toArray();

两个数组合并为一个List

  • 两个String数组转List<String>
        String[] a = {"a", "b", "c"};
        String[] b = {"1", "2", "3"};
        List<String> strList = Stream.of(a, b).flatMap(Stream::of).collect(Collectors.toList());
  • 两个int数组转List<Integer>
        int[] a = new int[]{1, 2};
        int[] b = new int[]{3, 4};
        List<Integer> integerList = Stream.of(IntStream.of(a).boxed(), IntStream.of(b).boxed()).flatMap(s -> s).collect(Collectors.toList());

两个List合并为一个新的List

        List<String> lis1 = new ArrayList<>(Arrays.asList("a", "b", "c"));
        List<String> list2 = new ArrayList<>(Arrays.asList("e", "f", "g"));
        List<String> newList = Stream.of(lis1, list2).flatMap(Collection::stream).collect(Collectors.toList());

List<Integer>求交集、并集、差集

List<Integer> list = new ArrayList<>(Arrays.asList(7, 8, 9));
List<Integer> list2 = new ArrayList<>(Arrays.asList(3,4, 9));

对 list 和 list2求交集、并集、差集

//交集
 List<Integer> beMixed = list.stream().filter(list2::contains).collect(Collectors.toList());
 System.out.println(beMixed);//[9]

//并集
List<Integer> aggregate = Stream.of(list, list2).flatMap(Collection::stream).distinct().collect(Collectors.toList());
System.out.println(aggregate);//[7, 8, 9, 3, 4]

//差集
List<Integer> subtraction = list.stream().filter(v->!list2.contains(v)).collect(Collectors.toList());
System.out.println(subtraction);//[7, 8]

Map的value保存为List、Set

  • 保存为List
        Map<String, String> map = new HashMap<>();
        map.put("1", "a");
        map.put("2", "b");
        map.put("3", "c");
        List<String> values = map.values().stream().collect(Collectors.toList());
  • 保存为Set
        Map<String, String> map = new HashMap<>();
        map.put("1", "a");
        map.put("2", "b");
        map.put("3", "c");
        Set<String> values = map.values().stream().collect(Collectors.toSet());

Map<String, List<Integer>>获取所有的values为一个List<Integer>

将map 里的所有value合并为一个List

       List<Integer> list1 = new ArrayList<>(Arrays.asList(1, 2, 3));
        List<Integer> list2 = new ArrayList<>(Arrays.asList(4, 5, 6));
        List<Integer> list3 = new ArrayList<>(Arrays.asList(7, 8, 9));

        Map<String, List<Integer>> map = new HashMap<>();
        map.put("a", list1);
        map.put("b", list2);
        map.put("c", list3);

        List<Integer> list = map.entrySet().stream().map(e -> e.getValue()).flatMap(Collection::stream).collect(Collectors.toList());
        System.out.println(list);//[1, 2, 3, 4, 5, 6, 7, 8, 9]

String[]中的元素转大写并转为List<String>

        String[] strArray= { "java", "react", "angular", "vue" };
        List<String> list = Stream.of(strArray).map(test -> test.toUpperCase()).collect(Collectors.toList());

List<String>中统计首字母是j的个数

        List<String> list = Arrays.asList("java", "react", "angular", "javascript", "vue");
        long count = list.stream().filter(p -> p.startsWith("j")).count();

List<String>中获取第一个首字母是j的元素

        List<String> list = Arrays.asList( "react","java", "angular", "javascript", "vue");
        //java
        String firstJ = list.stream().filter(p -> p.startsWith("j")).findFirst().get();

List<String>统计各字符串出现的次数

        List<String> items = Arrays.asList("apple", "apple", "orange", "orange", "orange", "blueberry", "peach", "peach", "peach", "peach");
        Map<String, Long> result = items.stream().collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));
        //{orange=3, apple=2, blueberry=1, peach=4}
        System.out.println(result);

List去除重复元素

        List<String> list = Arrays.asList("aa", "bb", "cc", "bb");
        List<String> distinctList = list.stream().distinct().collect(Collectors.toList());

List<List<String>>转List<String>

        List<String> a = Arrays.asList("Virat", "Dhoni", "Jadeja");
        List<String> b = Arrays.asList("1", "2", "3");
        List<List<String>> list = new ArrayList<>();
        list.add(a);
        list.add(b);

        List<String> newList = list.stream().flatMap(v -> v.stream()).collect(Collectors.toList());
        //[Virat, Dhoni, Jadeja, 1, 2, 3]
        System.out.println(newList);

List<Object>转Map<String, Object>

假设有Student类,里面含有id、name、score等信息。现在想把 List<Student> 转化为Map<String,Student>,其中key是name。

        List<Student> list = new ArrayList<>();
        list.add(new Student(1, "张三", 85));
        list.add(new Student(2, "李四", 60));
        Map<String, Student> map = list.stream().collect(Collectors.toMap(Student::getName, Function.identity()));

List<Object>针对某一成员变量获取最大、小值的Object

假设有 Student 类,里面含有 id、name、score 等信息。现在想获取List<Student> 中 score 最大的 Student 和 score 最小的 Student。

        List<Student> list = new ArrayList<>();
        list.add(new Student(1, "张三", 85));
        list.add(new Student(2, "李四", 60));
        list.add(new Student(3, "刘一", 70));
        list.add(new Student(4, "李四", 99));
        //获取score最大值
        Optional<Student> maxOptStudent = list.stream().collect(Collectors.maxBy(Comparator.comparing(Student::getScore)));
        Student maxStudent = maxOptStudent.get();
        //获取score最小值
        Optional<Student> mixOptStudent = list.stream().collect(Collectors.minBy(Comparator.comparing(Student::getScore)));
        Student minxStudent = mixOptStudent.get();

List<Object>获取某个成员变量最大、最小值、平均值,求和

假设有 Student 类,里面含有 id、name、score 等信息。现在想获取 List<Student> 中的 score 的最大值、最小值、平均值,求和

        List<Student> list = new ArrayList<>();
        list.add(new Student(1, "小名", 17));
        list.add(new Student(2, "小红", 18));
        list.add(new Student(3, "小蓝", 19));
        list.add(new Student(4, "小灰", 20));
        list.add(new Student(5, "小黄", 21));
        list.add(new Student(6, "小白", 22));
        
        IntSummaryStatistics intSummary = list.stream().collect(Collectors.summarizingInt(Student::getScore));
        System.out.println(intSummary.getAverage());// 19.5
        System.out.println(intSummary.getMax());// 22
        System.out.println(intSummary.getMin());// 17
        System.out.println(intSummary.getSum());// 117

List 获取最大、最小值、平均值,求和

        List<Integer> list = new ArrayList<>(Arrays.asList(12,3,34,67,100,99));
        IntSummaryStatistics statistics = list.stream().mapToInt(value -> value).summaryStatistics();
        System.out.println("the max:" + statistics.getMax());
        System.out.println("the min:" + statistics.getMin());
        System.out.println("the average:" + statistics.getAverage());
        System.out.println("the sum:" + statistics.getSum());
        System.out.println("the count:" + statistics.getCount());

拓展:
除了anyMatch ,stream 中还有 allMatch、noneMatch ,可以参考 java8新特性Stream流中anyMatch和allMatch和noneMatch的区别详解

版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。

文章由极客之家整理,本文链接:https://www.bmabk.com/index.php/post/80187.html

(0)
小半的头像小半

相关推荐

极客之家——专业性很强的中文编程技术网站,欢迎收藏到浏览器,订阅我们!