Stream API详解（附22道练习题）

已于 2024-07-16 20:51:31 修改
阅读量1.4k 收藏 29
点赞数 31
分类专栏： # Java SE 文章标签： java 后端
于 2024-07-12 23:00:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53140426/article/details/140388871
版权

Stream API是 Java 8 引入的一种新特性，用于简化集合操作，支持函数式编程，便于并行处理，具有延迟计算的特点。

Stream API的优势在于代码简洁、内置丰富的操作，能够提高数据处理效率。

流的操作分为三个步骤：它包括创建流、中间操作（如过滤、映射、排序等）和终止操作（如遍历、汇总、转换等），实现对集合的高效处理。

目录

一、什么是 Stream API

二、Stream API 的优势

三、什么是流

四、Stream 的三个操作

1.  创建流

2.  中间操作

3.  终止操作

五、Stream API 的练习

1. 基础练习

（1）计算整数列表的总和

（2）找出整数列表中的最大值

（3）计算整数列表中所有偶数的平均值

（4）筛选出一个整数列表中的偶数并打印

（5）将字符串列表中的每个元素转换为大写并收集到新的列表

​（6）对整数列表进行降序排序，并获取前3个元素

（7）将整数列表中的每个数字乘以2，并收集到一个新的列表中

（8）检查整数列表中是否所有数字都是正数

（9）找出整数列表中大于5的最小值

（10）检查整数列表中是否存在至少一个数字大于10

（11）检查整数列表中是否包含连续的数字

（12）将整数列表中的数字进行去重

（13）从字符串列表中找出最长的字符串

2. 进阶练习

（14）从员工（姓名、年龄）列表中找出年龄大于30岁的员工姓名列表

（15）计算列表中每个元素出现的次数

（16）对字符串列表按单词长度进行分组，并打印出每个长度组的单词列表

（17）将整数列表中的数字分为奇数和偶数，分别存储在不同的列表中

（18）将一个字符串列表中的每个字符串长度求和

（19）对员工列表按年龄分组，并打印每个年龄组的人数

（20）计算字符串中每个字符出现的次数

（21）给定两个字符串列表，合并这两个列表，并去除重复项，然后按字母顺序排序

（22）将字符串列表转换为Map，其中键是字符串，值是字符串长度

前置知识：Java集合

可参考 Java 集合用法和25道练习题-CSDN博客

进阶知识：Collectors

可参考 Collectors 详解-CSDN博客

一、什么是 Stream API

Stream API 是 Java 8 引入的一个新特性，它提供了一种处理集合的新方式，可以更简洁、更易读地操作数据。Stream API 可以用来处理集合中的元素，类似于使用 SQL 进行查询，可以进行过滤、映射、排序、聚合等操作。

以下是Stream API的一些关键概念：

  1. 源：Stream可以是从集合、数组、文件等生成的。
  2. 中间操作：诸如filter、map、sorted等操作会返回一个新Stream，这些操作不会修改原始数据源，它们返回的是一个新的Stream作为结果。
  3. 终端操作：诸如forEach、collect、reduce等操作，这些操作会返回一个结果或者一个副作用，比如对集合进行遍历、汇总或者转换成其他形式。

二、Stream API 的优势

  1. 支持函数式编程：Stream API 基于函数式接口，可以使用 Lambda 表达式来传递行为，使得代码更为灵活和可维护。
  2. 便于并行处理：Stream API 内置支持并行处理，并且可以利用多核架构来提高性能。通过 parallel() 方法可以轻松地将串行流转换为并行流。
  3. 延迟计算：Stream 中的操作可以进行延迟计算，只有在需要结果时才会执行。这种特性使得 Stream 在处理大数据集时能够有效地优化性能。
  4. 代码简洁：Stream API 提供了一套函数式编程风格的方法，使得代码更为简洁，可以通过链式操作完成复杂的数据处理任务。
  5. 内置丰富的操作：Stream API 提供了丰富的中间操作（如 filter、map、sorted 等）和终端操作（如 forEach、collect、reduce 等），可以满足各种数据处理需求。

三、什么是流

流（Stream）是一种数据通道，它用于处理数据源（如集合、数组等）所产生的元素序列。“集合关注的是数据本身，而流关注的是对数据的计算处理。”             

四、Stream 的三个操作

