前言

本文介紹了字符串的存儲常量池及字符串常使用的方法，介紹了StringBuffer 和 StringBuilder，有什么地方寫的不好歡迎指正評論，謝謝！

1. 定義字符串

首先C語言是沒有String類型的，我們來看一下Java當(dāng)中String的構(gòu)造 String 的方式。

String定義：

// 方式一
String str = "Hello Bit";
// 方式二
String str2 = new String("Hello Bit");
// 方式三
char[] array = {'a', 'b', 'c'};  //把數(shù)組變成字符串
String str3 = new String(array);

結(jié)果：

我們可以去幫助文檔去深入了解一下Sting Java幫助手冊。

首先我們可以看見這個是在lang包底下：所以不需要導(dǎo)包

被final修飾不可以繼承（它繼承object類，所有的類都繼承object類）

所有的類要產(chǎn)生，就要有構(gòu)造方法我們來看一下：（不一定學(xué)這么多，我們挑重點(diǎn)來講）

以上就是定義的方式：我們以后都是直接賦值不要在使用new一個的方式。

我們來看一下 “方式三” 的一個底層實(shí)現(xiàn)圖：

char[] array = {'a', 'b', 'c'};  //把數(shù)組變成字符串
String str3 = new String(array);

我們?nèi)タ匆幌耂tring類里面有什么：（有很多字段方法）但是我們只看values[ ]

string類里面有個value

我們在來看一下String的方法：（可以看見這個value拷貝了一份會產(chǎn)生新的一個副本）

以上就是方式三在底層完成的一個操作.

2.字符串比較相等

下面代碼輸出的是true 還是 false？？

結(jié)果：

為什么呢？不是一樣的嗎？

• 因?yàn)閟tr1是引用類型存放的是地址
• st2也是引用類型存放的也是地址
• 所以不一樣（比較的是還是值一不一樣）但是值不是字符串值，而是引用值。

那么想比較字符串的內(nèi)容一不一樣怎么比較呢？
使用：equals

結(jié)果：

equals 使用注意事項

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

String str = new String("Hello");
// 方式一
System.out.println(str.equals("Hello"));
// 方式二
System.out.println("Hello".equals(str));

在上面的代碼中, 哪種方式更好呢?
我們更推薦使用 “方式二”. 一旦 str 是 null, 方式一的代碼會拋出異常, 而方式二不會

String str = null;
// 方式一
System.out.println(str.equals("Hello"));  // 執(zhí)行結(jié)果 拋出 java.lang.NullPointerException 異 常
// 方式二
System.out.println("Hello".equals(str));  // 執(zhí)行結(jié)果 false

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

3. 字符串常量池( 多圖解析 )

字符串常量池：存儲的就是字符串。

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

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

大概圖示：（ 在JVM 并沒有劃分區(qū)域說xxx區(qū)域就是字符串常量池 ）

Stringpool 其實(shí)底層就是一個哈希表（不深入可百度）

理解 “池” (pool)

“池” 是編程中的一種常見的, 重要的提升效率的方式, 我們會在未來的學(xué)習(xí)中遇到各種 “內(nèi)存池”, “線程池”, “數(shù)據(jù)
庫連接池” …
然而池這樣的概念不是計算機(jī)獨(dú)有, 也是來自于生活中. 舉個栗子:
現(xiàn)實(shí)生活中有一種女神, 稱為 “綠茶”, 在和高富帥談著對象的同時, 還可能和別的屌絲搞曖昧. 這時候這個屌絲被
稱為 “備胎”. 那么為啥要有備胎? 因?yàn)橐坏┖透吒粠浄质至? 就可以立刻找備胎接盤, 這樣 效率比較高.
如果這個女神, 同時在和很多個屌絲搞曖昧, 那么這些備胎就稱為 備胎池.

第一個列子解析：

還是來看一下下面的代碼在內(nèi)存中的存放操作：

如下圖：根據(jù)上面的字符串常量池的介紹，我們知道字符串引用起來的，會放在常量池里面：

