Java中处理大量字符串拼接时，应优先使用StringBuilder或StringBuffer以避免频繁创建对象导致的性能问题；对于集合拼接可选用StringJoiner或String.join()；截取字符串需注意索引边界，防止越界异常，可通过预检查和Math.min等方法确保安全性；此外，String类还提供丰富的方法如equals、contains、replace、split等，支持内容比较、查找、替换、分割等常见操作，结合防御性编程可提升代码健壮性。
Java中操作字符串进行拼接和截取，核心在于理解字符串的不可变性。拼接通常会用到
+运算符、
concat()方法，或者更高效的
StringBuilder/
StringBuffer；而截取则主要依赖
substring()方法。
解决方案
字符串在Java里是个挺有意思的存在，一旦创建，它的内容就固定了，没法直接改。这种“不可变”的特性，既是优点（比如线程安全、哈希值稳定），也带来了一些挑战，尤其是在频繁操作字符串的时候。
字符串拼接（Concatenation）
-
使用
+
运算符： 这是最直观、最常用的方式，就像小学数学的加法一样。立即学习“Java免费学习笔记（深入）”；
String str1 = "Hello"; String str2 = "World"; String result = str1 + " " + str2 + "!"; // 结果是 "Hello World!" System.out.println(result);
背后原理：每次使用
+
拼接，JVM其实会偷偷创建一个新的String
对象来存放拼接后的内容。如果连续拼接很多次，就会创建一堆中间的、很快就会被GC（垃圾回收）的对象，效率就不高了。 -
使用
concat()
方法：String
类自带的concat()
方法也能实现拼接。String strA = "Java"; String strB = "教程"; String combined = strA.concat(strB); // 结果是 "Java教程" System.out.println(combined);
和
+
运算符类似，concat()
方法也会返回一个新的String
对象，原字符串不变。它不能像+
那样直接连接非字符串类型（比如数字），需要先转换为字符串。 -
使用
StringBuilder
或StringBuffer
： 这是处理大量或频繁拼接时的“主力军”。它们是可变的，不像String
那样每次操作都生成新对象。StringBuilder
：非线程安全，但在单线程环境下性能最佳。StringBuffer
：线程安全，方法都加了synchronized
关键字，所以在多线程并发操作时更安全，但性能略低于StringBuilder
。// 使用 StringBuilder StringBuilder sb = new StringBuilder(); sb.append("你好").append("，").append("我是").append("Java").append("!"); String finalString = sb.toString(); // 转换为 String System.out.println(finalString); // 结果是 "你好，我是Java!"
// 如果是多线程环境，或者不确定，可以使用 StringBuffer StringBuffer sbuf = new StringBuffer(); sbuf.append("多线程").append("安全"); String safeString = sbuf.toString(); System.out.println(safeString);
我个人觉得，除非明确知道有并发需求，否则日常开发中`StringBuilder`几乎是首选，它的性能优势很明显。
字符串截取（Substring）
String类提供了两个
substring()方法来截取子字符串：
-
substring(int beginIndex)
： 从指定索引开始，截取到字符串的末尾。String original = "HelloJavaWorld"; String sub1 = original.substring(5); // 从索引5开始截取 System.out.println(sub1); // 结果是 "JavaWorld"
需要注意的是，Java的字符串索引是从0开始的。所以索引5是字符'J'。
-
substring(int beginIndex, int endIndex)
： 从beginIndex
（包含）开始，到endIndex
（不包含）结束，截取子字符串。String text = "Java编程指南"; // 截取 "编程" // 'J'是0，'a'是1，'v'是2，'a'是3，'编'是4，'程'是5，'指'是6 String sub2 = text.substring(4, 6); System.out.println(sub2); // 结果是 "编程"
这里
endIndex
是6，表示截取到索引5的字符（'程'），索引6的字符（'指'）不包含在内。这和很多编程语言的“左闭右开”区间是一致的，理解起来需要一点点适应。
Java中处理大量字符串拼接时，有哪些性能优化策略？
当程序需要进行大量的字符串拼接操作时，如果仍然沿用简单的
+运算符，那程序的性能可能会出现断崖式下跌。这主要是因为字符串的不可变性，每次
+操作都会生成新的
String对象，导致内存开销和垃圾回收的压力剧增。在我看来，这简直就是性能杀手。
最核心的优化策略，毫无疑问是使用StringBuilder
或StringBuffer
。它们内部维护一个可变的字符数组，
append()操作直接修改这个数组，而不是创建新对象。
举个例子，假设你要拼接10000个单词：
// 性能不佳的写法
long startTime = System.nanoTime();
String resultBad = "";
for (int i = 0; i < 10000; i++) {
resultBad += "word" + i;
}
long endTime = System.nanoTime();
System.out.println("使用 + 拼接耗时: " + (endTime - startTime) / 1_000_000 + " ms");
// 这种方式会创建大量的 String 对象，性能极差// 推荐的优化写法
long startTimeOpt = System.nanoTime();
StringBuilder sbOpt = new StringBuilder();
// 如果能预估最终字符串的长度，可以预设容量，进一步减少内部数组扩容的开销
// StringBuilder sbOpt = new StringBuilder(10000 * 5); // 假设每个wordX平均5个字符
for (int i = 0; i < 10000; i++) {
sbOpt.append("word").append(i);
}
String resultOpt = sbOpt.toString();
long endTimeOpt = System.nanoTime();
System.out.println("使用 StringBuilder 拼接耗时: " + (endTimeOpt - startTimeOpt) / 1_000_000 + " ms");
// 这种方式只创建少数几个 StringBuilder 内部数组，性能高得多实际运行你会发现，两者的耗时差距是数量级的。
另外，对于某些特定场景，比如需要将集合中的字符串用分隔符连接起来，Java 8引入的
StringJoiner也非常好用，它在内部也是基于
StringBuilder实现的，提供更简洁的API：
import java.util.StringJoiner; import java.util.Arrays; import java.util.List; Listitems = Arrays.asList("Apple", "Banana", "Orange"); StringJoiner sj = new StringJoiner(", ", "[", "]"); // 分隔符, 前缀, 后缀 for (String item : items) { sj.add(item); } System.out.println(sj.toString()); // 结果是 "[Apple, Banana, Orange]" // 或者更简洁地结合 Stream API String joinedString = String.join(" - ", items); System.out.println(joinedString); // 结果是 "Apple - Banana - Orange"
String.join()方法也是一个不错的选择，它在底层也做了优化，适合连接少量字符串或集合。
总结一下，遇到字符串拼接，特别是循环或大量拼接，优先考虑
StringBuilder。如果涉及多线程，则选择
StringBuffer。而对于集合的拼接，
StringJoiner和
String.join()能让代码更优雅。
如何安全地处理字符串截取可能遇到的边界问题？
字符串截取，也就是
substring()方法，虽然用起来简单，但它也是
IndexOutOfBoundsException（索引越界异常）的“高发区”。我遇到过不少新手，甚至包括我自己，在刚开始写代码的时候，都因为索引计算错误导致程序崩溃。这玩意儿一旦抛出来，那可就直接让你的程序“歇菜”了。
核心在于：在调用substring()
之前，务必对传入的索引进行有效性检查。
substring()方法的规则是：
beginIndex
必须大于等于0。beginIndex
必须小于等于字符串的长度（length()
）。endIndex
必须大于等于beginIndex
。endIndex
必须小于等于字符串的长度（length()
）。
如果这些条件不满足，就会抛出
IndexOutOfBoundsException。
来看几个常见的场景和我的处理思路：
-
防止负数索引或索引过大：
String myString = "HelloWorld"; int begin = -1; // 错误的索引 int end = 100; // 错误的索引 // 错误的调用会导致异常 // String sub = myString.substring(begin); // String sub2 = myString.substring(0, end); // 正确的做法：先检查 if (begin >= 0 && begin < myString.length()) { String sub = myString.substring(begin); System.out.println("截取结果: " + sub); } else { System.out.println("开始索引 " + begin + " 无效。"); } if (begin >= 0 && end <= myString.length() && begin <= end) { String sub = myString.substring(begin, end); System.out.println("截取结果: " + sub); } else { System.out.println("截取范围 [" + begin + ", " + end + "] 无效。"); } -
处理空字符串或长度不足的字符串： 如果字符串是
null
，调用任何方法都会抛出NullPointerException
。如果是空字符串""
，它的length()
是0。String emptyStr = ""; // String sub = emptyStr.substring(0); // 抛出 IndexOutOfBoundsException // String sub2 = emptyStr.substring(0, 0); // 这个是合法的，返回空字符串 // 始终先检查非空和长度 if (myString != null && myString.length() > 0) { // 进行截取操作 // ... } else { System.out.println("字符串为空或null，无法截取。"); }我个人的习惯是，在接收外部输入（比如用户输入、文件读取、网络请求）的字符串进行截取时，都会做这些防御性检查。这能极大地提高程序的健壮性，避免一些难以预料的运行时错误。
-
灵活调整截取范围： 有时候我们想截取固定长度，但字符串可能不够长。
String shortStr = "abc"; int desiredLength = 5; int actualEndIndex = Math.min(shortStr.length(), desiredLength); String result = shortStr.substring(0, actualEndIndex); System.out.println("灵活截取: " + result); // 结果是 "abc"使用
Math.min()
可以确保endIndex
不会超过字符串的实际长度。这是一种很实用的技巧，能避免很多边界问题。
记住，防御性编程在字符串处理中尤为重要。多写几行检查代码，可以省去调试时的大量头疼时间。
除了拼接和截取，Java字符串还有哪些常用的操作方法？
字符串作为日常编程中使用频率最高的类型之一，除了拼接和截取，Java的
String类还提供了极其丰富的方法来满足各种操作需求。我经常感叹，Java的API设计在这方面确实考虑得很周全，很多常见的需求都有现成的方法可以直接用。
这里列举一些我个人觉得非常常用且重要的操作方法：
-
内容比较：
equals()
和equalsIgnoreCase()
equals(Object anObject)
：比较两个字符串的内容是否完全相同（区分大小写）。这是比较字符串内容是否相等唯一正确的方式，千万不要用==
来比较字符串内容，==
比较的是对象的引用地址。equalsIgnoreCase(String anotherString)
：比较两个字符串的内容是否相同，忽略大小写。String s1 = "Hello"; String s2 = "hello"; System.out.println(s1.equals(s2)); // false System.out.println(s1.equalsIgnoreCase(s2)); // true
-
查找与判断：
contains()
,startsWith()
,endsWith()
,indexOf()
,lastIndexOf()
contains(CharSequence s)
：判断字符串是否包含另一个子字符串。startsWith(String prefix)
：判断字符串是否以指定前缀开始。endsWith(String suffix)
：判断字符串是否以指定后缀结束。indexOf(String str)
/indexOf(String str, int fromIndex)
：查找子字符串第一次出现的位置（返回索引），找不到则返回-1。lastIndexOf(String str)
：查找子字符串最后一次出现的位置。String data = "Java programming is fun"; System.out.println(data.contains("pro")); // true System.out.println(data.startsWith("Java")); // true System.out.println(data.indexOf("a")); // 1 (第一个'a'的索引) System.out.println(data.lastIndexOf("a")); // 16 (最后一个'a'的索引)
-
替换：
replace()
,replaceAll()
,replaceFirst()
replace(char oldChar, char newChar)
：替换所有旧字符为新字符。replace(CharSequence target, CharSequence replacement)
：替换所有目标序列为替换序列。replaceAll(String regex, String replacement)
：用正则表达式替换所有匹配项。replaceFirst(String regex, String replacement)
：用正则表达式替换第一个匹配项。String msg = "Hello World World"; System.out.println(msg.replace('o', 'X')); // HellX WXrld WXrld System.out.println(msg.replace("World", "Java")); // Hello Java Java System.out.println(msg.replaceAll("World", "Java")); // Hello Java Java System.out.println(msg.replaceFirst("World", "Java")); // Hello Java WorldreplaceAll
和replaceFirst
因为支持正则表达式，所以功能非常强大，但也需要对正则表达式有一定了解。
-
大小写转换：
toLowerCase()
,toUpperCase()
toLowerCase()
：将字符串转换为小写。toUpperCase()
：将字符串转换为大写。String mixedCase = "AbCdEf"; System.out.println(mixedCase.toLowerCase()); // abcdef System.out.println(mixedCase.toUpperCase()); // ABCDEF
-
去除空白：
trim()
,strip()
,stripLeading()
,stripTrailing()
trim()
：去除字符串两端的ASCII空白字符（空格、制表符、换行符等）。strip()
(Java 11+)：去除字符串两端的Unicode空白字符。stripLeading()
(Java 11+)：去除字符串开头的Unicode空白字符。stripTrailing()
(Java 11+)：去除字符串末尾的Unicode空白字符。String spaced = " Hello World \n"; System.out.println("'" + spaced.trim() + "'"); // 'Hello World' // Java 11+ // System.out.println("'" + spaced.strip() + "'");在处理用户输入或从文件中读取数据时，
trim()
（或Java 11+的strip()
）是清理数据的常用手段。
-
分割：
split()
split(String regex)
：根据正则表达式将字符串分割成字符串数组。String csvData = "apple,banana,orange"; String[] fruits = csvData.split(","); for (String fruit : fruits) { System.out.println(fruit); } // 输出： // apple // banana // orange这个方法在处理结构化数据时非常有用，比如解析CSV文件或日志行。
这些方法只是
String类庞大功能集的一部分，但它们涵盖了日常开发中绝大多数的字符串操作场景。熟练掌握这些方法，能让你的代码更简洁、高效。