1.  创建流

  • Stream.of(T… values)：通过显式值创建一个流。
  • Collection.stream()：通过集合的stream()方法创建一个流。
  • Collection.parallelStream()：通过集合的parallelStream()方法创建一个并行流。
  • Arrays.stream(T[] array)：通过数组创建一个流。
  • Stream.iterate(T seed, UnaryOperator f)：创建一个无限流，种子值是seed，后续元素通过函数f迭代生成。
  • Stream.generate(Supplier s)：创建一个无限流，元素通过Supplier函数生成。
import java.util.Arrays;
import java.util.Collection;
import java.util.stream.Stream;
import java.util.function.UnaryOperator;
import java.util.function.Supplier;

public class Main {
    public static void main(String[] args) {
        // Stream.of(T… values) 通过显式值创建一个流
        Stream<String> streamOfValues = Stream.of("a", "b", "c");
        streamOfValues.forEach(s -> System.out.print(s + " "));
        // a b c
        System.out.println();

        // Collection.stream() 通过集合的stream()方法创建一个流
        Collection<String> collection = Arrays.asList("x", "y", "z");
        Stream<String> streamFromCollection = collection.stream();
        streamFromCollection.forEach(s -> System.out.print(s + " "));
        // x y z
        System.out.println();

        // Collection.parallelStream() 通过集合的parallelStream()方法创建一个并行流
        Stream<String> parallelStreamFromCollection = collection.parallelStream();
        parallelStreamFromCollection.forEach(s -> System.out.print(s + " "));
        // y x z
        System.out.println();

        // Arrays.stream(T[] array) 通过数组创建一个流
        String[] array = {"1", "2", "3"};
        Stream<String> streamFromArray = Arrays.stream(array);
        streamFromArray.forEach(s -> System.out.print(s + " "));
        // 1 2 3
        System.out.println();

        // Stream.iterate(T seed, UnaryOperator f) 创建一个无限流，种子值是0，后续元素通过函数f迭代生成
        UnaryOperator<Integer> f = x -> x + 2;
        Stream<Integer> iterateStream = Stream.iterate(0, f);
        iterateStream.limit(5).forEach(s -> System.out.print(s + " ")); // 限制输出前5个元素
        // 0 2 4 6 8
        System.out.println();

        // Stream.generate(Supplier s) 创建一个无限流，元素通过Supplier函数生成
        Supplier<Double> randomSupplier = Math::random;
        Stream<Double> generateStream = Stream.generate(randomSupplier);
        generateStream.limit(3).forEach(s -> System.out.print(s + " ")); // 限制输出前3个元素
        // 0.5262200929887488 0.07660005625390776 0.5097922636483587 
        System.out.println();
    }
}

2.  中间操作

  • filter(Predicate predicate)：过滤流中的元素，只保留满足条件的元素。

  • map(Function<T, R> mapper)：转换每个元素到对应的结果。

  • mapToInt(ToIntFunction mapper)：转换元素为int类型。

  • mapToLong(ToLongFunction mapper)：转换元素为long类型。

  • mapToDouble(ToDoubleFunction mapper)：转换元素为double类型。

  • flatMap(Function<T, Stream> mapper)：将每个元素转换为另一个流，然后将这些流连接成一个流。

  • distinct()：返回一个元素各不相同的新流。

  • sorted()：返回一个自然排序后的流。

  • sorted(Comparator comparator)：返回一个按照指定比较器排序后的流。

  • peek(Consumer action)：对每个元素执行操作，并返回一个新的流。

  • limit(long maxSize)：截断流，使其元素不超过指定数量。

  • skip(long n)：跳过前n个元素，返回剩下的元素组成的流。

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;


