爆！Java高级特性之Stream API详解

news2024/11/25 4:44:37

爆！Java高级特性之Stream API详解

Java 8引入的Stream API可以说是一个革命性的特性,让我们告别了又臭又长的for循环,迎来了函数式编程的春天。今天就让我们来一起深入了解这个让人又爱又恨的Stream API吧!

什么是Stream?

Stream就像一个高级的迭代器,允许我们以声明式方式处理数据集合。它可以让我们用一种类似SQL查询的方式来操作Java对象。Stream API结合了函数式编程的概念,大大简化了集合操作。

简单来说,Stream就是数据流。我们可以imagin它就像一条传送带,在上面放上要处理的元素,然后让它流过一系列的操作。

创建Stream

创建Stream的方式有很多,我们来看几种常见的:

从Collection创建

List<String> list = Arrays.asList("a", "b", "c");
Stream<String> stream = list.stream();

从数组创建

String[] arr = {"a", "b", "c"};
Stream<String> stream = Arrays.stream(arr);

使用Stream.of()

Stream<String> stream = Stream.of("a", "b", "c");

生成无限流

Stream<Integer> infiniteStream = Stream.iterate(0, n -> n + 2);

看到这里,有些同学可能会说:"这有什么了不起的?我用for循环一样可以啊!"别急,好戏才刚刚开始。

Stream操作

Stream API提供了丰富的中间操作和终端操作,让我们可以方便地对数据进行各种转换和汇总。

中间操作

中间操作会返回一个新的Stream,我们可以将多个中间操作连接起来形成一个查询。常见的中间操作包括:

filter: 过滤元素

Stream<String> filtered = stream.filter(s -> s.startsWith("a"));

map: 转换元素

Stream<String> mapped = stream.map(String::toUpperCase);

flatMap: 将流中的每个元素转换为一个流,然后把所有流连接起来

Stream<String> flatMapped = stream.flatMap(s -> Arrays.stream(s.split("")));

distinct: 去重

Stream<String> distinct = stream.distinct();

sorted: 排序

Stream<String> sorted = stream.sorted();

peek: 对每个元素执行操作并返回一个新的Stream

Stream<String> peeked = stream.peek(System.out::println);

终端操作

终端操作会遍历流以生成一个结果或副作用。在终端操作之后,流就被使用"光"了,无法再被操作。常见的终端操作包括:

forEach: 遍历每个元素

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

count: 返回流中元素的个数

long count = stream.count();

collect: 将流转换为其他形式

List<String> list = stream.collect(Collectors.toList());

reduce: 将流中元素组合起来

Optional<String> reduced = stream.reduce((s1, s2) -> s1 + s2);

anyMatch, allMatch, noneMatch: 匹配操作

boolean anyStartsWithA = stream.anyMatch(s -> s.startsWith("a"));

findFirst, findAny: 查找操作

Optional<String> first = stream.findFirst();

看到这里,有些同学可能会说:"哇,这么多操作,我脑子都晕了!"别担心,让我们来看一个实际的例子,你就会发现Stream API有多香了。

实战案例

假设我们有一个Person类:

class Person {
    String name;
    int age;
    
    // 构造函数、getter和setter省略
}

现在我们有一个List<Person>,我们想要找出所有年龄大于18岁的人的名字,按字母顺序排序,并且只取前3个。用传统的方式,我们可能会这样写:

List<String> result = new ArrayList<>();
for (Person p : persons) {
    if (p.getAge() > 18) {
        result.add(p.getName());
    }
}
Collections.sort(result);
if (result.size() > 3) {
    result = result.subList(0, 3);
}

看起来不算太糟?那让我们来看看用Stream API怎么写:

List<String> result = persons.stream()
    .filter(p -> p.getAge() > 18)
    .map(Person::getName)
    .sorted()
    .limit(3)
    .collect(Collectors.toList());

怎么样?是不是感觉整个世界都清爽了?这就是Stream API的魅力所在!它让我们的代码更加简洁、易读,而且更加声明式。我们告诉程序"我们想要什么",而不是"怎么去做"。

性能考虑

说到这里,可能有些同学会问:“Stream这么好用,是不是意味着我们应该到处使用它?”

嗯…这个问题问得好!虽然Stream API非常强大,但它并不是万能的。在某些情况下,传统的迭代可能会更快。特别是当我们处理的是基本类型(如int, long)时,使用Stream可能会带来装箱和拆箱的开销。

另外,Stream的延迟执行特性也是把双刃剑。它可以帮我们优化操作,避免不必要的计算。但如果使用不当,也可能导致性能问题。比如:

Stream<Integer> stream = Stream.iterate(0, i -> i + 1);
stream.filter(i -> i % 2 == 0)
      .map(i -> i * 2)
      .limit(10)
      .forEach(System.out::println);

这段代码看起来没什么问题,但实际上它的效率并不高。因为iterate生成的是一个无限流,filter和map操作会被反复执行,直到找到10个符合条件的元素。

一个更高效的写法是:

Stream.iterate(0, i -> i + 2)
      .map(i -> i * 2)
      .limit(10)
      .forEach(System.out::println);

这样我们就避免了不必要的过滤操作。

并行流

Stream API的另一个强大特性是可以轻松地实现并行处理。只需要调用parallel()方法,就可以将串行流转换为并行流:

List<String> result = persons.parallelStream()
    .filter(p -> p.getAge() > 18)
    .map(Person::getName)
    .sorted()
    .limit(3)
    .collect(Collectors.toList());