那么str2的字符串內(nèi)容在哪里呢？？

-我們都知道字符串存放在常量池里面，但是現(xiàn)在str也是hello，那么new string會先去常量池里面找有沒有一樣的，有一樣的就引用常量池里面的，就不需要在放進(jìn)去新建一個：

最終str1是指向常量池里面的，str2是指向堆里面的，所以是false。

會發(fā)現(xiàn)其實(shí)常量池幫我們節(jié)省了空間，不需要同樣?xùn)|西存兩份，這個就是常量池的意義。

第二個列子解析：

看下面代碼思考是否相等?

結(jié)果：

解析：這2個在java當(dāng)中都是字符串常量，編譯器編譯的時候會自動被拼接，變成linbo

內(nèi)存圖：

不相信？我們來編譯一下看看：（第二個字符串已經(jīng)變成 linbo）

常量在編譯的時候已經(jīng)被運(yùn)算了。

變量：就是在編譯的時候 不知道里面的值，在運(yùn)行的時候 才知道里面的值

在來列子:被final修飾變成常量

結(jié)果

反編譯:已經(jīng)變成30

第三個列子解析：

思考下面代碼得到什么：？

結(jié)果：

解析:str3指向的其實(shí)是lin 和 bo的一個拼接，在堆中產(chǎn)生新的對象，所以是false；

第四個列子解析：

思考下面結(jié)果：

結(jié)果：

解析:可以看見str2（str2要拼接所以指向新對象）指向的是堆里面的對象，而str1是指向常量池的對象，所以是false

第五個列子解析：

思考下面的代碼：

結(jié)果：

解析：str2依然是指向拼接的新對象，而str1是指向常量池所以false；

第六個列子解析：

inter()：手動將字符串入池。

思考下面的代碼：

結(jié)果：

解析：inter方法就是拿到對象里面的值去哈希表里面找，如果已經(jīng)有了，就不放進(jìn)去了 ，所以是false；

第七個列子解析：

思考下面代碼：

結(jié)果:

解析:s3.inter 放進(jìn)了（放的是地址）常量池，然后s4的11 指向 s3的11 ，所以就是true

第八個列子解析：

思考下面代碼：

結(jié)果：

解析：s3變成11，但是在此之前s4的11是沒有的，所以放進(jìn)常量池，然后說s3.inter，看看常量池有沒有，常量池是有的，所以沒有放進(jìn)去所以s4是指向常量池的，s3是指向堆中的對象，所以不一樣。

以上就是所有的字符串內(nèi)容相不相等的練習(xí)，相信看完這些你會對字符串的比較有個全新的認(rèn)知。

字符串傳參注意事項：
不是傳引用就可以改變原來的值，看下面代碼：

結(jié)果：

解析：形參的改變并不影響實(shí)參，只是改變了指向

面試題：請解釋String類中兩種對象實(shí)例化的區(qū)別

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

綜上, 我們一般采取直接賦值的方式創(chuàng)建 String 對象

4. 理解字符串不可變

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

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

String str = "hello" ; 
str = str + " world" ; 
str += "!!!" ; 
System.out.println(str); 
// 執(zhí)行結(jié)果
hello world!!!

圖文解析:先hello 和world拼接 變成hello world ，然后在和?。?！拼接變成hell world，
產(chǎn)生了5個對象，為什么這樣呢？就是因?yàn)槟切┳址豢梢愿淖儯ú豢梢灾苯釉诤竺婕樱?/p>

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

a) 常見辦法: 借助原字符串, 創(chuàng)建新的字符串

String str = "Hello";
str = "h" + str.substring(1);
System.out.println(str);
// 執(zhí)行結(jié)果
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重要特性, 有些編程語言也稱為 “自省”.
指的是程序運(yùn)行過程中, 獲取/修改某個對象的詳細(xì)信息(類型信息, 屬性信息等), 相當(dāng)于讓一個對象更好的 “認(rèn)清自己” .

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

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