public class Main {
    public static void main(String[] args) {
        List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd", "", "jkl");

        // filter：过滤流中的元素，只保留满足条件的元素
        List<String> filtered = strings.stream() //Collection.stream()集合方式创建流，得到的元素类型Stream<String>
                .filter(s -> !s.isEmpty())//筛选出不为空的字符串，不改变流的类型
                .collect(Collectors.toList()); //终止操作，把stream流中的每个元素收集到List集合中
        System.out.println("Filtered: " + filtered); //Filtered: [abc, bc, efg, abcd, jkl]

        // map：转换每个元素到对应的结果
        List<Integer> lengths = strings.stream()
                .map(s -> s.length())//对每个元素进行映射,s -> s.length()也可改写成String::length，得到元素类型Stream<Integer>
                .collect(Collectors.toList());
        System.out.println("Lengths: " + lengths); //Lengths: [3, 0, 2, 3, 4, 0, 3]

        // mapToInt：转换元素为int类型
        int[] intLengths = strings.stream()
                .mapToInt(String::length)//对生成的元素转换为int类型，得到IntStream类型的流
                .toArray();//终止操作，把stream流中的每个元素收集到数组中
        System.out.println("Int Lengths: " + Arrays.toString(intLengths));//Int Lengths: [3, 0, 2, 3, 4, 0, 3]

        // mapToLong：转换元素为long类型
        long[] longLengths = strings.stream()
                .mapToLong(String::length)//对生成的元素转换为long类型，得到LongStream类型的流
                .toArray();
        System.out.println("Long Lengths: " + Arrays.toString(longLengths));//Long Lengths: [3, 0, 2, 3, 4, 0, 3]

        // mapToDouble：转换元素为double类型
        double[] doubleLengths = strings.stream()
                .mapToDouble(String::length)//对生成的元素转换为long类型，得到DoubleStream类型的流
                .toArray();
        System.out.println("Double Lengths: " + Arrays.toString(doubleLengths));//Double Lengths: [3.0, 0.0, 2.0, 3.0, 4.0, 0.0, 3.0]

        // flatMap：将每个元素转换为另一个流，然后将这些流连接成一个流
        List<String> flatMapped = strings.stream()
                .flatMap(s -> Arrays.stream(s.split("")))//对流的每个元素拆分成新的流,s.split("")后是String[]类型
                .collect(Collectors.toList());
        System.out.println("FlatMapped: " + flatMapped);//FlatMapped: [a, b, c, , b, c, e, f, g, a, b, c, d, , j, k, l]

        // distinct：返回一个元素各不相同的新流
        List<String> distinctStrings = strings.stream()
                .distinct()//对流的元素进行去重
                .collect(Collectors.toList());
        System.out.println("Distinct: " + distinctStrings);//Distinct: [abc, , bc, efg, abcd, jkl]

        // sorted：返回一个自然排序后的流
        List<String> sortedStrings = strings.stream()
                .sorted()//对流的元素进行字典升序排序
                .collect(Collectors.toList());
        System.out.println("Sorted: " + sortedStrings);//Custom Sorted: [, , abc, abcd, bc, efg, jkl]

        // sorted(Comparator)：返回一个按照指定比较器排序后的流
        List<String> customSorted = strings.stream()
                //.sorted(Comparator.reverseOrder())//对流的元素进行降序排序
                .sorted((a, b) -> b.compareTo(a))//对流的元素进行降序排序
                .collect(Collectors.toList());
        System.out.println("Custom Sorted: " + customSorted);//Custom Sorted: [jkl, efg, bc, abcd, abc, , ]

        // peek：对每个元素执行操作，并返回一个新的流
        List<String> peeked = strings.stream()
                .peek(s -> System.out.print(s + " ")) //对每个元素进行打印 abc  bc efg abcd  jkl
                .collect(Collectors.toList());
        System.out.println("\nPeeked: " + peeked);//[abc, , bc, efg, abcd, , jkl]

        // limit：截断流，使其元素不超过指定数量
        List<String> limited = strings.stream()
                .limit(3) //截取流的前面三个
                .collect(Collectors.toList());
        System.out.println("Limited: " + limited); //Limited: [abc, , bc]

        // skip：跳过前n个元素，返回剩下的元素组成的流
        List<String> skipped = strings.stream()
                .skip(3)//跳过前面三个元素
                .collect(Collectors.toList());
        System.out.println("Skipped: " + skipped); //Skipped: [efg, abcd, , jkl]
    }
}


3.  终止操作

  • forEach(Consumer action)：遍历流中的每个元素，执行指定的操作。

  • forEachOrdered(Consumer action)：保证forEach操作在流被并行处理时，按照原始流的顺序执行。

  • toArray()：将流转换为数组。

  • reduce(T identity, BinaryOperator accumulator)：通过一个起始值，反复利用BinaryOperator来处理和累积元素，返回一个值。

  • reduce(BinaryOperator accumulator)：没有起始值，通过BinaryOperator处理和累积元素，返回一个Optional对象。

  • collect(Collector<T, A, R> collector)：将流中的元素累积成一个结果，利用Collector进行操作。

  • min(Comparator comparator)：返回流中最小元素。

  • max(Comparator comparator)：返回流中最大元素。

  • count()：返回流中元素的数量。

  • anyMatch(Predicate predicate)：判断流中是否至少有一个元素满足条件。

  • allMatch(Predicate predicate)：判断流中所有元素是否都满足条件。

  • noneMatch(Predicate predicate)：判断流中是否没有元素满足条件。

  • findFirst()：返回流中的第一个元素。

  • findAny()：返回流中的任意一个元素，主要用于并行流。

