Java字符串操作：substring陷阱与高效拼接实践

碧海醫心

发布时间：2025-11-04 15:57:00

514人浏览过

来源于php中文网

原创

Java字符串操作：substring陷阱与高效拼接实践

本文旨在解决java初学者在字符串操作中常遇到的`substring`方法误用及字符串拼接效率问题。通过分析`substring(index, index)`返回空字符串的原理，并纠正其正确用法`substring(index, index + 1)`，同时深入探讨java中`string`的不可变性，并推荐在循环中进行大量字符串修改时使用`stringbuilder`以提升程序性能，最终提供一套优化后的代码示例。

在Java编程中，字符串（String）是常用的数据类型，但其操作方式，尤其是截取和拼接，常常成为初学者混淆和遇到性能瓶颈的地方。本教程将围绕一个典型的字符串操作问题，详细解析其背后的原理，并提供最佳实践。

1. 原始问题分析：substring误用与意外输出

许多初学者在尝试从字符串中逐个字符提取时，可能会遇到代码运行但输出不符合预期的情况。以下是一个典型的示例代码：

package chucknorris;

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("Input string:");
        String input = scanner.nextLine();
        int length = input.length();
        String output = "test"; // 初始字符串

        for (int current = 0;current <= length;current++) {
            // 核心问题：substring(current, current)
            String letter = input.substring(current, current); 
            output = output + letter + " "; // 拼接空字符串

            if (current == length) {
                System.out.println(output);
            }
        }
    }
}

当输入例如 "hello" 时，程序期望输出 "test h e l l o "，但实际输出却是 "test"。

问题根源解析：

立即学习“Java免费学习笔记（深入）”；

String.substring(beginIndex, endIndex) 的工作原理：substring 方法用于截取字符串的一部分。它接受两个参数：beginIndex（包含）和 endIndex（不包含）。这意味着截取的子字符串是从 beginIndex 位置开始，到 endIndex - 1 位置结束。在上述代码中，input.substring(current, current) 的 beginIndex 和 endIndex 相同。根据其定义，这将截取一个长度为 current - current = 0 的字符串，即一个空字符串。因此，letter 变量在每次循环中都得到了一个空字符串。
循环条件与潜在的IndexOutOfBoundsException： 循环条件 current
输出时机：System.out.println(output) 被放置在 if (current == length) 条件内。这意味着只有当循环执行到超出字符串实际索引的最后一步时，才会打印最终结果。虽然这不是导致错误输出的原因，但也不是最佳实践。通常，最终结果应该在循环结束后统一输出。

2. 修正substring用法与循环逻辑

要正确地从字符串中提取单个字符，substring方法的endIndex应该比beginIndex大1。同时，循环条件也需要修正，以避免越界。

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("Input string:");
        String input = scanner.nextLine();
        int length = input.length();
        String output = "test"; // 初始字符串

        // 修正后的循环和substring用法
        for (int current = 0; current < length; current++) { // 循环条件修正为 current < length
            // 正确使用 substring 提取单个字符
            String letter = input.substring(current, current + 1); 
            output = output + letter; // 拼接提取到的字符
        }

        System.out.println(output); // 循环结束后统一输出
        scanner.close(); // 关闭Scanner资源
    }
}

修正后的代码说明：

for (int current = 0; current
String letter = input.substring(current, current + 1);: 这将正确地提取位于 current 索引位置的单个字符。
System.out.println(output);：将最终结果的打印移到循环外部，确保在所有拼接操作完成后再输出。
scanner.close();: 这是一个良好的编程习惯，用于释放 Scanner 对象占用的系统资源。

3. 字符串拼接的性能优化：String的不可变性与StringBuilder

尽管上述修正解决了功能上的问题，但在循环中频繁使用 output = output + letter; 这种方式进行字符串拼接，会带来显著的性能开销，尤其是在处理大量字符串或高频操作时。

Java中String的不可变性：

微信 WeLM

WeLM不是一个直接的对话机器人，而是一个补全用户输入信息的生成模型。

下载

在Java中，String对象是不可变的（immutable）。这意味着一旦一个 String 对象被创建，它的内容就不能被改变。每当执行 output = output + letter; 这样的操作时，Java虚拟机（JVM）实际上执行以下步骤：

创建一个新的 String 对象。
将 output 的内容复制到新对象中。
将 letter 的内容追加到新对象中。
将 output 变量的引用指向这个新创建的 String 对象。
原来的 output 对象（如果不再被引用）会成为垃圾回收的候选对象。

在循环中重复这个过程，会导致大量的 String 对象被创建和销毁，从而消耗大量的内存和CPU资源，降低程序性能。

使用StringBuilder进行高效拼接：

为了解决 String 不可变性带来的性能问题，Java提供了 StringBuilder（非线程安全）和 StringBuffer（线程安全）类。它们是可变的字符序列，允许在不创建新对象的情况下修改字符串内容。在单线程环境下，推荐使用 StringBuilder，因为它通常比 StringBuffer 性能更好。

以下是使用 StringBuilder 优化后的代码示例：

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("Input string:");
        String input = scanner.nextLine();

        // 使用 StringBuilder 进行字符串拼接
        StringBuilder stringBuilder = new StringBuilder("test"); // 初始化 StringBuilder

        for (int current = 0; current < input.length(); current++) {
            // 使用 append 方法添加字符
            stringBuilder.append(input.charAt(current)); // charAt(index) 更直接获取字符
        }

        // 最终通过 toString() 方法获取拼接后的 String 对象
        System.out.println(stringBuilder.toString()); 
        scanner.close();
    }
}

StringBuilder优化后的代码说明：

StringBuilder stringBuilder = new StringBuilder("test");: 创建一个 StringBuilder 对象，并用初始字符串 "test" 进行初始化。
stringBuilder.append(input.charAt(current));: 在循环中，我们使用 StringBuilder 的 append() 方法直接将字符追加到 stringBuilder 内部的字符数组中，而不会每次都创建新的 String 对象。charAt(current) 方法比 substring(current, current + 1) 更简洁地获取单个字符。
System.out.println(stringBuilder.toString());: 循环结束后，调用 stringBuilder.toString() 方法，将 StringBuilder 的内容转换为一个最终的 String 对象进行输出。

4. 总结与最佳实践

通过本文的分析和示例，我们可以得出以下关键点和最佳实践：

正确理解substring方法： substring(beginIndex, endIndex) 的 endIndex 是不包含的。要提取单个字符，应使用 substring(index, index + 1)。更推荐使用 charAt(index) 来获取单个字符。
注意循环边界条件： 在处理字符串索引时，循环条件通常是 current
理解String的不可变性： 认识到 String 对象一旦创建就不能修改，任何看似修改的操作实际上都会创建新的 String 对象。
高效字符串拼接： 在循环中进行多次字符串拼接时，应优先使用 StringBuilder（或 StringBuffer 在多线程环境下）而不是 + 运算符，以避免不必要的对象创建和提高程序性能。
资源管理： 对于像 Scanner 这样的资源，使用完毕后应调用 close() 方法释放资源。