Java中常见字符串操作

文章目录

• • • [1. 字符串的创建](#1. 字符串的创建)
    • [2. 字符串的拼接](#2. 字符串的拼接)
    • [3. 字符串的比较](#3. 字符串的比较)
    • [4. 字符串的查找](#4. 字符串的查找)
    • [5. 字符串的截取](#5. 字符串的截取)
    • • [`substring(int beginInde)` 方法](#substring(int beginInde) 方法)
      • [`substring()` 方法](#substring() 方法)
    • [6. 字符串的替换](#6. 字符串的替换)
    • • [`replace()` 方法](#replace() 方法)
      • [`replace()` 方法](#replace() 方法)
      • [`replaceAll()` 方法](#replaceAll() 方法)
    • [7. 字符串的分割](#7. 字符串的分割)
    • • [`split(String regex)` 方法](#split(String regex) 方法)
    • [8. 字符串的大小写转换](#8. 字符串的大小写转换)
    • • [`toUpperCase()` 方法](#toUpperCase() 方法)
      • [`toLowerCase()` 方法](#toLowerCase() 方法)
    • [9. 字符串的去除空白](#9. 字符串的去除空白)
    • • [`trim()` 方法](#trim() 方法)
    • [10. 字符串的长度获取](#10. 字符串的长度获取)
    • • [`length()` 方法](#length() 方法)
    • [11. 字符串与字符数组的转换](#11. 字符串与字符数组的转换)
    • • 字符串转字符数组
      • 字符数组转字符串
    • [12. 字符串与字节数组的转换](#12. 字符串与字节数组的转换)
    • • 字符串转字节数组

在 Java 里，字符串操作是编程中经常会用到的内容。 String 类提供了大量实用的方法来处理字符串。以下是对常见字符串操作的详细介绍：

1. 字符串的创建

• 使用字符串字面量：这是最常用的方式，字符串字面量会存储在字符串常量池中。

String str1 = "Hello";

当使用字符串字面量创建字符串时，Java 会首先检查字符串常量池（也称为串池）中是否已经存在相同内容的字符串。如果存在，就直接返回该字符串在串池中的引用；如果不存在，就在串池中创建一个新的字符串对象，并返回其引用。例如：

String str2 = "Hello";
System.out.println(str1 == str2); // 输出 true，因为 str1 和 str2 指向串池中

• 使用 new 关键字：会在堆内存中创建新的字符串对象。

String str2 = new String("World");

使用 new 关键字创建字符串对象时，无论串池中是否已经存在相同内容的字符串，都会在堆内存中创建一个新的字符串对象。例如：

String str4 = new String("World");
System.out.println(str3 == str4); // 输出 false，因为 str3 和 str4 是堆内存

2. 字符串的拼接

• 使用 + 运算符：可拼接字符串字面量、变量和其他数据类型，操作简单，但在循环中频繁使用会影响性能。

String str1 = "Hello";
String str2 = "World";
String result1 = str1 + " " + str2;

+ 运算符是最常用的字符串拼接方式，它可以用于拼接字符串字面量、字符串变量以及其他数据类型。当 + 运算符的一侧是字符串时，另一侧的操作数会被自动转换为字符串类型 。不过，在循环中频繁使用 + 运算符进行字符串拼接会导致性能问题，因为每次拼接都会创建一个新的字符串对象。例如：

String result = "";
for (int i = 0; i < 1000; i++) {
    result = result + i;
}

上述代码在循环中会创建大量的临时字符串对象，消耗大量的内存和时间。

• 使用 concat() 方法 ：String 类的方法，只能拼接字符串类型。

String result2 = str1.concat(" ").concat(str2);

concat() 方法是 String 类提供的用于拼接字符串的方法，它接受一个字符串参数，并将该字符串拼接在调用该方法的字符串后面。与 + 运算符相比，concat() 方法在某些场景下性能稍好，因为它不会创建多余的中间对象。但 concat() 方法只能拼接字符串类型，不能直接拼接其他数据类型，需要先将其他数据类型转换为字符串。例如：

int num = 123;
// 报错，不能直接拼接整数
// String result = str1.concat(num); 
String result = str1.concat(String.valueOf(num));

• 使用 StringBuilder 或 StringBuffer ：适用于大量字符串拼接，StringBuilder 非线程安全，性能好；StringBuffer 线程安全。

StringBuilder sb = new StringBuilder();
sb.append(str1).append(" ").append(str2);
String result3 = sb.toString();

StringBuilder 和 StringBuffer 都是可变的字符序列，它们提供了 append() 方法用于拼接字符串。StringBuilder 是非线程安全的，性能较高；StringBuffer 是线程安全的，但性能相对较低。在大量字符串拼接的场景下，特别是在循环中，建议使用 StringBuilder 或 StringBuffer。例如：

StringBuilder sb = new StringBuilder();
for (int i = 0; i < 1000; i++) {
    sb.append(i);
}
String result = sb.toString();

3. 字符串的比较

• 使用 equals() 方法：比较两个字符串的内容是否相同。

String str1 = "Hello";
String str2 = "Hello";
boolean isEqual1 = str1.equals(str2);

equals() 方法用于比较两个字符串的内容是否相同 。它会逐个比较两个字符串中的字符，如果所有字符都相同，则返回 true，否则返回 false。例如：

String str3 = "hello";
System.out.println(str1.equals(str3)); // 输出 false，因为大小写不同

• 使用 equalsIgnoreCase() 方法 ：比较字符串内容，忽略大小写。

String str3 = "hello";
boolean isEqual2 = str1.equalsIgnoreCase(str3);

equalsIgnoreCase() 方法用于比较两个字符串的内容是否相同，忽略大小写。例如：

System.out.println(str1.equalsIgnoreCase(str3)); // 输出 true，忽略大小写

• 使用 == 运算符：比较两个字符串的引用是否相同。

boolean isSame = str1 == str2;

== 运算符用于比较两个字符串的引用是否相同，即判断它们是否指向内存中的同一个对象。例如：

String str4 = new String("Hello");
System.out.println(str1 == str4); // 输出 false，因为 str1 和 str4 指向不同

4. 字符串的查找

• indexOf() 方法：返回指定字符或子字符串首次出现的索引，若未找到返回 -1。

String str = "Hello World";
int index1 = str.indexOf("World");

indexOf() 方法用于返回指定字符或子字符串首次出现的索引。如果未找到，则返回 -1。例如：

int index2 = str.indexOf("Java");
System.out.println(index2); // 输出 -1，因为字符串中不包含 "Java"

indexOf() 方法还有一个重载形式 indexOf(int ch, int fromIndex)，用于从指定的索引位置开始查找字符。例如：

int index3 = str.indexOf('l', 3);
System.out.println(index3); // 输出 3，从索引 3 开始查找字符 'l'

• lastIndexOf() 方法 ：返回指定字符或子字符串最后一次出现的索引，未找到返回 -1。

int index2 = str.lastIndexOf("l");

lastIndexOf() 方法用于返回指定字符或子字符串最后一次出现的索引。如果未找到，则返回 -1。例如：

int index5 = str.lastIndexOf("Java");
System.out.println(index5); // 输出 -1，因为字符串中不包含 "Java"

lastIndexOf() 方法也有一个重载形式 lastIndexOf(int ch, int fromIndex)，用于从指定的索引位置开始向前查找字符。例如：

int index6 = str.lastIndexOf('l', 4);
System.out.println(index6); // 输出 3，从索引 4 开始向前查找字符 'l'

• contains() 方法 ：判断字符串是否包含指定的子字符串。

boolean contains = str.contains("Hello");

contains() 方法用于判断字符串是否包含指定的子字符串。如果包含，则返回 true，否则返回 false。例如：

boolean containsJava = str.contains("Java");
System.out.println(containsJava); // 输出 false，因为字符串中不包含 "Java"

5. 字符串的截取

substring(int beginInde) 方法

String subStr1 = str.substring(6);

substring(int beginIndex) 方法用于从指定的索引位置开始截取到字符串的末尾。例如：

System.out.println(subStr1); // 输出 "World"

substring() 方法

String subStr2 = str.substring(0, 5);

substring(int beginIndex, int endIndex) 方法用于从 beginIndex 开始截取到 endIndex - 1 的位置。例如：

System.out.println(subStr2); // 输出 "Hello"

需要注意的是，beginIndex 必须大于等于 0，endIndex 必须大于 beginIndex 且小于等于字符串的长度 ，否则会抛出 StringIndexOutOfBoundsException 异常。

6. 字符串的替换

replace() 方法

String replaced1 = str.replace('l', 'L');

replace(char oldChar, char newChar) 方法用于将字符串中所有的 oldChar 替换为 newChar。例如:

System.out.println(replaced1); // 输出 "HeLLo WorLd"

replace() 方法

String replaced2 = str.replace("World", "Java");

replace(CharSequence target, CharSequence replacement) 方法用于将字符串中所有的 target 子字符串替换为 replacement。例如：

System.out.println(replaced2); // 输出 "Hello Java"

replaceAll() 方法

String replaced3 = str.replaceAll("\\s", "");

replaceAll(String regex, String replacement) 方法使用正则表达式替换所有匹配的子字符串。例如，上述代码将字符串中的所有空格替换为空字符串。需要注意的是，正则表达式中的特殊字符需要进行转义。例如：

String strWithDigits = "abc123def456";
String replaced4 = strWithDigits.replaceAll("\\d", "");
System.out.println(replaced4); // 输出 "abcdef"，将所有数字替换为空字符串

7. 字符串的分割

split(String regex) 方法

String[] parts = str.split(" ");

split(String regex) 方法根据正则表达式将字符串分割成字符串数组。例如，上述代码将字符串按空格分割成多个子字符串。例如：

for (String part : parts) {
    System.out.println(part);
}

输出结果为：

Hello
World

split() 方法还有一个重载形式 split(String regex, int limit)，用于指定分割的最大次数。例如：

String[] parts2 = str.split(" ", 2);
for (String part : parts2) {
    System.out.println(part);
}

输出结果为：

Hello
World

在这个例子中，由于 limit 为 2，所以最多分割成 2 个部分。

8. 字符串的大小写转换

toUpperCase() 方法

String upperCase = str.toUpperCase();

toUpperCase() 方法用于将字符串转换为大写形式。例如：

System.out.println(upperCase); // 输出 "HELLO WORLD"

toLowerCase() 方法

String lowerCase = str.toLowerCase();

toLowerCase() 方法用于将字符串转换为小写形式。例如：

System.out.println(lowerCase); // 输出 "hello world"

9. 字符串的去除空白

trim() 方法

String strWithSpaces = "  Hello World  ";
String trimmed = strWithSpaces.trim();

trim() 方法用于去除字符串首尾的空白字符。例如：

System.out.println(trimmed); // 输出 "Hello World"

10. 字符串的长度获取

length() 方法

int length = str.length();

length() 方法用于返回字符串的长度，即字符串中字符的个数。例如：

System.out.println(length); // 输出 11

11. 字符串与字符数组的转换

字符串转字符数组

char[] charArray = str.toCharArray();

toCharArray() 方法用于将字符串转换为字符数组。例如：

for (char c : charArray) {
    System.out.print(c + " ");
}

输出结果为：

H e l l o   W o r l d 

字符数组转字符串

char[] charArray2 = {'H', 'e', 'l', 'l', 'o'};
String newStr = new String(charArray2);

可以使用 String 类的构造方法将字符数组转换为字符串。例如：

System.out.println(newStr); // 输出 "Hello"

12. 字符串与字节数组的转换

字符串转字节数组

byte[] byteArray = str.getBytes();

getBytes() 方法用于将**字符串转换为字节数组**。默认情况下，使用平台的默认字符集进行编码。也可以指定字符集，例如：

try {
    byte[] byteArray2 = str.getBytes("UTF-8");
} catch (java.io.UnsupportedEncodingException e) {
    e.printStackTrace();
}

字节数组转字符串
byte[] byteArray3 = {72, 101, 108, 108, 111};
String newStr2 = new String(byteArray3);

可以使用 String 类的构造方法将**字节数组转换为字符串**。默认情况下，使用平台的默认字符集进行解码。也可以指定字符集，例如：

try {
    String newStr3 = new String(byteArray3, "UTF-8");
} catch (java.io.UnsupportedEncodingException e) {
    e.printStackTrace();
}