看完这篇，让代码更优雅：jdk8新特性--Stream API

Taooc

于 2023-07-14 10:35:12 发布

阅读量86

点赞数

分类专栏： javaee 文章标签： java 后端 java-ee

本文链接：https://blog.csdn.net/qq_31700775/article/details/131718218

版权

javaee 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

本文展示了JavaStreamAPI的各种核心操作，如filter()用于过滤元素，map()用于元素转换，flatMap()用于流的扁平化，distinct()用于去重，sorted()用于排序，以及peek()、limit()、skip()等其他实用方法。文章通过实例代码详细解释了每个操作的用途和效果，帮助读者理解和掌握JavaStreamAPI的使用。

摘要由CSDN通过智能技术生成

1、filter()：根据指定的 Predicate 保留符合条件的元素。

示例 1：使用 filter() 方法过滤奇数

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

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

        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, 10]

2、map()：根据指定的 Function 映射每个元素，生成一个新的 Stream。

示例 2：使用 map() 方法将每个字符串转换为大写

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

public class Example {
    public static void main(String[] args) {
        List<String> words = Arrays.asList("hello", "world", "java", "stream");

        List<String> capitalizedWords = words.stream()
                .map(String::toUpperCase)
                .collect(Collectors.toList());

        System.out.println("Capitalized words: " + capitalizedWords);
    }
}

输出结果：

Capitalized words: [HELLO, WORLD, JAVA, STREAM]

3、flatMap()：将每个元素映射为一个 Stream，然后将这些 Stream 连接成一个 Stream。

示例 3：使用 flatMap() 方法将嵌套的列表展平为一个列表

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

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

        List<Integer> flattenedNumbers = nestedNumbers.stream()
                .flatMap(List::stream)
                .collect(Collectors.toList());

        System.out.println("Flattened numbers: " + flattenedNumbers);
    }
}

输出结果：

Flattened numbers: [1, 2, 3, 4, 5, 6, 7, 8, 9]

4、distinct()：返回一个去重后的 Stream。

示例 4：使用 distinct() 方法去除重复元素

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

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

        List<Integer> distinctNumbers = numbers.stream()
                .distinct()
                .collect(Collectors.toList());

        System.out.println("Distinct numbers: " + distinctNumbers);
    }
}

输出结果：

Distinct numbers: [1, 2, 3, 4, 5, 6]

5、sorted()：对 Stream 进行排序。

示例 5：使用 sorted() 方法对 Stream 进行排序

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

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

        List<Integer> sortedNumbers = numbers.stream()
                .sorted()
                .collect(Collectors.toList());

        System.out.println("Sorted numbers: " + sortedNumbers);
    }
}

输出结果：

Sorted numbers: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

6、peek()：对每个元素执行指定的操作，但并不消费元素。

示例 6：使用 peek() 方法打印每个元素并统计元素个数

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

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

        int count = numbers.stream()
                .peek(System.out::println)
                .mapToInt(Integer::intValue)
                .sum();

        System.out.println("Total count: " + count);
    }
}

输出结果：

1
2
3
4
5
6
7
8
9
10
Total count: 55

7、limit()：返回一个截断后的 Stream。

示例 7：使用 limit() 方法限制结果集大小

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

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

        List<Integer> limitedNumbers = numbers.stream()
                .limit(5)
                .collect(Collectors.toList());

        System.out.println("Limited numbers: " + limitedNumbers);
    }
}

输出结果：

Limited numbers: [1, 2, 3, 4, 5]

8、skip()：返回一个跳过指定元素后的 Stream。

示例 8：使用 skip() 方法跳过前面的元素

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

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

        List<Integer> skippedNumbers = numbers.stream()
                .skip(5)
                .collect(Collectors.toList());

        System.out.println("Skipped numbers: " + skippedNumbers);
    }
}

输出结果：

Skipped numbers: [6, 7, 8, 9, 10]

9、forEach()：对每个元素执行指定的操作。

示例 9：使用 forEach() 方法打印每个元素

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

public class Example {
    public static void main(String[] args) {
        List<String> words = Arrays.asList("hello", "world", "java", "stream");

        words.stream()
                .forEach(System.out::println);
    }
}