注意事項: 如下代碼不應(yīng)該在你的開發(fā)中出, 會產(chǎn)生大量的臨時對象, 效率比較低.

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

后面講stringbuffer 和 stringbuilder會講

5.字符, 字節(jié)與字符串

代碼：str： 第二個參數(shù)是偏移量，第三個參數(shù)是第幾個：

意思:從偏移量為1 ，取兩個 字符來構(gòu)造String對象 。所以是bc

a是0，b是1

 public static void main(String[] args) {        char[] value = {'a','b','c','d','e'};        String str = new String(value,1,2);        System.out.println(str);  //bc    }    

代碼：從1位置處取一個

結(jié)果：h是0 e是1；

代碼：將字符串已字符數(shù)組方式進(jìn)行存儲

結(jié)果:

代碼示例: 給定字符串一個字符串, 判斷其是否全部由數(shù)字所組成.

思路: 將字符串變?yōu)樽址麛?shù)組而后判斷每一位字符是否是" 0 “~”‘9'"之間的內(nèi)容，如果是則為數(shù)字.

public static void main(String[] args) { 
 String str = "1a23456" ; 
 System.out.println(isNumber(str)? "字符串由數(shù)字所組成！" : "字符串中有非數(shù)字成員！"); 

 } 
 public static boolean isNumber(String str) { 
 if(str==null)return false;
 if(str.lenth()==0)return false;
 char[] data = str.toCharArray() ; //轉(zhuǎn)變數(shù)組
 for (int i = 0; i < data.length; i++) { 
 if (data[i]<'0' || data[i]>'9') { 
 return false ; 
 } 
 } 
 return true ; 
 }

字節(jié)與字符串

代碼：把字節(jié)（ASCII），轉(zhuǎn)換為合適的字符輸出

結(jié)果：

代碼：String上面有橫線是干嘛的？？

點(diǎn)進(jìn)去看看： 有這個代表被棄用

代碼：把字符串變成字節(jié)數(shù)組 返回出來

結(jié)果：

代碼：

結(jié)果：

但是漢字有問題：

結(jié)果：

utf-8：

結(jié)果：

不經(jīng)常使用這個

小結(jié)

那么何時使用 byte[], 何時使用 char[] 呢?

byte[] 是把 String 按照一個字節(jié)一個字節(jié)的方式處理, 這種適合在網(wǎng)絡(luò)傳輸, 數(shù)據(jù)存儲這樣的場景下使用. 更適合針對二進(jìn)制數(shù)據(jù)來操作char[] 是吧 String 按照一個字符一個字符的方式處理, 更適合針對文本數(shù)據(jù)來操作, 尤其是包含中文的時候.

6. 字符串常見操作

6.1 字符串比較

代碼: 比較引用的對象是否相等

public static void main(String[] args) {
        String str = "hello";
        String str2 = new String("hello");
        System.out.println(str.equals(str2));  //結(jié)果true
    }

代碼：忽略大小寫的情況

public static void main(String[] args) {
        String str = "hello";
        String str2 = new String("Hello");
        System.out.println(str.equalsIgnoreCase(str2));  //結(jié)果 true
    }

代碼：比較大小返回數(shù)字 str>str2 正數(shù) ，str==str2 0 ，< 返回負(fù)數(shù)（比較的是ASCII碼）

public static void main(String[] args) {
        String str = "hello";
        String str2 = new String("Hello");
        System.out.println(str.compareTo(str2));  //返回 32 
    }

如果第一個一樣（從前往后比較），比較第二個字符，有一個字符大小不同，那么代表整個字符串大小

6.2 字符串查找

代碼：判斷字符串是否存在

public static void main(String[] args) {
        String str = "abcdefg";
       boolean flag = str.contains(str);
        System.out.println(flag); //true
    }

列子2：

public static void main(String[] args) {
        String str = "abcdefg";
       boolean flag = str.contains("cdef");
        System.out.println(flag); //true
    }

