MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

Java Stream collect 方法构建 StringBuilder

2023-01-191.3k 阅读

Java Stream collect 方法构建 StringBuilder 基础概念

在Java编程中，Stream API为处理集合数据提供了一种高效且便捷的方式。collect方法是Stream API中的一个终端操作，它可以将流中的元素收集到一个可变结果容器中，例如集合或其他自定义的可变对象。StringBuilder是Java中用于高效拼接字符串的可变对象，利用Stream的collect方法来构建StringBuilder可以让我们以一种更简洁、函数式的风格来处理字符串拼接任务。

在传统的Java编程中，拼接字符串通常会使用String类的+运算符或者StringBuilder的append方法。然而，当处理大量字符串拼接时，使用+运算符会因为String类的不可变性而产生大量中间对象，导致性能下降。而StringBuilder的append方法虽然性能较好，但在处理集合元素拼接时，代码可能会显得冗长。Stream的collect方法为解决这个问题提供了新的思路。

基本语法与原理

Stream的collect方法有多种重载形式，其中与构建StringBuilder相关的主要是使用Collector接口的形式。Collector是一个用于将流元素累积到可变结果容器中的策略接口。

构建StringBuilder时，我们可以自定义Collector，或者使用Collectors工具类提供的预定义收集器。以下是collect方法的基本语法：

R collect(Collector<? super T, A, R> collector);

其中，T是流中元素的类型，A是可变累积对象的类型，R是收集操作最终结果的类型。

对于构建StringBuilder，我们通常希望A和R都是StringBuilder类型。自定义Collector来构建StringBuilder需要实现Collector接口的以下几个方法：

  1. supplier：创建一个新的可变累积对象，即StringBuilder实例。
  2. accumulator：将流中的元素添加到累积对象中，对于StringBuilder就是调用append方法。
  3. combiner：在并行流的情况下，合并两个累积对象，同样是调用append方法将一个StringBuilder的内容追加到另一个StringBuilder中。
  4. finisher：在收集操作完成后，对累积对象进行最终处理，通常对于StringBuilder不需要额外处理，直接返回StringBuilder本身。
  5. characteristics：定义收集器的特性，如CONCURRENT（支持并行处理）、UNORDERED（不关心元素顺序）等。

使用自定义Collector构建StringBuilder

下面通过一个示例来展示如何自定义Collector构建StringBuilder：

import java.util.stream.Collector;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class CustomStringBuilderCollector {
    public static void main(String[] args) {
        Stream<String> words = Stream.of("Hello", " ", "World", "!");
        Collector<String, StringBuilder, StringBuilder> customCollector = Collector.of(
            // supplier
            StringBuilder::new,
            // accumulator
            StringBuilder::append,
            // combiner
            (left, right) -> {
                left.append(right);
                return left;
            },
            // finisher
            sb -> sb,
            // characteristics
            Collector.Characteristics.IDENTITY_FINISH | Collector.Characteristics.CONCURRENT
        );
        StringBuilder result = words.collect(customCollector);
        System.out.println(result.toString());
    }
}

在上述代码中，首先通过Stream.of创建了一个包含字符串元素的流。然后自定义了一个Collector，在Collector.of方法中依次定义了supplier、accumulator、combiner、finisher和characteristics。最后通过collect方法使用这个自定义的收集器将流中的字符串元素收集到一个StringBuilder中，并输出结果。

使用Collectors.joining构建StringBuilder

Collectors工具类提供了一个方便的方法joining，它可以用于将流中的元素连接成一个字符串。虽然joining方法返回的是String类型，但我们可以通过先收集为String，再用String构造StringBuilder的方式间接实现类似功能。

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

public class CollectorsJoiningExample {
    public static void main(String[] args) {
        Stream<String> words = Stream.of("Hello", " ", "World", "!");
        String joinedString = words.collect(Collectors.joining());
        StringBuilder result = new StringBuilder(joinedString);
        System.out.println(result.toString());
    }
}

这种方式相对简单，适用于不需要对StringBuilder进行中间操作的场景。Collectors.joining方法还有其他重载形式，可以指定分隔符、前缀和后缀，例如：

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

public class CollectorsJoiningWithSeparatorExample {
    public static void main(String[] args) {
        Stream<String> words = Stream.of("Hello", "World", "!");
        String joinedString = words.collect(Collectors.joining(", "));
        StringBuilder result = new StringBuilder(joinedString);
        System.out.println(result.toString());
    }
}

在这个示例中，使用, 作为分隔符将流中的字符串元素连接起来，然后再构造StringBuilder。

性能比较

为了更好地理解使用Stream collect方法构建StringBuilder与传统方式的性能差异，我们进行一个简单的性能测试。

  1. 传统StringBuilder拼接：
import java.util.ArrayList;
import java.util.List;

