使用StringBuffer类的substring()方法获取子字符串

在Java编程中，字符串处理是开发者经常需要面对的任务。无论是解析日志文件、处理用户输入还是构建动态内容，字符串操作都占据着重要地位。虽然String类提供了基础的字符串操作功能，但在需要频繁修改字符串内容的场景下，String的不可变性（immutable）特性会导致性能问题。此时，StringBuffer类凭借其可变性（mutable）特性成为更优选择。本文将深入探讨StringBuffer类的substring()方法，从底层原理到实际应用场景，帮助开发者全面掌握这一重要工具。

一、StringBuffer类基础回顾

StringBuffer是Java中用于表示可变字符序列的类，位于java.lang包下。与String不同，StringBuffer允许在原有对象上进行修改操作，避免了频繁创建新对象带来的性能开销。其内部通过字符数组（char[]）实现存储，当数组容量不足时会自动扩容。

创建StringBuffer对象的基本方式：

// 空构造方法，初始容量16
StringBuffer sb1 = new StringBuffer();

// 指定初始容量
StringBuffer sb2 = new StringBuffer(32);

// 通过String初始化
StringBuffer sb3 = new StringBuffer("Hello World");

StringBuffer的核心优势在于其提供的修改方法，如append()、insert()、delete()等。这些方法都返回StringBuffer对象本身，支持方法链式调用：

StringBuffer sb = new StringBuffer();
sb.append("Java").insert(4, " ").append("Programming");
// 结果为"Java Programming"

二、substring()方法详解

substring()方法是StringBuffer类中用于提取子字符串的重要工具，其设计充分考虑了可变字符串的特性。该方法有两个重载版本：

1. substring(int beginIndex)

从指定索引开始截取，直到字符串末尾。

public synchronized String substring(int beginIndex)

参数说明：

• beginIndex：起始索引（包含），必须满足0 ≤ beginIndex ≤ length()

示例：

StringBuffer sb = new StringBuffer("StringBuffer");
String sub = sb.substring(5); // "ringBuffer"

2. substring(int beginIndex, int endIndex)

截取从beginIndex到endIndex-1的子字符串。

public synchronized String substring(int beginIndex, int endIndex)

参数说明：

• beginIndex：起始索引（包含）
• endIndex：结束索引（不包含）
• 必须满足0 ≤ beginIndex ≤ endIndex ≤ length()

示例：

StringBuffer sb = new StringBuffer("Programming");
String sub = sb.substring(2, 6); // "gram"

3. 异常处理

当参数不合法时，substring()会抛出StringIndexOutOfBoundsException：

try {
    StringBuffer sb = new StringBuffer("Test");
    sb.substring(-1); // 抛出异常
} catch (StringIndexOutOfBoundsException e) {
    System.out.println("索引越界: " + e.getMessage());
}

三、底层实现原理

StringBuffer的substring()方法最终调用的是AbstractStringBuilder类（其父类）的实现。在JDK源码中，核心逻辑如下：

public String substring(int beginIndex, int endIndex) {
    if (beginIndex  count) {
        throw new StringIndexOutOfBoundsException(endIndex);
    }
    if (beginIndex > endIndex) {
        throw new StringIndexOutOfBoundsException(endIndex - beginIndex);
    }
    return new String(value, beginIndex, endIndex - beginIndex);
}

关键点解析：

1. 参数校验：检查索引范围是否合法
2. 字符数组拷贝：使用String类的构造方法，从原始字符数组（value）中截取指定范围
3. 新对象创建：返回的String对象是新的不可变对象

值得注意的是，虽然StringBuffer本身是可变的，但substring()返回的始终是新的String对象。这种设计既保持了StringBuffer的修改能力，又确保了字符串截取结果的不可变性。

四、实际应用场景

substring()方法在实际开发中有多种应用场景，下面通过几个典型案例进行说明。

1. 日志处理

在解析日志文件时，经常需要提取特定字段。假设日志格式为"时间戳|级别|消息"，可以使用substring()分割字段：

