java使用教程怎样操作字符串进行拼接截取 java使用教程的字符串处理方法指南-java教程-PHP中文网

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

java使用教程怎样操作字符串进行拼接截取 java使用教程的字符串处理方法指南

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;

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()

登录后复制

能让代码更优雅。

Grammarly

Grammarly是一款在线语法纠正和校对工具，伟大的AI辅助写作工具

253

查看详情

如何安全地处理字符串截取可能遇到的边界问题？

字符串截取，也就是

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 World

登录后复制

replaceAll

登录后复制

和

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文件或日志行。