代碼：查找cdef 在 str里面有沒有 ，看第一個字符的位置（沒有返回-1）

 public static void main(String[] args) {
        String str = "abcdefg";
        System.out.println(str.indexOf("cdef")); // 返回下標(biāo)2  
    }

有點(diǎn)類似kmp算法

代碼：從指定位置找

public static void main(String[] args) {
        String str = "abcdefg";
        System.out.println(str.indexOf("bcdef",0)); // 1
    }

注意：位置的范圍

代碼：從后往前找

public static void main(String[] args) {
        String str = "abcdefg";
        System.out.println(str.lastIndexOf("bcdef")); // 1
    }

代碼：從指定的位置往前找

public static void main(String[] args) {
        String str = "abcdefbcdefg";
        System.out.println(str.lastIndexOf("bcdef",10)); // 6
    }

返回的是后面往前面的第一個bcdef

代碼：判斷是否以xx 開始的

 public static void main(String[] args) {
        String str = "abcdefbcdefg";
        System.out.println(str.startsWith("a")); // true
    }

 public static void main(String[] args) {
        String str = "abcdefbcdefg";
        System.out.println(str.startsWith("acdf")); // false
    }

代碼:從指定位置開始 從b開始判斷是不是a開頭

 public static void main(String[] args) {
        String str = "abcdefbcdefg";
        System.out.println(str.startsWith("a",1)); // false
    }

代碼：true

public static void main(String[] args) {
            String str = "abcdefbcdefg";
            System.out.println(str.endsWith("efg")); // true
        }

代碼：false

 public static void main(String[] args) {
            String str = "abcdefbcdefg";
            System.out.println(str.endsWith("efgc")); // false
        }

6.3 字符串替換

代碼：所以的a 變成z

public static void main(String[] args) {
            String str = "abcdefbcdaaa";
            System.out.println(str.replaceAll("a","z")); // zbcdefbcdzzz
        }

代碼：替換了第一個

public static void main(String[] args) {
            String str = "abcdefbcdaaa";
            System.out.println(str.replaceFirst("a","z")); // zbcdefbcdaaa

        }

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

6.4 字符串拆分

代碼：

public static void main(String[] args) {
        String str = "ab abc abcd";
       String[] strings = str.split(" "); //以空格分割
        for (String s:strings) {
            System.out.println(s);
        }
}

結(jié)果：
ab
abc
abcd

代碼二：

public static void main(String[] args) {
        String str = "ab abc abcd";
       String[] strings = str.split(" ",2); //以空格分割  最多分2組
        for (String s:strings) {
            System.out.println(s);
        }
    }

//結(jié)果
ab
abc abcd

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

代碼示例: 拆分IP地址

String str = "192.168.1.1" ; 
String[] result = str.split("\\.") ; 
for(String s: result) { 
 System.out.println(s); 
}

注意事項:

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

public static void main(String[] args) {
        String str = "ab#ab-cab cd";
       String[] strings = str.split("#|-| "); //以空格分割

        for (String s:strings) {
            System.out.println(s);
        }
    }

結(jié)果：

代碼示例: 多次拆分

public static void main(String[] args) {
        String str = "name=zhangsan&age=18" ;
        String[] result = str.split("&") ;
        for (int i = 0; i < result.length; i++) {
            String[] temp = result[i].split("=") ;
            System.out.println(temp[0]+" = "+temp[1]);
        }
    }
    

結(jié)果：

6.5 字符串截取

代碼：從2下標(biāo)開始截取

public static void main(String[] args) {
        String str = "hello";
        String ret = str.substring(2);
        System.out.println(ret);//llo
    }

public static void main(String[] args) {
        String str = "hellobit";
        String ret = str.substring(2,4);
        System.out.println(ret);//ll [2,4)表示包含 2 號下標(biāo)的字符, 不包含 4 號下標(biāo)
    }

注意事項:

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

6.6 其他操作方法

代碼：不使用的時候

