Java中String類詳解之字符串操作的必備知識

更新時間：2025年09月10日 08:38:44 作者：IsLand1314~

Java String類是Java編程語言中的核心類,用于高效處理字符串操作,它在面試中常被問到,因為理解其特性與用法對于編寫高質(zhì)量的代碼至關(guān)重要,這篇文章主要介紹了Java中String類詳解之字符串操作的必備知識,需要的朋友可以參考下

1 基本概念

java.lang.String 類用于描述字符串，Java程序中所有的字符串面值都可以用該類的對象加以描述。
該類由 final 關(guān)鍵字修飾，表示該類不能被繼承。
從 jdk1.9開始該類的底層不使用 char[] 來存儲數(shù)據(jù)，而是改成 byte[] 加上編碼標記，從而節(jié)約了一些空間。
該類描述的字符串內(nèi)容是個常量，不可更改，可以被共享使用。

?? 創(chuàng)建字符串 String

// 方式一：使用常量串構(gòu)造
String str = "Hello Bit";
// 方式二：直接newString對象
String str2 = new String("Hello Bit");
// 方式三：使用字符數(shù)組進行構(gòu)造
char[] array = {'a', 'b', 'c'};
String str3 = new String(array);

2 字符串常量池

?? 常量池（了解）：由于String 類型描述的字符串內(nèi)容是常量不可改變，因此 Java 虛擬機將首次出現(xiàn)的字符串放入常量池中，若后續(xù)代碼中出現(xiàn)了相同字符串內(nèi)容則直接使用池中已有的字符串對象而無需申請內(nèi)存及創(chuàng)建對象，從而提高了性能

在下面的例子中, String類的兩種實例化操作, 直接賦值和 new 一個新的 String

（1）直接賦值

String str1 = "hello" ;
String str2 = "hello" ;
String str3 = "hello" ;
System.out.println(str1 == str2); // true
System.out.println(str1 == str3); // true
System.out.println(str2 == str3); // true

為什么現(xiàn)在并沒有開辟新的堆內(nèi)存空間呢？

String類的設(shè)計使用了共享設(shè)計模式

在JVM底層實際上會自動維護一個對象池（字符串常量池)

如果現(xiàn)在采用了直接賦值的模式進行String類的對象實例化操作，那么該實例化對象（字符串內(nèi)容）將自動保存到這個對象池之中.
如果下次繼續(xù)使用直接賦值的模式聲明String類對象，此時對象池之中如若有指定內(nèi)容，將直接進行引用
如若沒有，則開辟新的字符串對象而后將其保存在對象池之中以供下次使用

理解 "池" (pool)

"池" 是編程中的一種常見的, 重要的提升效率的方式, 我們會在未來的學(xué)習中遇到各種 "內(nèi)存池", "線程池", "數(shù)據(jù)庫連接池" ....
舉個栗子：
假如 A 對象為 B ，并且同時還有一個備胎 C，當 A 與 B 分手之后，A 就可以立即找 C接盤，這樣脫單效率比較高，如果 A 不止一個備胎的話，那么我們就稱這些備胎就稱為 備胎池。

（2）采用構(gòu)造方法

類對象使用構(gòu)造方法實例化是標準做法。分析如下程序：

String str = new String("hello") ;

這樣的做法有兩個缺點:

如果使用String構(gòu)造方法就會開辟兩塊堆內(nèi)存空間，并且其中一塊堆內(nèi)存將成為垃圾空間(字符串常量 "hello" 也是一個匿名對象，用了一次之后就不再使用了，就成為垃圾空間, 會被 JVM 自動回收掉).
字符串共享問題。同一個字符串可能會被存儲多次，比較浪費空間。我們可以使用 String 的 intern 方法來手動把 String 對象加入到字符串常量池中

// 該字符串常量并沒有保存在對象池之中
String str1 = new String("hello") ;
String str2 = "hello" ;
System.out.println(str1 == str2);
// 執(zhí)行結(jié)果
false
 
String str1 = new String("hello").intern() ;
String str2 = "hello" ;
System.out.println(str1 == str2);
// 執(zhí)行結(jié)果
true

因此我們就可以知道String類中兩種對象實例化的區(qū)別