输出结果：

hello
world
java
stream

10、toArray()：将 Stream 转换为数组。

示例 10：使用 toArray() 方法将 Stream 转换为数组

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

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

        Integer[] numberArray = numbers.stream()
                .toArray(Integer[]::new);

        System.out.println("Number array: " + Arrays.toString(numberArray));
    }
}

输出结果：

Number array: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

11、reduce()：将 Stream 中的所有元素合并为一个，可以传入一个初始值。

使用 reduce() 将列表中的所有数字相加

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        Integer[] integers = {1, 2, 3, 4, 5};
        int result = Arrays.stream(integers).reduce(0, Integer::sum);
        System.out.println("Result: " + result);
    }
}

输出结果：

Result: 15

12、collect()：将 Stream 中的元素收集到一个集合中。

使用 collect() 将列表中的所有字符串拼接为一个字符串

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

public class Main {
    public static void main(String[] args) {
        String[] strings = {"apple", "banana", "cherry", "date"};
        String result = Arrays.stream(strings).collect(Collectors.joining(", "));
        System.out.println("Result: " + result);
    }
}

输出结果：

Result: apple, banana, cherry, date

13、count()：返回 Stream 中元素的数量。

使用 count() 计算列表中的字符串数量

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        String[] strings = {"apple", "banana", "cherry", "date"};
        long result = Arrays.stream(strings).count();
        System.out.println("Result: " + result);
    }
}

输出结果：

Result: 4

14、anyMatch()：判断是否存在至少一个元素满足指定的条件。

使用 anyMatch() 判断列表中是否存在以字母"a"开头的字符串

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        String[] strings = {"apple", "banana", "cherry", "date"};
        boolean result = Arrays.stream(strings).anyMatch(s -> s.startsWith("a"));
        System.out.println("Result: " + result);
    }
}

输出结果：

Result: true

15、allMatch()：判断是否所有元素都满足指定的条件。

使用 allMatch() 判断列表中的所有字符串是否都以字母"a"开头

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        String[] strings = {"apple", "avocado", "apricot", "almond"};
        boolean result = Arrays.stream(strings).allMatch(s -> s.startsWith("a"));
        System.out.println("Result: " + result);
    }
}

输出结果：

Result: true

16、noneMatch()：判断是否不存在任何一个元素满足指定的条件。

使用 noneMatch() 判断列表中是否不存在包含字母"z"的字符串

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        String[] strings = {"apple", "banana", "cherry", "date"};
        boolean result = Arrays.stream(strings).noneMatch(s -> s.contains("z"));
        System.out.println("Result: " + result);
    }
}

输出结果：

Result: true

17、findFirst()：返回 Stream 中的第一个元素。

使用 findFirst() 从列表中找到第一个长度为 4 的字符串

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

public class Main {
    public static void main(String[] args) {
        String[] strings = {"apple", "banana", "cherry", "date"};
        Optional<String> result = Arrays.stream(strings).filter(s -> s.length() == 4).findFirst();
        System.out.println("Result: " + result.orElse("Not found"));
    }
}

输出结果：

Result: date

18、findAny()：返回 Stream 中的任意一个元素。

使用 min() 找到列表中的最小值

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        Integer[] integers = {3, 7, 1, 9, 2, 5};
        int result = Arrays.stream(integers).min(Integer::compareTo).orElse(-1);
        System.out.println("Result: " + result);
    }
}

输出结果：

Result: 1

19、min()：返回 Stream 中的最小元素。

使用 min() 找到列表中的最小值

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        Integer[] integers = {3, 7, 1, 9, 2, 5};
        int result = Arrays.stream(integers).min(Integer::compare).orElse(-1);
        System.out.println("Result: " + result);
    }
}

输出结果：

Result: 1

20、max()：返回 Stream 中的最大元素。

使用 max() 找到列表中的最大值

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        Integer[] integers = {3, 7, 1, 9, 2, 5};
        int result = Arrays.stream(integers).max(Integer::compare).orElse(-1);
        System.out.println("Result: " + result);
    }
}

21、groupingBy()：按照指定条件对 Stream 中的元素进行分组。

使用 groupingBy() 按照字符串长度对字符串列表进行分组

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

