Java 8 之 Stream 详细示例

快来打我* 2022-12-27 12:54 147阅读 0赞

该实例来源于：[https://www.runoob.com/java/java8-streams.html][https_www.runoob.com_java_java8-streams.html]

在此表示感谢，如有感到冒犯，请联系删除！！

import java.util.*;
    import java.util.stream.Collectors;
    
    public class StreamTest {
        public static void main(String[] args) {
    
            System.out.println("--- 使用 Java 7 ---");
            // String 字符串的操作
            List<String> strList = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
            System.out.println("--- 列表：" + strList);
            // 计算列表中和空字符串的数量
            long emptyCount = getCountEmptyStringUsingJava7(strList);
            System.out.println("--- 空字符数量为：" + emptyCount);
            // 计算列表中长度为 3 的字符串的数量
            long thirdCount = getCountLength3UsingJava7(strList);
            System.out.println("--- 字符串长度为 3 的数量为：" + thirdCount);
            // 删除空字符串
            List<String> deleteStr = deleteEmptyStringsUsingJava7(strList);
            System.out.println("--- 删除空字符串之后的列表: " + deleteStr);
            // 删除空字符串，并使用逗号把非空的各个字符串合并
            String mergedNotEmptyStr = getMergedStringUsingJava7(strList,", ");
            System.out.println("--- 合并字符串：" + mergedNotEmptyStr);
            // 整型数据的操作
            List<Integer> intList = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
            System.out.println("--- 列表1: " + intList);
            // 对列表中的每个元素求平方
            List<Integer> squaresList = getSquares(intList);
            System.out.println("--- 对列表1中各元素求平方：" + squaresList);
            // 对列表进行 max、min 等操作
            List<Integer> numberList = Arrays.asList(1,2,13,4,15,6,17,8,19);
            System.out.println("--- 列表2: " + numberList);
            System.out.println("--- 列表2中最大的数是：" + getMax(numberList));
            System.out.println("--- 列表2中最小的数是：" + getMin(numberList));
            System.out.println("--- 列表2中的所有数之和是：" + getSum(numberList));
            System.out.println("--- 列表2中各数的平均数是：" + getAverage(numberList));
            // 随机数的操作
            System.out.println("--- 随机数：");
            // 输出10个随机数
            Random random = new Random();
            for(int i = 0; i < 10; i++){
                System.out.println(i + 1 + ": " + random.nextInt());
            }
    
            System.out.println();
            System.out.println("--- 使用 Java 8 ---");
            System.out.println("--- 列表：" + strList);
            // 使用 Java 8 语法求空字符串的数量
            emptyCount = strList.stream().filter(string -> string.isEmpty()).count();
            System.out.println("--- 空字符串数量为：" + emptyCount);
            // 并行处理，计算空字符串的数量空字符串
            emptyCount = strList.parallelStream().filter(string -> string.isEmpty()).count();
            System.out.println("--- 并行计算空字符串的数量为: " + emptyCount);
            // 使用 Java 8 语法求字符串长度为3的字符串数量
            thirdCount = strList.stream().filter(string -> string.length() == 3).count();
            System.out.println("--- 字符串长度为 3 的数量为：" + thirdCount);
            // 使用 Java 8 语法将空字符串过滤
            List<String> filterStr= strList.stream().filter(string -> !string.isEmpty()).collect(Collectors.toList());
            System.out.println("--- 过滤掉空字符串之后的列表：" + filterStr);
            // 用逗号将非空字符串连接成一个字符串
            String mergedString = strList.stream().filter(string -> !string.isEmpty()).collect(Collectors.joining(","));
            System.out.println("--- 合并非空字符串：" + mergedString);
            // 对整型数据类型的列表中的各个元素使用 Java 8 语法求平方
            squaresList = intList.stream().map( i -> i * i).distinct().collect(Collectors.toList());
            System.out.println("--- 使用 Java 8 语法对列表1各元素求平方之后：" + squaresList);
            // 输出用于计算 max、min 等的列表
            System.out.println("--- 列表2：" + numberList);
            // 对列表进行统一计算，即 max、min、avg等
            IntSummaryStatistics result = numberList.stream().mapToInt((x) -> x).summaryStatistics();
            System.out.println("--- 列表2中最大的数是：" + result.getMax());
            System.out.println("--- 列表2中最小的数是：" + result.getMin());
            System.out.println("--- 列表2中的所有数之和是：" + result.getSum());
            System.out.println("--- 列表2中的所有数的平均数是：" + result.getAverage());
            // Java 8 对随机数的操作
            System.out.println("--- Java 8 输出有序随机数：");
            random.ints().limit(10).sorted().forEach(System.out::println);
    
        }
    
        /**
         * 计算空字符串的数量
         * @param strings
         * @return
         */
        private static int getCountEmptyStringUsingJava7(List<String> strings){
            int count = 0;
            for(String string: strings){
                if(string.isEmpty()){
                    count++;
                }
            }
            return count;
        }
    
        /**
         * 计算长度为3的字符串的数量
         * @param strings
         * @return
         */
        private static int getCountLength3UsingJava7(List<String> strings){
            int count = 0;
            for(String string: strings){
                if(string.length() == 3){
                    count++;
                }
            }
            return count;
        }
    
        /**
         * 删除空字符串
         * @param strings
         * @return
         */
        private static List<String> deleteEmptyStringsUsingJava7(List<String> strings){
            List<String> filteredList = new ArrayList<String>();
            for(String string: strings){
                if(!string.isEmpty()){
                    filteredList.add(string);
                }
            }
            return filteredList;
        }
        /**
         * 合并非空字符串
         * @param strings
         * @param separator
         * @return
         */
        private static String getMergedStringUsingJava7(List<String> strings, String separator){
            StringBuilder stringBuilder = new StringBuilder();
            for(String string: strings){
                if(!string.isEmpty()){
                    stringBuilder.append(string);
                    stringBuilder.append(separator);
                }
            }
            String mergedString = stringBuilder.toString();
            return mergedString.substring(0, mergedString.length()-2);
        }
    
        /**
         * 对列表中的各元素求平方
         * @param numbers
         * @return
         */
        private static List<Integer> getSquares(List<Integer> numbers){
            List<Integer> squaresList = new ArrayList<Integer>();
            for(Integer number: numbers){
                Integer square = new Integer(number.intValue() * number.intValue());
                if(!squaresList.contains(square)){
                    squaresList.add(square);
                }
            }
            return squaresList;
        }
        /**
         * 求列表中元素的最大值
         * @param numbers
         * @return
         */
        private static int getMax(List<Integer> numbers){
            int max = numbers.get(0);
            for(int i = 1;i < numbers.size();i++){
                Integer number = numbers.get(i);
                if(number.intValue() > max){
                    max = number.intValue();
                }
            }
            return max;
        }
        /**
         * 求列表中元素的最小值
         * @param numbers
         * @return
         */
        private static int getMin(List<Integer> numbers){
            int min = numbers.get(0);
            for(int i=1;i < numbers.size();i++){
                Integer number = numbers.get(i);
                if(number.intValue() < min){
                    min = number.intValue();
                }
            }
            return min;
        }
        /**
         * 对列表中元素求和
         * @param numbers
         * @return
         */
        private static int getSum(List numbers){
            int sum = (int)(numbers.get(0));
            for(int i=1;i < numbers.size();i++){
                sum += (int)numbers.get(i);
            }
            return sum;
        }
        /**
         * 对列表中元素求平均值
         * @param numbers
         * @return
         */
        private static int getAverage(List<Integer> numbers){
            return getSum(numbers) / numbers.size();
        }
    
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW9tdWJhaQ_size_16_color_FFFFFF_t_70][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW9tdWJhaQ_size_16_color_FFFFFF_t_70 1][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW9tdWJhaQ_size_16_color_FFFFFF_t_70 2][]

示例：将列表中的元素求平方之后排序输出各平方值；字符串列表转map

import java.util.*;
    import java.util.stream.Collectors;
    
    public class StreamTest {
        public static void main(String[] args) {
    
            List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
            System.out.println("--- 列表：" + numbers);
            // 求列表中各数的平方，不去重
            List<Integer> squares = numbers.stream().map( i -> i * i).collect(Collectors.toList());
            System.out.print("--- 列表中各数的平方为：" + squares);
            System.out.println();
            List<Integer> squaresDistinct = numbers.stream().map( i -> i * i).distinct().collect(Collectors.toList());
            System.out.print("--- 列表中各数的平方去重之后为：" + squaresDistinct);
            System.out.println();
            // 对列表中的元素求平方并排序输出
            List<Integer> squaresSort = numbers.stream()
                    .map(i -> i * i)
                    .sorted((x, y) -> x - y)
                    .collect(Collectors.toList());
            System.out.println("--- 升序输出列表中的元素的平方：");
            squaresSort.forEach(num -> {
                System.out.print(num + " ");
            });
            List<Integer> squaresSortReverse = numbers.stream()
                    .map(i -> i * i)
                    .sorted((x, y) -> y - x)
                    .collect(Collectors.toList());
            System.out.println("\n" + "--- 降序输出列表中的元素的平方：");
            squaresSortReverse.forEach(num -> {
                System.out.print(num + " ");
            });
            System.out.println("\n" + "--- 字符串转 map ---");
            List<String> strList = Arrays.asList("a", "ba", "bb", "abc", "cbb", "bba", "cab");
            Map<Integer, String> strMap = new HashMap<Integer, String>();
            strMap = strList.stream().collect(Collectors.toMap(str -> strList.indexOf(str), str -> str));
            strMap.forEach((key, value) -> {
                System.out.println(key + "：" + value);
            });
    
        }
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW9tdWJhaQ_size_16_color_FFFFFF_t_70 3][]

[https_www.runoob.com_java_java8-streams.html]: https://www.runoob.com/java/java8-streams.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW9tdWJhaQ_size_16_color_FFFFFF_t_70]: /images/20221120/63626125cc1e4998be501c7b1d036f8e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW9tdWJhaQ_size_16_color_FFFFFF_t_70 1]: /images/20221120/58851fa1dfbe466a98e287948fb6800b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW9tdWJhaQ_size_16_color_FFFFFF_t_70 2]: /images/20221120/5ae0acd15389424aa3febdef48ac6b7a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW9tdWJhaQ_size_16_color_FFFFFF_t_70 3]: /images/20221120/da0fbc6ff7f04f308b7ae2e6b4c8b763.png