直接賦值：只會開辟一塊堆內(nèi)存空間，并且該字符串對象可以自動保存在對象池中以供下次使用。
構(gòu)造方法：會開辟兩塊堆內(nèi)存空間，不會自動保存在對象池中，可以使用intern()方法手工入池。

3 字符串的不可變性

字符串是一種不可變對象. 它的內(nèi)容不可改變.

String 類的內(nèi)部實現(xiàn)也是基于 char[] 來實現(xiàn)的, 但是 String 類并沒有提供 set 方法之類的來修改內(nèi)部的字符數(shù)組.

舉個例子：

String str = "hello" ;
str = str + " world" ;
str += "!!!" ;
System.out.println(str);

// 執(zhí)行結(jié)果
hello world!!!

形如 += 這樣的操作, 表面上好像是修改了字符串, 其實不是. 內(nèi)存變化如下:

+= 之后 str 打印的結(jié)果卻是變了, 但是不是 String 對象本身發(fā)生改變, 而是 str 引用到了其他的對象.

任何對于 String 對象的修改操作實際上都相當于創(chuàng)建了一個新的 String 對象，而原對象將會被垃圾回收期處理

回顧引用

引用相當于一個指針, 里面存的內(nèi)容是一個地址. 我們要區(qū)分清楚當前修改到底是修改了地址對應(yīng)內(nèi)存的內(nèi)容發(fā)生改變了, 還是引用中存的地址改變了.

那么如果實在需要修改字符串, 例如, 現(xiàn)有字符串 str = "Hello" , 想改成 str = "hello" , 該怎么辦?

a. 常見辦法：

借助原字符串, 創(chuàng)建新的字符串

String str = "Hello";
str = "h" + str.substring(1);
System.out.println(str);
// 執(zhí)行結(jié)果
hello
String str = "Hello";

b. 特殊辦法(選學(xué))：

使用 "反射" 這樣的操作可以破壞封裝, 訪問一個類內(nèi)部的 private 成員。
IDEA 中 ctrl + 左鍵跳轉(zhuǎn)到 String 類的定義, 可以看到內(nèi)部包含了一個 char[] , 保存了字符串的內(nèi)容.

String str = "Hello"
// 獲取 String 類中的 value 字段. 這個 value 和 String 源碼中的 value 是匹配的.
Field valueField = String.class.getDeclaredField("value");
// 將這個字段的訪問屬性設(shè)為 true
valueField.setAccessible(true);
// 把 str 中的 value 屬性獲取到.
char[] value = (char[]) valueField.get(str);
// 修改 value 的值
value[0] = 'h';
System.out.println(str);
// 執(zhí)行結(jié)果
hello

關(guān)于反射

反射是面向?qū)ο缶幊痰囊环N重要特性, 有些編程語言也稱為 "自省".
指的是程序運行過程中, 獲取/修改某個對象的詳細信息(類型信息, 屬性信息等), 相當于讓一個對象更好的 "認清自己" .
Java 中使用反射比較麻煩一些. 我們后面會詳細介紹反射的具體用法.

為什么 String 要不可變?(不可變對象的好處是什么?) (選學(xué))

方便實現(xiàn)字符串對象池. 如果 String 可變, 那么對象池就需要考慮何時深拷貝字符串的問題了.
不可變對象是線程安全的.
不可變對象更方便緩存 hash code, 作為 key 時可以更高效的保存到 HashMap 中

綜上，我們對于下面這種代碼就知道它會產(chǎn)生大量的臨時對象，效率比較低，應(yīng)該被避免

String str = "hello" ;
for(int x = 0; x < 1000; x++) {
  str += x ;
}
System.out.println(str);

4 字符串操作

4.1 字符串比較

地址比較

對于內(nèi)置類型（數(shù)據(jù)類型）， == 比較的是變量中的值；
對于引用類型 == 比較的是引用中的地址

public static void main(String[] args) {
        String s1 = new String("hello");
        String s2 = new String("world");
        String s3 = s1;
        System.out.println(s1 == s2); //false
        System.out.println(s2 == s3); //false
        System.out.println(s1 == s3); //true
}