public class GroupingByExample {
    public static void main(String[] args) {
        List<String> stringList = Arrays.asList("hello", "world", "java", "stream");

        Map<Integer, List<String>> result = stringList.stream()
                .collect(Collectors.groupingBy(String::length));

        System.out.println(result);
    }
}

22、partitioningBy()：按照指定条件对 Stream 中的元素进行分区。

使用 partitioningBy() 将数字列表按照是否为偶数进行分区

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

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

        Map<Boolean, List<Integer>> result = numberList.stream()
                .collect(Collectors.partitioningBy(n -> n % 2 == 0));

        System.out.println(result);
    }
}

输出结果：

{false=[1, 3, 5, 7, 9], true=[2, 4, 6, 8, 10]}

23、joining()：将 Stream 中的元素连接成一个字符串。

使用 joining() 将字符串列表中的元素用逗号连接成一个字符串

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

public class JoiningByExample {
    public static void main(String[] args) {
        List<String> stringList = Arrays.asList("hello", "world", "java", "stream");

        String result = stringList.stream()
                .collect(Collectors.joining(","));

        System.out.println(result);
    }
}

输出结果：

hello,world,java,stream

24、mapping()：根据指定的 Function 对 Stream 中的元素进行映射，并返回一个新的 Stream。

使用 mapping() 将字符串列表中的元素转换为大写字母

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

public class MappingByExample {
    public static void main(String[] args) {
        List<String> stringList = Arrays.asList("hello", "world", "java", "stream");

        List<String> result = stringList.stream()
                .map(String::toUpperCase)
                .collect(Collectors.toList());

        System.out.println(result);
    }
}

输出结果：

hello,world,java,stream

25、flatMapping()：将每个元素映射为一个 Stream，然后将这些 Stream 连接成一个 Stream。

使用 flatMapping() 将嵌套的字符串列表展平为一个字符串列表

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

public class FlatMappingByExample {
    public static void main(String[] args) {
        List<List<String>> nestedList = Arrays.asList(
                Arrays.asList("hello", "world"),
                Arrays.asList("hello","java", "stream"));

        List<String> result = nestedList.stream()
                .flatMap(List::stream)
                .distinct()
                .collect(Collectors.toList());

        System.out.println(result);
    }
}

输出结果：

[hello, world, java, stream]

26、iterating()：使用指定的种子值创建输出结果：一个 Stream，并依次对每个元素进行指定的操作。

使用 iterating() 生成斐波那契数列前 10 项

import java.util.stream.Stream;

public class IteratingByExample {
    public static void main(String[] args) {
        Stream.iterate(new int[]{0, 1}, t -> new int[]{t[1], t[0] + t[1]})
                .limit(10)
                .map(t -> t[0])
                .forEach(System.out::println);
    }
}

输出结果：

27、empty()：返回一个空的 Stream。

使用 empty() 使用空的 Stream

import java.util.stream.Stream;

public class EmptyStreamExample {
    public static void main(String[] args) {
        Stream<String> emptyStream = Stream.empty();

        System.out.println(emptyStream.count());
    }
}

28、of()：根据指定的元素创建一个 Stream。

使用 of() 创建包含一些字符串的 Stream

import java.util.stream.Stream;

public class OfStreamExample {
    public static void main(String[] args) {
        Stream<String> stringStream = Stream.of("hello", "world", "java", "stream");

        stringStream.forEach(System.out::println);
    }
}

输出结果：

hello
world
java
stream

29、concat()：将多个 Stream 连接成一个 Stream。

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

public class ConcatStreamExample {
    public static void main(String[] args) {
        List<String> list1 = Arrays.asList("hello", "world");
        List<String> list2 = Arrays.asList("java", "stream");

        Stream<String> stream1 = list1.stream();
        Stream<String> stream2 = list2.stream();

        List<String> result = Stream.concat(stream1, stream2)
                .collect(Collectors.toList());

        System.out.println(result);
    }
}

输出结果：

[hello, world, java, stream]

30、unordered()：返回一个无序的 Stream。

使用 unordered() 对数字列表进行排序后，使用 unordered()返回一个无序的 Stream

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

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

        List<Integer> result = numberList.stream()
                .sorted()
                .unordered()
                .collect(Collectors.toList());

        System.out.println(result);
    }
}

输出结果：

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

31、range()：生成一个包含指定范围内所有整数的 Stream。

使用 range()：生成一个包含指定范围内所有整数的 Stream。

import java.util.stream.IntStream;

public class RangeExample {
    public static void main(String[] args) {
        IntStream.range(1, 6)
                 .forEach(System.out::println);
    }
}

输出结果：

32、rangeClosed()：生成一个包含指定范围内所有整数（包括端点）的 Stream。

使用 rangeClosed()：生成一个包含指定范围内所有整数（包括端点）的 Stream。

import java.util.stream.IntStream;

public class RangeClosedExample {
    public static void main(String[] args) {
        IntStream.rangeClosed(1, 5)
                 .forEach(System.out::println);
    }
}

输出结果：

33、iterate()：根据指定的初始值和 UnaryOperator 生成一个无限长度的 Stream。

使用 iterate()：根据指定的初始值和 UnaryOperator 生成一个无限长度的 Stream。

import java.util.stream.Stream;

public class IterateExample {
    public static void main(String[] args) {
        Stream.iterate(2, n -> n * 2)
              .limit(5)
              .forEach(System.out::println);
    }
}

输出结果：

34、generate()：根据指定的 Supplier 生成一个无限长度的 Stream。

使用 generate()：根据指定的 Supplier 生成一个无限长度的 Stream。

import java.util.Random;
import java.util.stream.Stream;

public class GenerateExample {
    public static void main(String[] args) {
        Stream.generate(() -> new Random().nextInt(100))
              .limit(5)
              .forEach(System.out::println);
    }
}

输出结果：

35、takeWhile()：返回满足指定条件的元素，直到遇到第一个不满足条件的元素。

使用 takeWhile()：返回满足指定条件的元素，直到遇到第一个不满足条件的元素。

import java.util.stream.Stream;

public class TakeWhileExample {
    public static void main(String[] args) {
        Stream.of("apple", "banana", "orange", "pear")
              .takeWhile(s -> s.startsWith("a"))
              .forEach(System.out::println);
    }
}

输出结果：

apple

36、dropWhile()：返回不满足指定条件的元素，直到遇到第一个满足条件的元素。

使用 dropWhile()：返回不满足指定条件的元素，直到遇到第一个满足条件的元素。

import java.util.stream.Stream;

public class DropWhileExample {
    public static void main(String[] args) {
        Stream.of("apple", "banana", "orange", "pear")
              .dropWhile(s -> s.startsWith("a"))
              .forEach(System.out::println);
    }
}

输出结果：

banana
orange
pear

37、peek()：对每个元素执行指定的操作，但并不消费元素。

使用 peek()：对每个元素执行指定的操作，但并不消费元素。

import java.util.stream.Stream;

public class PeekExample {
    public static void main(String[] args) {
        Stream.of("apple", "banana", "orange", "pear")
              .peek(System.out::println)
              .count();
    }
}

输出结果：

apple
banana
orange
pear

38、boxed()：将 Stream 中的基本类型元素装箱成对应的包装类型。

使用 boxed()：将 Stream 中的基本类型元素装箱成对应的包装类型。

import java.util.stream.IntStream;

public class BoxedExample {
    public static void main(String[] args) {
        IntStream.range(1, 6)
                 .boxed()
                 .forEach(System.out::println);
    }
}

输出结果：

39、parallel()：返回一个并行的 Stream。

使用 parallel()：返回一个并行的 Stream。

import java.util.stream.Stream;

public class ParallelExample {
    public static void main(String[] args) {
        Stream.of("apple", "banana", "orange", "pear")
              .parallel()
              .forEach(System.out::println);
    }
}

输出结果：

pear
banana
apple
orange

40、sequential()：返回一个顺序的 Stream。

使用 sequential()：返回一个顺序的 Stream。

import java.util.stream.Stream;

public class SequentialExample {
    public static void main(String[] args) {
        Stream.of("apple", "banana", "orange", "pear")
              .parallel()
              .sequential()
              .forEach(System.out::println);
    }
}