public class TraditionalStringBuilderAppend {
    public static void main(String[] args) {
        List<String> words = new ArrayList<>();
        for (int i = 0; i < 10000; i++) {
            words.add("word" + i);
        }
        long startTime = System.currentTimeMillis();
        StringBuilder sb = new StringBuilder();
        for (String word : words) {
            sb.append(word);
        }
        long endTime = System.currentTimeMillis();
        System.out.println("Traditional StringBuilder append time: " + (endTime - startTime) + " ms");
    }
}
  1. 使用Stream collect自定义Collector构建StringBuilder：
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collector;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class StreamCollectCustomCollector {
    public static void main(String[] args) {
        List<String> words = new ArrayList<>();
        for (int i = 0; i < 10000; i++) {
            words.add("word" + i);
        }
        long startTime = System.currentTimeMillis();
        Collector<String, StringBuilder, StringBuilder> customCollector = Collector.of(
            StringBuilder::new,
            StringBuilder::append,
            (left, right) -> {
                left.append(right);
                return left;
            },
            sb -> sb,
            Collector.Characteristics.IDENTITY_FINISH | Collector.Characteristics.CONCURRENT
        );
        StringBuilder result = words.stream().collect(customCollector);
        long endTime = System.currentTimeMillis();
        System.out.println("Stream collect with custom collector time: " + (endTime - startTime) + " ms");
    }
}
  1. 使用Collectors.joining构建StringBuilder：
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class StreamCollectJoining {
    public static void main(String[] args) {
        List<String> words = new ArrayList<>();
        for (int i = 0; i < 10000; i++) {
            words.add("word" + i);
        }
        long startTime = System.currentTimeMillis();
        String joinedString = words.stream().collect(Collectors.joining());
        StringBuilder result = new StringBuilder(joinedString);
        long endTime = System.currentTimeMillis();
        System.out.println("Stream collect with Collectors.joining time: " + (endTime - startTime) + " ms");
    }
}

通过多次运行这些测试代码，可以发现传统的StringBuilder直接append方法在处理大量元素时性能略好于使用Stream collect自定义收集器的方式，这是因为Stream操作本身会有一些额外的开销，例如流的创建和中间操作的处理。而使用Collectors.joining构建StringBuilder的方式由于先构建String再构造StringBuilder，性能相对更差一些，特别是在处理大量数据时。然而，Stream方式的优势在于代码的简洁性和可读性，尤其是在处理复杂的流操作和并行处理时。

在复杂场景中的应用

  1. 并行处理：当需要处理大量数据并且希望利用多核CPU的优势时，可以使用并行流。使用Stream collect方法构建StringBuilder在并行流场景下也能很好地工作。以下是一个示例：
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collector;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class ParallelStreamStringBuilder {
    public static void main(String[] args) {
        List<String> words = new ArrayList<>();
        for (int i = 0; i < 100000; i++) {
            words.add("word" + i);
        }
        long startTime = System.currentTimeMillis();
        Collector<String, StringBuilder, StringBuilder> customCollector = Collector.of(
            StringBuilder::new,
            StringBuilder::append,
            (left, right) -> {
                left.append(right);
                return left;
            },
            sb -> sb,
            Collector.Characteristics.IDENTITY_FINISH | Collector.Characteristics.CONCURRENT
        );
        StringBuilder result = words.parallelStream().collect(customCollector);
        long endTime = System.currentTimeMillis();
        System.out.println("Parallel stream collect time: " + (endTime - startTime) + " ms");
    }
}

在这个示例中，通过调用parallelStream将流转换为并行流，利用自定义的Collector收集字符串元素到StringBuilder中。由于Collector的characteristics设置为支持并行处理，所以在多核CPU环境下，并行流可以显著提高处理速度。

  1. 结合其他Stream操作：Stream的强大之处在于可以将多个操作组合在一起。我们可以在构建StringBuilder之前对元素进行过滤、映射等操作。例如，我们只拼接长度大于3的单词：
import java.util.stream.Collector;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class StreamOperationsWithStringBuilder {
    public static void main(String[] args) {
        Stream<String> words = Stream.of("Hello", " ", "World", "!", "Java", "is", "fun");
        Collector<String, StringBuilder, StringBuilder> customCollector = Collector.of(
            StringBuilder::new,
            StringBuilder::append,
            (left, right) -> {
                left.append(right);
                return left;
            },
            sb -> sb,
            Collector.Characteristics.IDENTITY_FINISH | Collector.Characteristics.CONCURRENT
        );
        StringBuilder result = words.filter(word -> word.length() > 3).collect(customCollector);
        System.out.println(result.toString());
    }
}

在上述代码中，先使用filter方法过滤掉长度小于等于3的单词，然后再使用自定义的Collector将符合条件的单词收集到StringBuilder中。

注意事项

  1. 线程安全性：虽然StringBuilder本身不是线程安全的，但在使用Stream collect方法构建StringBuilder时，如果Collector的characteristics设置为CONCURRENT，并且在并行流中使用，collect方法会确保线程安全地合并多个StringBuilder实例。然而，如果在单线程环境下或者自定义Collector时没有正确处理线程安全问题，可能会导致数据不一致。
  2. 内存消耗：在处理大量数据时，无论是使用传统的StringBuilder还是Stream collect方法构建StringBuilder，都需要注意内存消耗。如果一次性处理的数据量过大，可能会导致内存溢出。可以考虑分批处理或者使用更高效的数据结构来减少内存占用。
  3. 性能优化：如前面性能测试所示，Stream操作会有一定的开销。在性能敏感的场景下，需要权衡代码的简洁性和性能。如果性能是首要考虑因素，传统的StringBuilder直接append方法可能是更好的选择。但如果代码的可读性和可维护性更为重要，并且数据量不是特别巨大，Stream collect方法构建StringBuilder是一个不错的方案。

通过以上对Java Stream collect方法构建StringBuilder的详细介绍，包括基本概念、语法原理、代码示例、性能比较以及在复杂场景中的应用和注意事项，希望读者能够对这一技术有更深入的理解，并在实际编程中根据具体需求灵活运用。无论是追求代码的简洁性还是性能优化，都能找到适合的方法来处理字符串拼接任务。