s1與s2對象的地址值是不一樣的，所以是false，在將s2的地址傳給s1，此時再次比較，輸出的就是true

內(nèi)容比較

equals

在String重寫了Object類的equals方法后，就大大簡化了我們的比較過程

equals (Object anObject) 方法：比較字符串內(nèi)容是否相等并返回，返回值為 boolean 類型
equalsIgnoreCase (String anotherString)方法：比較字符串內(nèi)容是否相等并返回，返回值為 boolean 類型，不考慮大小寫，如：'A’和’a’是相等

案例：

String str = new String("Hello World");
//注意：開發(fā)中作比較一般常量值在前，變量值在后
System.out.println("hello world".equals(str));//false
System.out.println("hello world".equalsIgnoreCase(str));//true

equals 注意事項

現(xiàn)在需要比較字符串 s 和 "hello" 兩個字符串是否相等, 我們該如何來寫呢?

// 方法1
System.out.println("hello".equals(s));

// 方法2
System.out.println(s.equals("hello"));

在上面的代碼中, 哪種方式更好呢?

我們更推薦使用 "方式1"，一旦 str 是 null, 方式2 的代碼會拋出異常, 而方式二不會

注意事項： "Hello" 這樣的字面值常量, 本質(zhì)上也是一個 String 對象, 完全可以使用 equals 等 String 對象的方法

compareTo

相比于上面 equals比較返回 true，compareTo 返回的是 int 類型

compareTo (String anotherString) 方法：比較調(diào)用對象和參數(shù)對象的大小關(guān)系，返回值為 int 類型
compareToIgnoreCase (String str)方法：比較調(diào)用對象和參數(shù)對象的大小關(guān)系，返回值為 int 類型，不考慮大小寫，也就是’a’和’A’是相等的關(guān)系

比較大小的方法：

例如 A.compareTo(B)，拿方法調(diào)用者(A)的字符依次與方法參數(shù)(B)的字符作比較，即用 A 的 ASCII碼減去 B 的ASCII碼；
結(jié)果有三種：負整數(shù)、正整數(shù)、零。負整數(shù)即按字典順序 A 在 B 之前，正整數(shù)即 A 在 B 之后，零則為字符串相等。

注意：比較出大小就不往后進行，即從第一個字符串開始比較，相同則比較下一個，直到比較出大小或比較到最后一個字符。

案例：

String str = "hello";
System.out.println(str.compareTo("world"));  // 'h' - 'w' => 104 - 119 => -15
System.out.println(str.compareTo("haha"));   // 'e' - 'a' => 101 - 97  => 4
System.out.println(str.compareTo("heihei")); // 'l' - 'i' => 108 - 105 => 3
System.out.println(str.compareTo("helloworld")); // 長度： 5 - 10 => -5
System.out.println(str.compareToIgnoreCase("HELLO")); // 0

4.2 字符串查找

方法名稱	作用
char charAt (int index)	返回index位置上字符，如果index為負數(shù)或者越界，拋出 IndexOutOfBoundsException 異常。
int indexOf (String str)	返回 str 第一次出現(xiàn)的位置，沒有返回 -1
int indexOf (String str, int fromIndex)	從 fromIndex 位置開始找 ch 第一次出現(xiàn)的位置，沒有返回 -1
int indexOf (String str)	返回 str 第一次出現(xiàn)的位置，沒有返回 -1
int indexOf (String str, int fromIndex)	從 fromIndex 位置開始找 str 第一次出現(xiàn)的位置，沒有返回 -1
int lastIndexOf (String str)	從后往前找，返回 str 第一次出現(xiàn)的位置，沒有返回 -1
Int lastIndexOf (String str, int fromIndex)	從 fromIndex 位置開始找，從后往前找 ch 第一次出現(xiàn)的位置，沒有返回-1
int lastIndexOf (String str)	從后往前找，返回 str 第一次出現(xiàn)的位置，沒有返回 -1
int lastIndexOf(String str, int fromIndex)	從 fromIndex 位置開始找，從后往前找 str 第一次出現(xiàn)的位置，沒有返回-1
boolean contains (CharSequence s)	判斷當前字符串是否包含參數(shù)指定的內(nèi)容，參數(shù) CharSequence 為一個接口，CharSequence 是 char 值的可讀序列，參數(shù)可以為String、StringBuilder、StringBuffer等類型
boolean startWith (String prefix)	判斷是否以指定字符串 prefix 開頭
boolean startWith (String prefix, int toffset)	從指定位置開始判斷是否以指定字符串 prefix 開頭
boolean endWith (String prefix)	判斷是否以指定字符串 prefix 結(jié)尾

