Java字符串拼接与截取技巧详解

本教程深入解析Java字符串拼接与截取的关键技巧，助力开发者高效处理字符串操作。针对字符串不可变性，详细讲解了`+`运算符、`concat()`方法以及`StringBuilder`/`StringBuffer`在不同场景下的应用，尤其强调了在大量拼接时使用`StringBuilder`的性能优势。同时，剖析了`substring()`方法的索引边界问题，提供预检查等防御性编程策略，避免`IndexOutOfBoundsException`。此外，还介绍了`equals`、`contains`、`replace`、`split`等常用字符串操作方法，助你提升代码的健壮性和效率，轻松应对各种字符串处理需求。掌握这些技巧，让你的Java字符串操作更加得心应手。

Java中处理大量字符串拼接时，应优先使用StringBuilder或StringBuffer以避免频繁创建对象导致的性能问题；对于集合拼接可选用StringJoiner或String.join()；截取字符串需注意索引边界，防止越界异常，可通过预检查和Math.min等方法确保安全性；此外，String类还提供丰富的方法如equals、contains、replace、split等，支持内容比较、查找、替换、分割等常见操作，结合防御性编程可提升代码健壮性。

Java中操作字符串进行拼接和截取，核心在于理解字符串的不可变性。拼接通常会用到+运算符、concat()方法，或者更高效的StringBuilder/StringBuffer；而截取则主要依赖substring()方法。

解决方案

字符串在Java里是个挺有意思的存在，一旦创建，它的内容就固定了，没法直接改。这种“不可变”的特性，既是优点（比如线程安全、哈希值稳定），也带来了一些挑战，尤其是在频繁操作字符串的时候。

字符串拼接（Concatenation）

1. 使用+运算符： 这是最直观、最常用的方式，就像小学数学的加法一样。

   String str1 = "Hello";
   String str2 = "World";
   String result = str1 + " " + str2 + "!"; // 结果是 "Hello World!"
   System.out.println(result);

   背后原理：每次使用+拼接，JVM其实会偷偷创建一个新的String对象来存放拼接后的内容。如果连续拼接很多次，就会创建一堆中间的、很快就会被GC（垃圾回收）的对象，效率就不高了。

2. 使用concat()方法： String类自带的concat()方法也能实现拼接。

   String strA = "Java";
   String strB = "教程";
   String combined = strA.concat(strB); // 结果是 "Java教程"
   System.out.println(combined);

   和+运算符类似，concat()方法也会返回一个新的String对象，原字符串不变。它不能像+那样直接连接非字符串类型（比如数字），需要先转换为字符串。

3. 使用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()方法来截取子字符串：

1. substring(int beginIndex)： 从指定索引开始，截取到字符串的末尾。

   String original = "HelloJavaWorld";
   String sub1 = original.substring(5); // 从索引5开始截取
   System.out.println(sub1); // 结果是 "JavaWorld"

   需要注意的是，Java的字符串索引是从0开始的。所以索引5是字符'J'。

2. 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;

List<String> items = 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。

来看几个常见的场景和我的处理思路：

1. 防止负数索引或索引过大：

   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 + "] 无效。");
   }

2. 处理空字符串或长度不足的字符串： 如果字符串是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，无法截取。");
   }

   我个人的习惯是，在接收外部输入（比如用户输入、文件读取、网络请求）的字符串进行截取时，都会做这些防御性检查。这能极大地提高程序的健壮性，避免一些难以预料的运行时错误。

3. 灵活调整截取范围： 有时候我们想截取固定长度，但字符串可能不够长。

   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设计在这方面确实考虑得很周全，很多常见的需求都有现成的方法可以直接用。

这里列举一些我个人觉得非常常用且重要的操作方法：

1. 内容比较：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

2. 查找与判断：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'的索引)

3. 替换：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 World

     replaceAll和replaceFirst因为支持正则表达式，所以功能非常强大，但也需要对正则表达式有一定了解。

4. 大小写转换：toLowerCase(), toUpperCase()

   • toLowerCase()：将字符串转换为小写。
   • toUpperCase()：将字符串转换为大写。

     String mixedCase = "AbCdEf";
     System.out.println(mixedCase.toLowerCase()); // abcdef
     System.out.println(mixedCase.toUpperCase()); // ABCDEF

5. 去除空白：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()）是清理数据的常用手段。

6. 分割：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类庞大功能集的一部分，但它们涵盖了日常开发中绝大多数的字符串操作场景。熟练掌握这些方法，能让你的代码更简洁、高效。

好了，本文到此结束，带大家了解了《Java字符串拼接与截取技巧详解》，希望本文对你有所帮助！关注golang学习网公众号，给大家分享更多文章知识！