import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;
import java.util.Comparator;


public class Main {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);

        // forEach：遍历流中的每个元素，执行指定的操作
        numbers.stream().forEach(s -> System.out.print(s + " "));//1 2 3 4 5 6 7 8 9
        System.out.println();

        // forEachOrdered：保证forEach操作在流被并行处理时，按照原始流的顺序执行
        numbers.parallelStream().forEachOrdered(s -> System.out.print(s + " "));//1 2 3 4 5 6 7 8 9
        System.out.println();

        // toArray：将流转换为数组
        Integer[] numbersArray = numbers.stream().toArray(Integer[]::new);
        //int[] array = numbers.stream().mapToInt(Integer::valueOf).toArray();
        System.out.println("Array: " + Arrays.toString(numbersArray));//Array: [1, 2, 3, 4, 5, 6, 7, 8, 9]

        // reduce(T identity, BinaryOperator accumulator)：通过一个起始值，反复利用BinaryOperator来处理和累积元素，返回一个值
        int sum = numbers.stream().reduce(0, (a, b) -> a + b); //初始值sum = 0 ,(a, b) -> a + b可以改成Integer::sum
        System.out.println("Sum with identity: " + sum);//Sum with identity: 45

        // reduce(BinaryOperator accumulator)：没有起始值，通过BinaryOperator处理和累积元素，返回一个Optional对象
        Optional<Integer> sumOptional = numbers.stream().reduce(Integer::sum); //Optional<Integer>类的实例可以包含一个的Integer值，也可以不包含任何值（即它是null的）。
        // System.out.println(sumOptional.orElse(null)); //该方式取值也可以，如果不存在则返回null，如果存在则取出Integer类型的值
        // Integer i = sumOptional.get(); //该方式取值也可以，要确保值存在；如果不存在会抛出异常
        sumOptional.ifPresent(s-> System.out.println(s));//45


        // collect(Collector<T, A, R> collector)：将流中的元素累积成一个结果，利用Collector进行操作
        List<Integer> evenNumbers = numbers.stream()
                .filter(n -> n % 2 == 0)
                .collect(Collectors.toList());
        System.out.println("Even numbers: " + evenNumbers); //Even numbers: [2, 4, 6, 8]

        // min(Comparator comparator)：返回流中最小元素
        Optional<Integer> min = numbers.stream().min(Comparator.naturalOrder());
        min.ifPresent(System.out::println); //1

        // max(Comparator comparator)：返回流中最大元素
        Optional<Integer> max = numbers.stream().max(Comparator.naturalOrder());
        max.ifPresent(System.out::println); //9

        // count()：返回流中元素的数量
        long count = numbers.stream().count();
        System.out.println("Count: " + count); //Count: 9

        // anyMatch(Predicate predicate)：判断流中是否至少有一个元素满足条件
        boolean anyMatch = numbers.stream().anyMatch(n -> n > 5);
        System.out.println("Any match: " + anyMatch); //Any match: true

        // allMatch(Predicate predicate)：判断流中所有元素是否都满足条件
        boolean allMatch = numbers.stream().allMatch(n -> n > 0);
        System.out.println("All match: " + allMatch); //All match: true

        // noneMatch(Predicate predicate)：判断流中是否没有元素满足条件
        boolean noneMatch = numbers.stream().noneMatch(n -> n < 0);//没有元素小于0
        System.out.println("None match: " + noneMatch); //None match: true

        // findFirst()：返回流中的第一个元素
        Optional<Integer> first = numbers.stream().findFirst();
        first.ifPresent(System.out::println);//1

        // findAny()：返回流中的任意一个元素，主要用于并行流
        Optional<Integer> any = numbers.parallelStream().findAny();
        any.ifPresent(System.out::println);//1~9任意一个数字
    }
}

五、Stream API 的练习

1. 基础练习

（1）计算整数列表的总和

import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("1", "2", "3");
        //方法一
        int IntAns = list.stream()
                .mapToInt(Integer::valueOf)            //IntStream类型
                .sum();
        
        //方法二
        Integer IntegerAns = list.stream()
                .map(Integer::parseInt)                //Stream<Integer>类型
                .reduce(0, Integer::sum);              //对Stream<Integer>和IntStream类型都可以进行规约
        System.out.println("总和为：" + IntAns);        //总和为：6
        System.out.println("总和为：" + IntegerAns);    //总和为：6
    }
}

（2）找出整数列表中的最大值

