在循环中推荐使用Stringbuilder进行字符串拼接，因为string是不可变的，每次+操作都会创建新对象，导致大量内存开销和频繁垃圾回收，而stringbuilder内部维护可变字符数组，通过append()方法直接在原数组上操作，避免了重复创建对象，显著提升性能；1. 使用+操作符在循环中拼接字符串会因string不可变性导致性能低下；2. concat()方法同样生成新对象，效率不高；3. stringbuilder是非线程安全的可变类，适合单线程下的高效拼接；4. stringbuffer是线程安全的，适用于多线程环境但性能略低；5. 因此在循环拼接时应优先使用stringbuilder以获得最佳性能。
Java字符串的拼接操作，通常我们会用到
+
操作符、
concat()
方法，以及更高效的
StringBuilder
和
StringBuffer
类。而字符串的分割，则主要依赖于
split()
方法。掌握这些工具各自的特点和适用场景，对于编写高性能、可维护的Java代码至关重要。这不仅仅是语法层面的理解，更关乎在不同上下文中的最佳实践选择。
字符串的拼接，在Java里有几种常见手段，每种都有它的用武之地，但效率和原理却大相径庭。最直观的莫过于
+
操作符，它用起来确实方便，比如
"Hello" + " " + "World"
，代码简洁明了。但如果是在循环里进行大量拼接，比如迭代一个列表来构建一个长字符串，那么
+
操作符的效率会非常低。这是因为Java中的
String
是不可变的，每次
+
操作都会创建一个新的
String
对象，旧的字符串被丢弃，这无疑增加了垃圾回收的压力和内存消耗。
concat()
方法也类似，它也是
String
类的一个方法，用于将指定字符串连接到当前字符串的末尾。比如
str1.concat(str2)
，它的本质和
+
操作符在拼接少量字符串时差异不大，同样会生成新的
String
对象。
立即学习“Java免费学习笔记（深入）”；
真正改变游戏规则的是
StringBuilder
和
StringBuffer
。它们设计之初就是为了解决字符串频繁修改（包括拼接）的效率问题。这两个类都是可变的，它们内部维护一个可变的字符数组，当进行拼接操作时，它们会直接在这个数组上进行修改或扩容，而不是像
String
那样每次都创建新对象。
StringBuilder
是非线程安全的，所以在单线程环境下，它的性能是最好的选择。而
StringBuffer
是线程安全的，所有公共方法都经过同步处理，适合多线程并发操作，但相对而言会带来一些性能开销。我的经验是，如果不是明确需要线程安全，就无脑用
StringBuilder
，性能表现会让你满意。
至于字符串的分割，
String
类的
split()
方法是主力。它接受一个正则表达式作为分隔符，然后将字符串分割成一个
String
数组。比如
"apple,banana,orange".split(",")
就会得到一个包含”apple”, “banana”, “orange”的数组。这个方法非常强大，但也需要注意正则表达式的特性，因为一些特殊字符（比如
.
、
|
、
*
等）在正则表达式中是有特殊含义的，如果想用它们作为字面量分隔符，就需要进行转义。
为什么在循环中推荐使用StringBuilder进行字符串拼接？
这几乎是Java字符串处理中最常被提及的性能优化点，但其背后的原理却值得深思。简单来说，Java中的
String
对象是不可变的（Immutable）。这意味着一旦一个
String
对象被创建，它的内容就不能被改变。每次你看起来像是在修改一个字符串，比如用
+
操作符进行拼接，实际上Java虚拟机（jvm）都在背后默默地做着一件“昂贵”的事情：它会创建一个全新的
String
对象来存储拼接后的结果，而原来的字符串对象则保持不变，等待垃圾回收器来清理。
想象一下，在一个循环里进行上千次甚至上万次的字符串拼接。每一次拼接，JVM都要：
- 分配新的内存空间来容纳新的、更大的字符串。
- 将旧字符串的内容复制到新内存中。
- 将要拼接的新内容也复制到新内存中。
- 最终，旧的字符串对象就成了“垃圾”，等待被回收。
这个过程在内存分配和数据复制上消耗巨大，导致性能急剧下降，尤其当字符串长度越来越长时，复制的数据量也呈线性增长。这就像你每次想给一份文档添加内容，不是直接在原文档上修改，而是把旧文档内容抄一遍，再把新内容抄上去，形成一份全新的文档。效率可想而知。
而
StringBuilder
（以及它的线程安全版本
StringBuffer
）则完全不同。它们内部维护的是一个可变的字符数组。当你调用
append()
方法时，如果内部数组还有空间，它会直接在现有数组的末尾添加字符；如果空间不足，它会智能地扩容（通常是当前容量的两倍加二），然后继续在原数组上操作。整个过程中，它避免了反复创建新的
String
对象，从而大大减少了内存分配和垃圾回收的开销。所以，在循环中进行字符串拼接时，
StringBuilder
几乎是唯一的，也是最佳的选择。
举个例子，假设我们要拼接10000个数字：
// 使用 + 操作符 (不推荐在循环中使用) long startTime = System.nanoTime(); String resultPlus = ""; for (int i = 0; i < 10000; i++) { resultPlus += i; } long endTime = System.nanoTime(); System.out.println("使用 + 操作符耗时: " + (endTime - startTime) + " 纳秒"); // 使用 StringBuilder (推荐) startTime = System.nanoTime(); StringBuilder resultBuilder = new StringBuilder(); for (int i = 0; i < 10000; i++) { resultBuilder.append(i); } String finalResult = resultBuilder.toString(); // 最终只创建一次String对象 endTime = System.nanoTime(); System.out.println("使用 StringBuilder 耗时: " + (endTime - startTime) + " 纳秒");
你会发现
StringBuilder
的性能远超
+
操作符，尤其是在数据量大的情况下，差距是数量级的。
Java字符串分割时，如何处理特殊字符和空字符串？
String.split()
方法是一个非常方便的工具，但它背后依赖的是正则表达式（Regex），这就意味着在使用时需要对正则表达式的规则有所了解，否则很容易踩坑。最常见的坑就是分隔符本身在正则表达式中有特殊含义。
处理特殊字符： 正则表达式中，一些字符被赋予了特殊意义，比如：
-
.
：匹配任意单个字符（除了换行符）。
-
*
：匹配前一个元素零次或多次。
-
+
：匹配前一个元素一次或多次。
-
?
：匹配前一个元素零次或一次。
-
|
：逻辑或，匹配左边或右边。
-
：转义字符，用于转义其他特殊字符或表示特殊序列。
-
[
]
：字符集。
-
(
)
：分组。
-
{}
：量词。
-
^
：行的开头。
-
$
：行的结尾。
如果你想用这些特殊字符作为字面量分隔符，就必须对它们进行转义，即在它们前面加上
。例如，如果你想用句点
.
来分割字符串，你需要写成
"."
，而不是
"."
。
String data = "item1.item2.item3"; String[] parts = data.split("."); // 正确：使用 . 转义句点 System.out.println("分割结果 (句点): " + String.join(", ", parts)); // 输出：item1, item2, item3 String path = "foldersubfolderfile.txt"; String[] pathParts = path.split("\"); // 正确：使用 \ 转义反斜杠 System.out.println("分割结果 (反斜杠): " + String.join(", ", pathParts)); // 输出：folder, subfolder, file.txt // 如果不转义，比如用 "." 分割： String trickyData = "price.12.34"; String[] trickyParts = trickyData.split("."); // 错误：. 匹配任意字符，会得到空数组或意想不到的结果 System.out.println("错误分割 (未转义句点): " + String.join(", ", trickyParts)); // 可能会输出空，取决于Java版本和具体实现
为了避免这种麻烦，当你不确定一个字符串是否包含正则表达式特殊字符时，可以使用
Pattern.quote()
方法来自动转义。
String literalDelimiter = "."; String[] safeParts = data.split(Pattern.quote(literalDelimiter)); // 安全地使用字面量句点 System.out.println("安全分割 (Pattern.quote): " + String.join(", ", safeParts));
处理空字符串：
split()
方法在处理空字符串或连续分隔符时，行为可能会有点“微妙”，这取决于
limit
参数的使用以及Java的版本。
- 连续分隔符： 默认情况下，
split()
会忽略尾部的空字符串。但如果分隔符在字符串中间连续出现，它们会产生空的字符串元素。
String csv = "apple,,banana,orange,"; String[] items = csv.split(","); System.out.println("默认分割 (连续和尾部空): " + String.join("|", items)); // 输出：apple||banana|orange // 注意：尾部的空字符串被省略了。 // 如果需要保留尾部空字符串，可以使用 limit 参数为负数 String[] allItems = csv.split(",", -1); System.out.println("保留尾部空字符串: " + String.join("|", allItems)); // 输出：apple||banana|orange|
- 空字符串作为分隔符： 如果你尝试用空字符串
""
作为分隔符，
split()
会将字符串分割成单个字符。
String word = "hello"; String[] chars = word.split(""); System.out.println("按字符分割: " + String.join("|", chars)); // 输出：h|e|l|l|o
- 字符串本身为空或只有分隔符：
-
"".split(",")会返回一个包含单个空字符串
[""]
的数组。
-
",".split(",")也会返回一个包含两个空字符串
["", ""]
的数组。
- 这点在处理用户输入或文件读取时需要特别注意，可能需要额外的逻辑来过滤掉空字符串。
-
在实际开发中，我通常会在分割前对字符串进行
trim()
操作来去除首尾空格，或者在分割后遍历结果数组，过滤掉那些
isEmpty()
的元素，以确保数据的干净。
除了拼接与分割，还有哪些实用的Java字符串操作技巧？
字符串操作远不止拼接和分割这么简单，Java的
String
类和相关工具提供了极其丰富的API，能满足绝大多数文本处理需求。掌握这些技巧，能让你的代码更健壮、更高效。
-
去除首尾空白：
trim()
、
strip()
、
stripLeading()
、
stripTrailing()
trim()
是老牌方法，去除字符串两端的ASCII码小于等于U+0020（空格符）的字符。Java 11引入了更强大的
strip()
、
stripLeading()
、
stripTrailing()
，它们能够识别所有Unicode空白字符，而不仅仅是ASCII空格，这在处理国际化文本时非常有用。
String textWithSpaces = " Hello World! "; System.out.println("trim(): '" + textWithSpaces.trim() + "'"); // 'Hello World!' System.out.println("strip(): '" + textWithSpaces.strip() + "'"); // 'Hello World!' (更广泛的空白字符) -
提取子字符串：
substring()
substring()
可以从一个大字符串中截取一部分。它有两个重载版本：
substring(int beginIndex)
从指定索引开始到字符串末尾；
substring(int beginIndex, int endIndex)
从
beginIndex
开始到
endIndex-1
结束。
String sentence = "The quick brown fox"; String word = sentence.substring(4, 9); // "quick" System.out.println("Substring: " + word); -
替换字符或子字符串：
replace()
,
replaceAll()
,
replaceFirst()
-
replace(char oldChar, char newChar)
：替换所有匹配的字符。
-
replace(CharSequence target, CharSequence replacement)
：替换所有匹配的子字符串。
-
replaceAll(String regex, String replacement)
：使用正则表达式替换所有匹配的子字符串。
-
replaceFirst(String regex, String replacement)
：使用正则表达式替换第一个匹配的子字符串。
String data = "Java is fun, Java is powerful."; System.out.println("replace 'Java' with 'python': " + data.replace("Java", "Python")); System.out.println("replaceAll 'is (w+)' with 'was $1': " + data.replaceAll("is (w+)", "was $1")); -
-
查找与判断：
contains()
,
startsWith()
,
endsWith()
,
indexOf()
,
lastIndexOf()
-
contains(CharSequence s)
：判断字符串是否包含指定的字符序列。
-
startsWith(String prefix)
/
endsWith(String suffix)
：判断字符串是否以指定的前缀或后缀开始/结束。
-
indexOf(int ch)
/
indexOf(String str)
：返回指定字符或子字符串第一次出现的索引。
-
lastIndexOf(int ch)
/
lastIndexOf(String str)
：返回指定字符或子字符串最后一次出现的索引。
String email = "user@example.com"; if (email.contains("@") && email.endsWith(".com")) { System.out.println("Valid email format (simple check)."); } System.out.println("Index of '@': " + email.indexOf('@')); -
-
大小写转换：
toUpperCase()
,
toLowerCase()
将字符串转换为大写或小写。
String mixedCase = "HelloWorld"; System.out.println("Uppercase: " + mixedCase.toUpperCase()); System.out.println("Lowercase: " + mixedCase.toLowerCase()); -
字符串比较：
equals()
,
equalsIgnoreCase()
,
compareTo()
-
equals(Object anObject)
：比较两个字符串的内容是否相等，区分大小写。这是最常用的字符串比较方法。
-
equalsIgnoreCase(String anotherString)
：比较两个字符串的内容是否相等，忽略大小写。
-
compareTo(String anotherString)
：按字典顺序比较两个字符串。如果当前字符串小于、等于或大于另一个字符串，则分别返回负整数、零或正整数。
String s1 = "hello"; String s2 = "Hello"; System.out.println("s1 equals s2 (case-sensitive): " + s1.equals(s2)); // false System.out.println("s1 equalsIgnoreCase s2: " + s1.equalsIgnoreCase(s2)); // true -
-
格式化字符串：
String.format()
类似于c语言的
sprintf
，可以方便地构建格式化的字符串。
String name = "Alice"; int age = 30; String formattedString = String.format("My name is %s and I am %d years old.", name, age); System.out.println("Formatted string: " + formattedString); -
高效地连接字符串数组/集合：
String.join()
(Java 8+) 或
StringJoiner
String.join()
是一个非常方便的静态方法，它允许你使用指定的分隔符连接多个字符串或字符串数组。
List<String> fruits = Arrays.asList("apple", "banana", "cherry"); String joinedFruits = String.join(" - ", fruits); System.out.println("Joined fruits: " + joinedFruits); // apple - banana - cherry // StringJoiner 提供更灵活的控制，可以指定前缀和后缀 StringJoiner sj = new StringJoiner(", ", "[", "]"); sj.add("red").add("green").add("blue"); System.out.println("StringJoiner result: " + sj.toString()); // [red, green, blue]
这些实用技巧，配合对
String
不可变性和
StringBuilder
/
StringBuffer
可变性的深刻理解，能够让你在处理Java字符串时游刃有余，写出既高效又易读的代码。
