java实现字符串分割split（附带源码）-CSDN博客

本文链接：https://blog.csdn.net/m0_61840987/article/details/148336889

一、项目背景详细介绍

在软件开发中，字符串处理是最常见也是最基础的需求之一。无论是日志解析、文本分析、命令行参数解析、数据交换格式的处理，还是前后端交互、数据库查询语句构建，都离不开对字符串的分割、匹配、替换等操作。其中，字符串分割（split） 是最基础、最常用的功能之一。

Java 标准库提供了 String.split() 方法，使用正则表达式分割字符串。但在高性能、大规模数据处理、对正则不熟悉或需要自定义分割规则时，我们往往需要手动实现高效、可定制的字符串分割算法。本项目旨在用纯 Java 从零实现字符串分割功能，封装为一个易用、灵活、可扩展的工具类，提供：

支持单字符分隔符、字符串分隔符、正则分隔符
支持限制分割次数（limit）
支持去除空白项或保留空项
支持 trim 选项，是否对每个子串进行前后空白去除
支持多种输入类型（String、CharSequence、Reader 流）
支持返回 String[]、List<String> 或者 Java 8 Stream<String>
提供静态工具类和可配置的实例两种调用方式
保证高性能、低内存占用、线程安全

通过本项目，读者可以深入理解字符串分割的核心原理，掌握高效字符扫描算法，并学会如何设计易用、可扩展的工具 API。

二、项目需求详细介绍

2.1 功能需求

基本功能：根据指定分隔符将目标字符串分割为若干子串；
分隔符类型：支持单字符、字符串常量、基于正则的分隔；
limit 参数：支持分割次数限制，与 String.split(regex, limit) 参数语义一致；
空串处理：可选择保留空串或去除空串；
trim 选项：可选择对每个子串进行 trim()；
输入多样：可接受 String、CharSequence，并可从 Reader 流中增量读取并分割；
输出多样：可直接返回 String[]、List<String> 或 Stream<String>；
性能要求：对超长字符串分割（百万字符）时，内存拷贝和GC开销最小，响应时间低于50ms；
线程安全：工具类实例不可变，静态方法线程安全；

2.2 非功能需求

易用性：API 清晰、重载合理，避免参数歧义；
可测试性：提供丰富单元测试，覆盖边界场景、参数组合；
可扩展性：后续可扩展为 CSV 分割、定界符对（如引号包裹）等；
文档化：Javadoc 完整，配合示例说明；

三、相关技术详细介绍

3.1 Java 原生 `String.split()`

基于正则引擎实现，性能与正则复杂度相关；
重载方法 split(String regex)、split(String regex, int limit)；
返回 String[]，默认去除末尾空串；

优点：用法简单，功能强大；缺点：无法控制是否保留空串、无法方便设置 trim，对于简单分隔效率不高。

3.2 自定义分割算法

基于字符扫描：从头到尾遍历字符串，利用 indexOf 或手动字符比较实现定界；
KMP 算法：对多字符分隔符，可通过预处理分隔符模式，获得线性匹配时间；
正则引擎：当需要复杂模式分割时，可内嵌正则匹配或 Pattern；

3.3 Java 8 Stream

Stream API：将分割结果包装为 Stream<String>，支持惰性评估、并行分割；
可与函数式接口结合，进行 map/filter 操作；

3.4 性能优化

一次分配容量：根据大致子串数量预估 ArrayList 容量，减少扩容；
最小化对象创建：避免在循环内部创建临时 StringBuilder，可复用单个实例；
Reader 分块处理：针对超长文本，用缓冲区分块读取，边读边分割，降低内存峰值；

四、实现思路详细介绍

API 设计
- SplitUtils 静态工具类，提供一系列 split(...) 静态方法；
- Splitter 可配置实例，Builder 模式构造，支持链式配置：分隔符、limit、trim、keepEmpty；
核心分割流程（针对 String 输入）
- 初始化：检查输入、分隔符非空；
- 扫描：根据分隔符类型调用不同分支：
  - 单字符：for 遍历查找 charAt(i) 等于分隔符；
  - 字符串：使用 indexOf(delimiter, fromIndex)；
  - 正则：预编译 Pattern，使用 Matcher.find()；
- 收集：每次找到界限时，从 prevIndex 到 currentIndex 提取子串，按配置决定是否 trim、是否保留空串；
- 结束：处理最后一段残余字符；
- limit 处理：当已收集子串数达到 limit-1 时，将剩余全部作为最后一段；
Reader 分割
- 使用 BufferedReader 按块读取到 char[] buffer，手动维护环形缓冲区，保证在分隔符跨块边界时也能正确匹配；
- 类似上面的扫描逻辑，但需额外管理跨块边界的残余；
Stream 分割
- 将上述扫描逻辑封装为 Spliterator，在 tryAdvance 中返回下一个子串；
- 构造 StreamSupport.stream(...)，支持串行和并行；
工具类与实例类设计
- SplitUtils：所有静态方法，多重重载；
- Splitter：不可变实例，Builder 中保存配置，提供 splitToArray、splitToList、splitToStream；

五、完整实现代码

// =====================================================
// File: SplitUtils.java
// Description: 静态工具类，提供多种重载的 split 方法
// =====================================================
package com.example.split;

import java.io.*;
import java.util.*;
import java.util.regex.*;
import java.util.stream.*;

public class SplitUtils {

    private SplitUtils() {
        // 私有构造，禁止实例化
    }

    // ----------- 静态方法：简单分割 -----------
    public static String[] split(String input, char delimiter) {
        return new SplitterBuilder()
                .delimiter(delimiter)
                .build()
                .splitToArray(input);
    }

    public static String[] split(String input, String delimiter) {
        return new SplitterBuilder()
                .delimiter(delimiter)
                .build()
                .splitToArray(input);
    }

    public static String[] split(String input, String regex, boolean useRegex, int limit) {
        return new SplitterBuilder()
                .delimiter(regex)
                .useRegex(useRegex)
                .limit(limit)
                .build()
                .splitToArray(input);
    }

    // ----------- 静态方法：返回 List -----------
    public static List<String> splitToList(String input, char delimiter, boolean keepEmpty) {
        return new SplitterBuilder()
                .delimiter(delimiter)
                .keepEmpty(keepEmpty)
                .build()
                .splitToList(input);
    }

    public static List<String> splitToList(String input, String delimiter, boolean trim, int limit) {
        return new SplitterBuilder()
                .delimiter(delimiter)
                .trim(trim)
                .limit(limit)
                .build()
                .splitToList(input);
    }

    // ----------- 静态方法：返回 Stream -----------
    public static Stream<String> splitToStream(String input, String delimiter) {
        return new SplitterBuilder()
                .delimiter(delimiter)
                .build()
                .splitToStream(input);
    }

    // ----------- Reader 分割 -----------
    public static List<String> split(Reader reader, String delimiter, boolean keepEmpty) throws IOException {
        return new SplitterBuilder()
                .delimiter(delimiter)
                .keepEmpty(keepEmpty)
                .build()
                .split(reader);
    }
}

// =====================================================
// File: Splitter.java
// Description: 可配置实例，执行分割逻辑
// =====================================================
package com.example.split;

import java.io.*;
import java.util.*;
import java.util.regex.*;
import java.util.stream.*;

public final class Splitter {

    private final String delimiter;
    private final char delimiterChar;
    private final boolean useRegex;
    private final int limit;
    private final boolean keepEmpty;
    private final boolean trim;
    private final Pattern pattern; // 如果 useRegex=true，则持有 Pattern

    // 私有构造，必须通过 Builder 构建
    Splitter(String delimiter, char delimiterChar, boolean useRegex,
             int limit, boolean keepEmpty, boolean trim, Pattern pattern) {
        this.delimiter = delimiter;
        this.delimiterChar = delimiterChar;
        this.useRegex = useRegex;
        this.limit = limit;
        this.keepEmpty = keepEmpty;
        this.trim = trim;
        this.pattern = pattern;
    }

    // 分割到数组
    public String[] splitToArray(String input) {
        return splitToList(input).toArray(new String[0]);
    }

    // 分割到 List
    public List<String> splitToList(String input) {
        List<String> result = new ArrayList<>();
        if (input == null) {
            return result;
        }
        if (useRegex) {
            splitByRegex(input, result);
        } else if (delimiter != null) {
            splitByString(input, result);
        } else {
            splitByChar(input, result);
        }
        return result;
    }

    // 分割到 Stream
    public Stream<String> splitToStream(String input) {
        return splitToList(input).stream();
    }

    // Reader 分割
    public List<String> split(Reader reader) throws IOException {
        BufferedReader br = reader instanceof BufferedReader ?
                (BufferedReader) reader : new BufferedReader(reader);
        List<String> result = new ArrayList<>();
        String line;
        while ((line = br.readLine()) != null) {
            result.addAll(splitToList(line));
        }
        return result;
    }

    // 按字符分割
    private void splitByChar(String input, List<String> result) {
        int start = 0;
        int count = 0;
        for (int i = 0; i < input.length(); i++) {
            if (input.charAt(i) == delimiterChar && (limit <= 0 || count < limit - 1)) {
                String part = input.substring(start, i);
                addPart(result, part);
                start = i + 1;
                count++;
            }
        }
        // 最后剩余部分
        String part = input.substring(start);
        addPart(result, part);
    }

    // 按固定字符串分割
    private void splitByString(String input, List<String> result) {
        int start = 0, count = 0;
        int dl = delimiter.length();
        while ((limit <= 0 || count < limit - 1)) {
            int idx = input.indexOf(delimiter, start);
            if (idx < 0) break;
            String part = input.substring(start, idx);
            addPart(result, part);
            start = idx + dl;
            count++;
        }
        addPart(result, input.substring(start));
    }

    // 按正则分割
    private void splitByRegex(String input, List<String> result) {
        Matcher m = pattern.matcher(input);
        int start = 0, count = 0;
        while (m.find() && (limit <= 0 || count < limit - 1)) {
            String part = input.substring(start, m.start());
            addPart(result, part);
            start = m.end();
            count++;
        }
        addPart(result, input.substring(start));
    }

    // 添加子串到结果，根据配置决定是否 trim/keepEmpty
    private void addPart(List<String> result, String part) {
        if (trim) {
            part = part.trim();
        }
        if (part.isEmpty() && !keepEmpty) {
            return;
        }
        result.add(part);
    }
}

// =====================================================
// File: SplitterBuilder.java
// Description: Splitter 构建者
// =====================================================
package com.example.split;

import java.util.regex.*;

public class SplitterBuilder {

    String delimiter = null;
    char delimiterChar = 0;
    boolean useRegex = false;
    int limit = 0;
    boolean keepEmpty = true;
    boolean trim = false;
    Pattern pattern = null;

    /** 设置单字符分隔符 */
    public SplitterBuilder delimiter(char c) {
        this.delimiterChar = c;
        this.delimiter = null;
        return this;
    }

    /** 设置字符串分隔符 */
    public SplitterBuilder delimiter(String s) {
        this.delimiter = s;
        return this;
    }

    /** 是否将 delimiter 视为正则 */
    public SplitterBuilder useRegex(boolean useRegex) {
        this.useRegex = useRegex;
        return this;
    }

    /** 限制返回子串个数；<=0 表示不限制 */
    public SplitterBuilder limit(int limit) {
        this.limit = limit;
        return this;
    }

    /** 是否保留空白子串 */
    public SplitterBuilder keepEmpty(boolean keepEmpty) {
        this.keepEmpty = keepEmpty;
        return this;
    }

    /** 是否对子串执行 trim() */
    public SplitterBuilder trim(boolean trim) {
        this.trim = trim;
        return this;
    }

    /** 构造 Splitter 实例 */
    public Splitter build() {
        if (useRegex && delimiter != null) {
            this.pattern = Pattern.compile(delimiter);
        }
        return new Splitter(delimiter, delimiterChar, useRegex, limit, keepEmpty, trim, pattern);
    }
}

// =====================================================
// File: Main.java
// Description: 演示 SplitUtils 和 Splitter 的使用
// =====================================================
package com.example.split;

import java.io.*;
import java.util.*;

public class Main {
    public static void main(String[] args) throws IOException {
        String text = "apple,banana,,orange, grape , ,melon";
        // 静态简单调用
        String[] arr = SplitUtils.split(text, ',');
        System.out.println(Arrays.toString(arr));
        // 自定义 Builder 调用
        List<String> list = new SplitterBuilder()
                .delimiter(",")
                .trim(true)
                .keepEmpty(false)
                .limit(4)
                .build()
                .splitToList(text);
        System.out.println(list);
        // 正则分割示例
        String csv = "one; two;three; ;four";
        Stream<String> stream = SplitUtils.splitToStream(csv, "\\s*;\\s*");
        stream.forEach(System.out::println);
        // Reader 分割示例
        try (Reader reader = new StringReader("a|b||c|")) {
            List<String> r = SplitUtils.split(reader, "|", false);
            System.out.println(r);
        }
    }
}

六、代码详细解读

SplitUtils.split(input, delimiterChar)
作用：使用单字符分隔，返回 String[]，基于默认 keepEmpty=true, trim=false, limit=0。
SplitUtils.split(input, delimiter, useRegex, limit)
作用：使用字符串或正则分隔，指定是否使用正则及最大分割数。
SplitterBuilder.delimiter(char / String)
作用：配置分隔符，单字符或字符串。
SplitterBuilder.useRegex(boolean)
作用：指定是否将字符串分隔符按正则解析。
SplitterBuilder.limit(int)
作用：设置最大分割数，<=0 表示不限。
SplitterBuilder.keepEmpty(boolean)
作用：是否保留空字符串子串。
SplitterBuilder.trim(boolean)
作用：是否对每个子串执行 trim()。
SplitterBuilder.build()
作用：根据配置构造不可变 Splitter 实例。
Splitter.splitToList(String)
作用：根据配置选择字符/字符串/正则分割并收集子串列表。
Splitter.splitByChar / splitByString / splitByRegex
作用：分别实现三种分割策略的具体扫描算法，限于 limit 控制分割次数。
Splitter.addPart(List, String)
作用：对每个子串应用 trim 和 keepEmpty 过滤后加入结果列表。
Splitter.split(Reader)
作用：按行读取 Reader，对每行执行分割并聚合结果，适合大文本按行处理。
Main.main()
作用：演示静态工具类和 Builder 方式对不同场景（简单分割、自定义配置、正则、Reader）下的用法示例。