import java.util.Arrays;
import java.util.List;
import java.util.OptionalInt;

public class Main {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 3, 4);
        // 方法一
        OptionalInt max1 = list.stream()
                .mapToInt(Integer::valueOf)
                .max();
        max1.ifPresent(System.out::println); //4

        // 方法二
        int max2 = list.stream()
                .reduce(Integer.MIN_VALUE, (a, b) -> a >= b ? a : b);
        //  .reduce(Integer.MIN_VALUE, Integer::max); //初始值是第一个元素或最小值
        System.out.println(max2); //4

    }
}

（3）计算整数列表中所有偶数的平均值

import java.util.Arrays;
import java.util.List;
import java.util.OptionalDouble;

public class Main {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 3, 4);

        //OptionalDouble是一个可能包含double数值容器，数值也有可能不存在
        OptionalDouble average = list.stream()
                .filter(n -> n % 2 == 0)
                .mapToInt(Integer::valueOf)//转换成IntStream类型
                .average();

        //ifPresent()：这是OptionalDouble类中的一个方法，用于检查这个Optional对象中是否包含值。如果Optional对象包含值，那么ifPresent()方法会执行传递给它的lambda表达式。
        average.ifPresent(value -> System.out.println(value)); //3.0

    }
}

（4）筛选出一个整数列表中的偶数并打印

import java.util.Arrays;
import java.util.List;
​
public class Main {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("1", "2", "5", "3", "6");
        list.stream()
                .mapToInt(Integer::valueOf)//转换成int类型，也可以parseInt
                .filter(x -> x % 2 == 0)
                .forEach(System.out::println); 
    }
}

（5）将字符串列表中的每个元素转换为大写并收集到新的列表

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        // 初始化列表
        List<String> list = Arrays.asList("aaa", "bbb", "cc", "D");

        // 将列表中的字符串转换为大写，并收集结果到新的列表中
        List<String> collect = list.stream()
                .map(String::toUpperCase) // 映射操作，将每个字符串转换为大写
                .collect(Collectors.toList()); // 收集操作，将结果收集到列表中

        // 打印转换后的列表
        System.out.println(collect); //[AAA, BBB, CC, D]
    }
}

​（6）对整数列表进行降序排序，并获取前3个元素

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 4, 3, 6, 3, 8, 5);
        List<Integer> collect = list.stream()
                .sorted((a, b) -> b - a)
                .limit(3)
                .collect(Collectors.toList());
        System.out.println(collect);//[8, 6, 5]

    }
}

（7）将整数列表中的每个数字乘以2，并收集到一个新的列表中

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 3, 4);
        List<Integer> collect = list.stream()
                .map(s -> s * 2)
                .collect(Collectors.toList());
        collect.forEach(s -> System.out.print(s + " ")); //2 4 6 8 
    }
}

（8）检查整数列表中是否所有数字都是正数

import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 4, 3, 6, 3, 8, 5);
        boolean b = list.stream()
                .allMatch(Main::IsPositive); //对list里面的所有数进行判断
                //.allMatch(n -> n > 0); //也可以直接该写法

        System.out.println(b); //true
    }

    public static boolean IsPositive(int n) {
        return n > 0;
    }
}

（9）找出整数列表中大于5的最小值

import java.util.Arrays;
import java.util.List;
import java.util.OptionalInt;

public class Main {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 4, 3, 6, 3, 8, 5);
        OptionalInt min = list.stream()
                .mapToInt(Integer::valueOf)
                .filter(n -> n > 5)
                .findFirst();
        min.ifPresent(System.out::println); //6
    }
}

（10）检查整数列表中是否存在至少一个数字大于10

import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 4, 3, 6, 3, 8, 5);
        boolean b = list.stream().anyMatch(n -> n > 5);//判断列表中是否有一个存在>5的数字
        System.out.println(b);

    }
}

（11）检查整数列表中是否包含连续的数字

import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 3, 5, 6, 7);
        boolean hasConsecutiveNumbers = list.stream()
                .anyMatch(n -> list.contains(n + 1));
        System.out.println("列表中是否包含连续的数字：" + hasConsecutiveNumbers);//列表中是否包含连续的数字：true
    }
}

（12）将整数列表中的数字进行去重

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(3, 1, 4, 1, 5, 9);
        List<Integer> collect = list.stream()
                .distinct()
                .collect(Collectors.toList());
        System.out.println(collect);//[3, 1, 4, 5, 9]
    }
}

（13）从字符串列表中找出最长的字符串