案例：

String s = "aaabbbcccaaabbbccc";
System.out.println(s.charAt(3)); //'b'
System.out.println(s.indexOf('c')); //6
System.out.println(s.indexOf('c', 10)); //15
System.out.println(s.indexOf("bbb")); //3
System.out.println(s.indexOf("bbb", 10)); //12
System.out.println(s.lastIndexOf('c'));//17
System.out.println(s.lastIndexOf('c', 10)); //8
System.out.println(s.lastIndexOf("bbb"));//12
System.out.println(s.lastIndexOf("bbb",10));//5
System.out.println(s.contains("aa")); // true
System.out.println(s.startsWith("bb")); // false
System.out.println(s.startsWith("bb", 3)); // true
System.out.println(s.endsWith("cc")); // true

4.3 字符串替換

方法名稱	作用
String replace (char oldChar, char newChar)	使用參數(shù)newChar替換此字符串中出現(xiàn)的所有參數(shù)oldChar
String replace (char oldChar, char newChar)	用新字符串replacement替換所有的舊字符串target
String replaceAll (String regex, String replacement)	替換所有指定內(nèi)容
String replaceFirst (String regex, String replacement)	替換首個內(nèi)容

? 注意事項: 由于字符串是不可變對象, 替換不修改當前字符串, 而是產(chǎn)生一個新的字符串?。?/p>

4.4 字符串拆分

可以將一個完整的字符串按照指定的分隔符劃分為若干個子字符串

方法名稱	作用
String[] split (String regex)	將字符串全部拆分
String[] split (String regex, int limit)	將字符串以指定的格式，拆分為 limit 組

代碼示例: 實現(xiàn)字符串的拆分處理

String str = "hello world island" ;
String[] result = str.split(" ") ; // 按照空格拆分
for(String s: result)
{
    System.out.println(s);
}

// 結(jié)果如下：
hello
world
island

代碼示例: 字符串的部分拆分

String str = "hello world island" ;
String[] result = str.split(" ",2) ;
for(String s: result) {
    System.out.println(s);
}

// 結(jié)果如下：
hello
world island

注意：拆分是特別常用的操作. 一定要重點掌握. 另外有些特殊字符作為分割符可能無法正確切分, 需要加上轉(zhuǎn)義.

字符"|"、"*"、"+"、"." 都得加上轉(zhuǎn)義字符，前面加上 "\\"
而如果是 "\" ，那么就得寫成 "\\\\"
如果一個字符串中有多個分隔符，可以用"|"作為連字符

// ip 地址拆分
String str1 = "192.168.1.1" ;
String[] result1= str1.split("\\.") ;
for(String s: result1) {
    System.out.println(s);
}
// 多次拆分
String str2 = "name=island1314&age=18" ;
String[] result2 = str2.split("&") ;
for (int i = 0; i < result2.length; i++) {
    String[] temp = result2[i].split("=") ;
    System.out.println(temp[0]+" = "+temp[1]);
}

4.5 字符串截取

方法名稱	作用
String[] substring (int beginIndex)	從指定索引截取到結(jié)尾
String[] substring (int beginIndex, int endIndex)	截取部分內(nèi)容

String str = "helloworld" ;
System.out.println(str.substring(5));
System.out.println(str.substring(0, 5));

注意事項:

索引從0開始
注意前閉后開區(qū)間的寫法, substring(0, 5) 表示包含 0 號下標的字符, 不包含 5 號下標

4.6 字符串輸入遍歷

字符串輸入

在很多情況的時候，我們會發(fā)現(xiàn)字符串的輸入可以用 next() 或者 nextLine()，那么這兩個究竟有什么區(qū)別呢？？

next()方法