public static void main(String[] args) {
        String str = "  a  hello";
        System.out.println(str);

    }

結(jié)果：

使用的情況：

public static void main(String[] args) {
        String str = "  a  hello";
        System.out.println(str.trim());

    }

結(jié)果：去掉了2邊的空格 但是不可以去中間的

代碼：小寫轉(zhuǎn)大寫

 public static void main(String[] args) {
        String str = "abcde";
        System.out.println(str.toUpperCase());//ABCDE

    }

代碼：

public static void main(String[] args) {
        String str = "ABCDE";
        System.out.println(str.toLowerCase()); //abcde


    }
//都是新對象

代碼：

public static void main(String[] args) {
        String str = "ABCDE";
        System.out.println(str.length()); //5
    }

lenth()!=arr.lenth

 public static void main(String[] args) {
        String str = "ABCDE";
        String str2 = "";

        System.out.println(str.isEmpty()); //false
        System.out.println(str2.isEmpty()); //true

    }

7. StringBuffer 和 StringBuilder

首先來回顧下String類的特點(diǎn)：

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

通常來講String的操作比較簡單，但是由于String的不可更改特性，為了方便字符串的修改，提供StringBuffer和StringBuilder類。

StringBuffer 和 StringBuilder 大部分功能是相同的，我們文章上主要介紹 StringBuffer
在String中使用"+"來進(jìn)行字符串連接，但是這個操作在StringBuffer類中需要更改為append()方法：

先來看一下StringBuffer和String的區(qū)別

• 賦值上的區(qū)別 StringBuffer不可以直接賦值
  

那么需要給它賦值怎么辦？
可以直接new一個給它

• 拼接上面的不同 StringBuffer沒有＋號 append 添加

結(jié)果：

• 除了append()方法外，StringBuffer也有一些String類沒有的方法

字符串反轉(zhuǎn)：

深入來看一下 這個代碼:

這個代碼我們說不要這樣使用：因?yàn)檫@樣會產(chǎn)生很多的一個對象，浪費(fèi)內(nèi)存

大家可以看見上面 每次都會new一次對象，這樣循環(huán)10次了。

我們可以改一下：

這樣就產(chǎn)生了一個new 循環(huán)里面沒有那么多new了 節(jié)約了內(nèi)存 達(dá)到了一樣的效果

有時候說 String是不可變的 StringBuffer是可變的 為什么呢？

因?yàn)镾tring拼接都是新對象

StringBuffer每次拼接返回的是當(dāng)前對象

而且StringBuffer 和 StringBuilder的區(qū)別就是 synchronized 關(guān)鍵字

StringBuffer ：

StringBuilder:

那么這個synchronized 關(guān)鍵字是干嘛的呢？？

其實(shí)簡單說就是保證線程安全的。

所以說 Stringbuffer適合多線程模式下，StringBuilder適合單線程模式下

注意：String和StringBuffer類不能直接轉(zhuǎn)換。如果要想互相轉(zhuǎn)換，可以采用如下原則:

String變?yōu)镾tringBuffer:利用StringBuffer的構(gòu)造方法或append()方法

StringBuffer變?yōu)镾tring:調(diào)用toString()方法

面試題：請解釋String、StringBuffer、StringBuilder的區(qū)別:

• String的內(nèi)容不可修改，StringBuffer與StringBuilder的內(nèi)容可以修改.
• StringBuffer與StringBuilder大部分功能是相似的
• StringBuffer采用同步處理，屬于線程安全操作；而StringBuilder未采用同步處理，屬于線程不安全操作

以上就是我們?nèi)績?nèi)容了，講的比較詳細(xì)，當(dāng)然有什么不對的地方可以指出來，一起進(jìn)步感謝觀看?。?！

到此這篇關(guān)于詳解Java Sring String的常見操作以及StringBuffer StringBuilder的區(qū)別的文章就介紹到這了,更多相關(guān)Java Sring String 常見操作內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

最新評論