import java.util.Arrays;
import java.util.List;
import java.util.Optional;

public class Main {
    public static void main(String[] args) {
        List<String> strings = Arrays.asList("hello", "world2222", "stream22", "api", "java");
        // 方法一
        Optional<String> longestString = strings.stream().max((s1, s2) -> s1.length() - s2.length());
        longestString.ifPresent(System.out::println); //world2222

        // 方法二
        Optional<String> reduce = strings.stream().reduce((a, b) -> a.length() > b.length() ? a : b);
        System.out.println(reduce.orElse(null));//world2222
    }
}

2. 进阶练习

（14）从员工（姓名、年龄）列表中找出年龄大于30岁的员工姓名列表

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

class Employee {
    private String name;
    private int age;

    public Employee(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }


}

public class Main {
    public static void main(String[] args) {
        List<Employee> employees = Arrays.asList(
                new Employee("Alice", 32),
                new Employee("Bob", 29),
                new Employee("Charlie", 34)
        );

        String collect = employees.stream()
                .filter(e -> e.getAge() > 30)
                .map(e -> e.getName())//对每个员工取出姓名,或直接Employee::getName
                .collect(Collectors.joining(", ")); 
        System.out.println(collect); //Alice, Charlie
    }
}

（15）计算列表中每个元素出现的次数

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<Integer> integerNumbers = Arrays.asList(1, 2, 4, 3, 6, 3, 8, 5);
        Map<Integer, Long> collect = integerNumbers
                .stream()
                .collect(Collectors.groupingBy(e -> e, Collectors.counting()));
        //groupingBy类似与SQL中的GROUP BY
        //<e, Collectors.counting())>中,e值key,而Collectors.counting()是对每个key聚合后的值
        System.out.println(collect); // {1=1, 2=1, 3=2, 4=1, 5=1, 6=1, 8=1}
    }
}

（16）对字符串列表按单词长度进行分组，并打印出每个长度组的单词列表

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<String> words = Arrays.asList("apple", "banana", "cherry", "date", "fig", "grape");

        Map<Integer, List<String>> wordsByLength = words.stream()
                .collect(Collectors.groupingBy(String::length)); 
        //groupingBy只有一个参数时，key就是String::length，而value就是元素本身
        
        //wordsByLength: {3=[fig], 4=[date], 5=[apple, grape], 6=[banana, cherry]}
        wordsByLength.forEach((length, wordList) -> System.out.println("Length: " + length + ", Words: " + wordList));
        
   
    }
}

（17）将整数列表中的数字分为奇数和偶数，分别存储在不同的列表中

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 4, 3, 6, 3, 8, 5);
        Map<Boolean, List<Integer>> partitionedMap = list.stream()
                .collect(Collectors.partitioningBy(n -> n % 2 == 0));
        //partitioningBy是二元分组，groupingBy是多元分组
        System.out.println("偶数列表：" + partitionedMap.get(true)); //偶数列表：[2, 4, 6, 8]
        System.out.println("奇数列表：" + partitionedMap.get(false)); //奇数列表：[1, 3, 3, 5]
    }
}

（18）将一个字符串列表中的每个字符串长度求和

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<String> strings = Arrays.asList("apple", "banana", "cherry");
        // 方法一
        int totalLength1 = strings.stream()
                .collect(Collectors.summingInt(String::length));
        System.out.println(totalLength1); // 输出：17
        
        // 方法二
        int totalLength2 = strings.stream()
                .mapToInt(String::length).sum();
        System.out.println(totalLength2); // 输出：17

        // 方法三
        int totalLength3 = strings.stream()
                .reduce("",String::concat)
                .length();
        System.out.println(totalLength3); // 输出：17
    }
}

（19）对员工列表按年龄分组，并打印每个年龄组的人数

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

class Employee {
    String name;
    int age;

    Employee(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public int getAge() {
        return age;
    }

    @Override
    public String toString() {
        return name + ": " + age;
    }
}

public class Main {
    public static void main(String[] args) {
        List<Employee> people = Arrays.asList(
                new Employee("Alice", 22),
                new Employee("Bob", 20),
                new Employee("Charlie", 21),
                new Employee("David", 20)
        );

        //按照age进行分组，对每个分组求和
        Map<Integer, Long> peopleByAge = people.stream()
                .collect(Collectors.groupingBy(Employee::getAge, Collectors.counting()));
        peopleByAge.forEach((age, count) -> System.out.println("Age: " + age + ", Count: " + count));


        //按照age进行分组
        Map<Integer, List<Employee>> collect = people.stream()
                .collect(Collectors.groupingBy(person -> person.getAge()));
        System.out.println(collect);
        
    }
}

（20）计算字符串中每个字符出现的次数

import java.util.Map;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        String str = "hello world";
        