行為：
- 讀取輸入直到遇到空格、制表符或換行符 （默認分隔符），并返回分隔符前的部分。
- 自動跳過前導(dǎo)空格 （如開頭的空格或換行符）。
- 不會消費分隔符 （換行符會保留在輸入緩沖區(qū)中）。
適用場景 ：讀取單個單詞（以空格分隔的字符串）。
示例

Scanner in = new Scanner(System.in);
System.out.print("輸入內(nèi)容: ");
String s = in.next(); // 輸入 "Hello World"
System.out.println("結(jié)果: " + s); // 輸出 "Hello"

nextLine() 方法

行為：
- 消費換行符 （將其從緩沖區(qū)中移除）。
- 讀取輸入直到遇到換行符 （\n），并返回換行符前的所有內(nèi)容（包含空格 ）。
適用場景 ：讀取整行輸入（包括空格）
示例：

Scanner in = new Scanner(System.in);
System.out.print("輸入內(nèi)容: ");
String s = in.nextLine(); // 輸入 "Hello World"
System.out.println("結(jié)果: " + s); // 輸出 "Hello World"

關(guān)鍵區(qū)別

特性	next()	nextLine()
讀取范圍	到空格或換行符為止	到換行符為止（包含空格）
消費換行符	? 不消費	?? 消費
前導(dǎo)空格	自動跳過	保留（但會消費前導(dǎo)換行符）
典型用途	單詞、數(shù)字等簡單輸入	整行輸入（如帶空格的句子）

常見陷阱與解決方案

陷阱 1：混合使用 next() 和 nextLine()

Scanner in = new Scanner(System.in);
System.out.print("輸入數(shù)字: ");
int num = in.nextInt();      // 輸入 123 后按回車
System.out.print("輸入字符串: ");
String s = in.nextLine();    // 此時 s 會直接讀取到換行符，導(dǎo)致輸入被跳過

原因：nextInt() 不會消費換行符，殘留的換行符被 nextLine() 直接讀取，導(dǎo)致看似跳過輸入。
解決方案 ：在 nextInt() 后手動消費換行符：

int num = in.nextInt();
in.nextLine(); // 消費殘留的換行符
String s = in.nextLine();

陷阱 2：nextLine() 讀取到空字符串

Scanner in = new Scanner(System.in);
System.out.print("輸入內(nèi)容: ");
String s1 = in.nextLine(); // 輸入 "Hello"
String s2 = in.nextLine(); // 直接按回車
System.out.println("s2: " + s2); // 輸出空字符串

原因：nextLine() 會讀取換行符前的所有內(nèi)容，如果直接按回車，會返回空字符串。

總結(jié)

需要單個單詞 → 用 next()。
需要整行內(nèi)容（含空格） → 用 nextLine()。
混合使用時 → 注意換行符殘留問題，必要時手動清理緩沖區(qū)

字符串遍歷

在Java中，字符串不能像數(shù)組一樣直接通過下標訪問字符（如s[0]），而是需要使用charAt()方法或轉(zhuǎn)換為字符數(shù)組。

比如我們當前輸入一個字符串，需要遍歷字符串的每個字符，方法如下：

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String s = in.next();

        // 方法1：使用charAt()遍歷字符
        if (s.length() > 0) {
            // 首字符轉(zhuǎn)小寫
            System.out.print(Character.toLowerCase(s.charAt(0)));

            for (int i = 1; i < s.length(); i++) {
                char current = s.charAt(i);
                char prev = s.charAt(i - 1);

                // 如果前一個字符是空格且當前字符非空格，則轉(zhuǎn)小寫
                if (prev == ' ' && current != ' ') {
                    System.out.print(Character.toLowerCase(current));
                } else {
                    System.out.print(current);
                }
            }
        }

        // 方法2：轉(zhuǎn)換為字符數(shù)組遍歷（更簡潔）
         char[] chars = s.toCharArray();
         if (chars.length > 0) {
             chars[0] = Character.toLowerCase(chars[0]);
             for (int i = 1; i < chars.length; i++) {
                 if (chars[i-1] == ' ' && chars[i] != ' ') {
                     chars[i] = Character.toLowerCase(chars[i]);
                 }
             }
             System.out.println(new String(chars));
         }
    }
}

兩種遍歷方式對比：