StringBuffer logLine = new StringBuffer("2023-01-01 12:00|ERROR|File not found");
int firstBar = logLine.indexOf("|");
int secondBar = logLine.indexOf("|", firstBar + 1);

String timestamp = logLine.substring(0, firstBar);
String level = logLine.substring(firstBar + 1, secondBar);
String message = logLine.substring(secondBar + 1);

2. 模板引擎实现

在简单模板引擎中，可以使用substring()处理占位符：

public class SimpleTemplate {
    public static String process(StringBuffer template, Map data) {
        String result = template.toString();
        for (Map.Entry entry : data.entrySet()) {
            String placeholder = "{{" + entry.getKey() + "}}";
            int start = result.indexOf(placeholder);
            if (start >= 0) {
                int end = start + placeholder.length();
                // 先转换为StringBuffer进行复杂操作
                StringBuffer sb = new StringBuffer(result);
                sb.replace(start, end, entry.getValue());
                result = sb.substring(0); // 重新获取String
            }
        }
        return result;
    }
}

3. 字符串校验与截取

在验证用户输入时，可能需要提取特定部分进行校验：

public boolean validatePhoneNumber(StringBuffer phone) {
    if (phone.length() != 11) return false;
    
    String areaCode = phone.substring(0, 3);
    if (!areaCode.matches("[1-9]\\d{2}")) {
        return false;
    }
    
    String prefix = phone.substring(3, 7);
    return prefix.matches("\\d{4}");
}

五、性能优化建议

虽然StringBuffer的substring()方法使用方便，但在高性能场景下仍需注意以下几点：

1. 避免频繁截取

每次调用substring()都会创建新的String对象，在循环中应尽量避免：

// 低效方式
for (int i = 0; i 

2. 合理设置初始容量

对于已知长度的字符串操作，预先设置足够容量可减少扩容次数：

// 处理1000字符的字符串
StringBuffer sb = new StringBuffer(1000);
for (int i = 0; i 

3. 与StringBuilder的选择

在单线程环境下，StringBuilder（非同步）性能更好：

// 单线程推荐
StringBuilder sb = new StringBuilder();
sb.append("High").append("Performance");
String result = sb.substring(0);

六、常见问题解答

Q1: substring()与String类的substring()有什么区别？

A: 核心区别在于操作对象。StringBuffer的substring()作用于可变对象，最终返回不可变String；而String的substring()直接操作不可变对象。性能上，StringBuffer版本因同步机制略慢，但提供了修改能力。

Q2: 为什么substring()返回String而不是StringBuffer？

A: 这是Java字符串不可变性的设计原则体现。即使从可变StringBuffer中截取，结果也应保持不可变性，防止意外修改影响程序其他部分。

Q3: 如何高效处理大字符串的多次截取？

A: 对于大字符串的多次截取操作，可以考虑：

// 示例：记录分割点
StringBuffer sb = new StringBuffer("A,B,C,D,E");
int[] commas = new int[4];
int pos = 0;
for (int i = 0; i 

public class StringUtil {
    /**
     * 安全截取字符串，自动处理边界情况
     * @param sb 原始StringBuffer
     * @param begin 起始索引
     * @param end 结束索引
     * @return 截取结果，索引非法时返回null
     */
    public static String safeSubstring(StringBuffer sb, int begin, int end) {
        if (sb == null) return null;
        int len = sb.length();
        if (begin  len) end = len;
        if (begin > end) return null;
        try {
            return sb.substring(begin, end);
        } catch (IndexOutOfBoundsException e) {
            return null;
        }
    }

    /**
     * 按正则表达式截取
     * @param sb 原始StringBuffer
     * @param regex 正则表达式
     * @return 匹配的第一个子串，未匹配返回null
     */
    public static String substringByRegex(StringBuffer sb, String regex) {
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(sb);
        if (matcher.find()) {
            return matcher.group();
        }
        return null;
    }
}