        Map<Character, Long> charCountMap = str.chars() // IntStream
                .mapToObj(c -> (char) c) // Stream<Character>
                .collect(Collectors.groupingBy(c -> c, Collectors.counting()));

        System.out.println(charCountMap); //{ =1, r=1, d=1, e=1, w=1, h=1, l=3, o=2}
    }
}

（21）给定两个字符串列表，合并这两个列表，并去除重复项，然后按字母顺序排序

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Main {
    public static void main(String[] args) {
        List<String> list1 = Arrays.asList("a", "b", "c");
        List<String> list2 = Arrays.asList("b", "c", "d");

        List<String> mergedList = Stream.concat(list1.stream(), list2.stream())
                .distinct()
                .sorted()
                .collect(Collectors.toList());
        System.out.println(mergedList);//[a, b, c, d]
    }
}

（22）将字符串列表转换为Map，其中键是字符串，值是字符串长度

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<String> strings = Arrays.asList("apple", "banana", "cherry");

        Map<String, Integer> stringLengthMap = strings.stream()
                .collect(Collectors.toMap(s -> s, String::length));

        stringLengthMap.forEach((s, length) -> System.out.println(s + ": " + length));
//        banana: 6
//        apple: 5
//        cherry: 6
    }
}

重学Java 8新特性 | 第8讲——趁热打铁，快来练练这三道有关Stream API的练习题
李阿昀的博客
02-16 875
在上一讲中，我们学了那么的Stream API，是不是应该要用一下啊，不然学它干嘛，所以，本讲我们就趁热打铁赶紧来用一下学过的Stream API，看你会不会用学过的Stream API来解决下面这三道练习题。 练习题一 题目是这样的：给定一个数字列表，如何返回一个由每个数的平方构成的列表呢？即给定[1, 2, 3, 4, 5]，应该返回[1, 4, 9, 16, 25]。 这道练习题解决起来还是蛮简单的，关键是要用一下map方法，相信大家应该都知道这点，下面我直接给出代码清单。 package com.m
尚硅谷-实验：Stream API练习.pdf
07-08
本教程特点： 1.更适合零基础学员： ·自Java语言起源始，循序渐进，知识点剖析细致且每章配备大量随堂练习，让你步步为营，学得透彻、练得明白 ·拒绝晦涩难懂的呆板教学，宋老师语言生动幽默，举例形象生动深入浅出，迅速让你把握问题本质，四两拨千斤 2.课程内容推陈出新： ·基于JDK 11，将Java8、Java9、Java10、Java11新特性一网打尽 ·课程中，Eclipse和IDEA这两种企业一线开发环境都使用到了 3.技术讲解更深入、更全面： ·课程共30天，715个知识视频小节，涉及主流Java使用的方方面面，全而不冗余 ·全程内容涵盖数据结构、设计模式、JVM内存结构等深度技术 ·企业级笔试面试题目深入源码级讲解，拒绝死记硬背 4.代码量更大、案例更丰富、更贴近实战： ·Java语言基础阶段：12720行代码，Java语言高级阶段：11684行代码 ·课堂实战项目3套，课后实战项目2套 ·近百道企业面试真题精讲精练、极具实战性
streamAPI练习
qq_42547698的博客
01-12 397
 Stream 不是集合元素，他不是数据结构，不会保存数据，它是有关算法和计算的。它更新一个高级的Iterator，   不会像以往的迭代器一样，它是隐式在内部进行遍历，是单向的，不可往复，数据只能遍历一次，遍历之后就没了，   就和流水从面前流过一样，一去而不复返。   而和迭代器不同的时，Stream可以并行化操作，迭代器只能命令式的，串行化操作。   顾名思义，当使用串行化方式去遍历时，每个...
JAVA8新特性之StreamAPI简单练习
花&败
10-12 1873
一：给定一个数字列表，如何返回一个由每个数的平方构成的数字列表呢？         例如：给定[1,2,3,4,5]，返回[1,4,9,16,25]                  效果：             二：怎样使用map和reduce方法数一数流中有多少个Employee呢？                 效果：            三：通过下面的条件进行练习       ...
StreamAPI练习
Mr_ZhouR的博客
11-08 275
练习一 新建交易员类 //新建交易员类 public class Trader { private String name; private String city; public Trader() { } public Trader(String name, String city) { this.name = name; ...
简单的StreamAPI的使用练习
weixin_54964323的博客
03-25 327
给定一个数字列表，如何返回一个由每个数的平方构成的列表呢？ 例如，给定【1，2，3，4，5】， 应该返回【1，4，9，16，25】 public class Exer1 { public static void main(String[] args) { List<Integer> asList = Arrays.asList(1,2,3,4,5,6); Stream<Integer> stream = asList.stream(); stream.map(a -&
Java 8 Stream API详解与练习指导
通过大量的示例代码和练习题，学习者可以加深对Stream API的理解，并在实际开发中灵活运用。对于想要深入了解和使用Java Stream API的开发者来说，这是一份非常宝贵的资源。 最后，值得一提的是，虽然Stream API给...
掌握JAVA基础：200道实例练习题详解
尽管实例题可能会专注于基础，了解一些现代Java版本（如Java 8及以上）的新特性，例如Lambda表达式、Stream API、新的日期时间API等，也对深入理解Java非常有帮助。 ### 9. 设计模式 虽然设计模式通常被归类为高级...
JAVA练习题及答案：50道选择题详解
资源摘要信息: "《14、JAVA练习题及答案(50道选择题19页)》是一份专注于Java编程语言的学习资源。它包含50道选择题以及每道题目的详细答案，旨在帮助读者加深对Java编程语言的理解。这份材料适用于初学者和中级Java...
spark考试练习题含答案.rar
06-22
《Spark大数据处理实战练习题详解》 Spark作为大数据处理领域的重要工具，因其高效、易用的特性备受开发者青睐。为了帮助大家深入理解和掌握Spark的核心功能，我们整理了一系列的Spark考试练习题，涵盖从基础概念到...
Java Lambda表达式练习题详解
Stream API是Java 8中引入的处理集合的函数式接口集合，它提供了一种高效和易于理解的方式来操作数据集合。使用Lambda表达式配合Stream API，可以轻松实现对集合的过滤、排序、映射等操作。例如： ```java List...
Java 8 : Stream API 练习
weixin_30279671的博客
08-24 144
//店铺属性类 public class Property { String name; // 距离，单位:米 Integer distance; // 销量，月售 Integer sales; // 价格，这里简单起见就写一个级别代表价格段 Integer priceLevel; public Property(S...
Stream API 小练习（map，filter）
m0_70099405的博客
04-08 126
函数式编程，StreamAPI 小练习 边借鉴，边练习（发博第五天）
StreamAPI 小练习
weixin_30858241的博客
11-11 144
/** * StreamAPI的小练习 */ public class StreamAPIExercise { private List<Transaction> transactions; @Before public void before() { Trader yan = new Trader("Yan",...
java8 Stream API简单练习
weixin_38165486的博客
07-23 329
package com.cdy.java801.test2; //交易员类 public class Trader { private String name; private String city; public Trader() { } public Trader(String name, String city) { this.name = name; this....
Java8新特性_Stream API 练习
兴趣是最好的老师
03-08 615
package com.zs.boot.controller; import org.junit.Test; import java.util.*; import java.util.stream.Collectors; public class TestStream5API { //求每个数的平方 @Test public void test1() { Integer[] nums = new Integer[]{1,2,3,4,5}; //.
java api练习_Java 8 : Stream API 练习
weixin_30043049的博客
02-23 213
//店铺属性类public class Property {String name;// 距离，单位:米Integer distance;// 销量，月售Integer sales;// 价格，这里简单起见就写一个级别代表价格段Integer priceLevel;public Property(String name, int distance, int sales, int priceLev...
Java8新特性_Stream API练习
weixin_42449715的博客
02-26 497
Java8新特性_Stream API练习 记录一下今天学到的新知识 例题。我们来看一个不同的领域：执行交易的交易员。你的经理让你为八个查询找到答案。 找出2011年发生的所有交易，并按交易额排序（从低到高）。 交易员都在哪些不同的城市工作过？ 查找所有来自于剑桥的交易员，并按姓名排序。 返回所有交易员的姓名字符串，按字母顺序排序。 有没有交易员是在米兰工作的？ 打印生活在剑桥的交易员的所有交易额。 所有交易中，最高的交易额是多少？ 找到交易额最小的交易。 领域：交易员和交易 以下是我们要处理的领域
Java8新特性_stream API 练习
weixin_34389926的博客
01-25 184
交易员类 public class Trader { private String name; private String city; public Trader() { } public Trader(String name, String city) { this.name = name; ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值