charAt()：直接操作字符串，適合只讀場景。
字符數(shù)組：可修改字符，適合需要頻繁修改的場景

4.7 其他操作方法

方法名稱	作用
String trim ()	去掉字符串的左右空格，保留中間空格
String toUpperCase ()	字符串轉(zhuǎn)大寫
String toLowerCase ()	字符串轉(zhuǎn)小寫
native String intern ()	字符串入池操作
String concat (String str)	字符串連接，等同于 ”+“，不入池
int length ()	獲取字符串長度
boolean isEmpty ()	判斷是否為空字符串，注：不是 null ，而是長度為 0

這里我們就不做過多演示，大家可以自行實踐

5. StringBuffer 和 StringBuilder

首先來回顧下String類的特點：

任何的字符串常量都是String對象，而且String的常量一旦聲明不可改變，如果改變對象內(nèi)容，改變的是其引用的指向而已。

?? 通常來講String的操作比較簡單，但是由于String的不可更改特性，為了方便字符串的修改，提供StringBuffer和StringBuilder類。而StringBuffer和StringBuilder大部分功能是相同的，這里我們主要介紹 StringBuffer

?? StringBuffer類和String類一樣，也用來代表字符串，只是由于StringBuffer的內(nèi)部實現(xiàn)方式和String不同，StringBuffer在進行字符串處理時，不生成新的對象，所以在內(nèi)存使用上，StringBuffer類要優(yōu)于String類。

StringBuffer類中存在很多和String類一樣的方法，這些方法在功能上是完全一樣的。
StringBuffer類中也有一些獨特的方法，用于幫助我們更方便的實現(xiàn)某些特定的功能。

5.1 StringBuffer類的對象的初始化

// 方法1：
StringBuffer stringBuffer = new StringBuffer(); //初始化出的StringBuffer對象是一個空的對象

// 方法2：
StringBuffer stringBuffer = new StringBuffer("Hello World!"); //創(chuàng)建帶有內(nèi)容的StringBuffer對象

5.2 append 方法

在String中使用"+"來進行字符串連接，但是這個操作在StringBuffer類中需要更改為append()方法：

StringBuffer stringBuffer = new StringBuffer("Hello");
stringBuffer.append("World!");
System.out.println(stringBuffer);

// 執(zhí)行結(jié)果
HelloWorld!

5.3 reverse 方法

reverse()方法將把當前字符序列反轉(zhuǎn)后返回，請看示例：

StringBuffer stringBuffer = new StringBuffer("abc");
System.out.println(stringBuffer.reverse());

// 執(zhí)行結(jié)果：
cba

5.4 StringBuffer對象和String對象互轉(zhuǎn)

注意：StringBuffer和String屬于不同的類型，也不能直接進行強制類型轉(zhuǎn)換，案例如下：

// 錯誤
StringBuffer s = "abc";  //賦值類型不匹配
StringBuffer s = (StringBuffer)"abc";  //不存在繼承關(guān)系，無法進行強轉(zhuǎn)

// 正確
String string1 = "Hello World!";
StringBuffer stringBuffer = new StringBuffer(string1);  //String轉(zhuǎn)換為StringBuffer
String string2 = stringBuffer.toString();  //StringBuffer轉(zhuǎn)換為String

5.5 String, StringBuffer, StringBuilder區(qū)別

StringBuffer和String最大的區(qū)別在于：String的內(nèi)容無法修改，而StringBuffer和StringBuilder的內(nèi)容可以修改。頻繁修改字符串的情況考慮使用StingBuffer
StringBuffer與StringBuilder大部分功能是相似的
StringBuffer采用同步處理，屬于線程安全操作；而StringBuilder未采用同步處理，屬于線程不安全操作

6.小結(jié)

以上我們就把String 類的相關(guān)知識講完啦，我們了解了 String的基本性質(zhì)以及常量池的概念，而且對于 String 字符串的操作方法，大家要多去熟悉，后面可以多多實踐，在 StringBuffer和String 運用的時候，大家要記得兩者的區(qū)別以及特定場景下的使用。

到此這篇關(guān)于Java中String類詳解之字符串操作的文章就介紹到這了,更多相關(guān)Java String類字符串操作內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: