今天帶大家了解一下java的基礎(chǔ)法語(yǔ)---String

字符串是我們以后工作中非常常用到的類(lèi)型. 使用起來(lái)都非常簡(jiǎn)單方便, 我們一定要使用熟練。

那么C語(yǔ)言中是否有字符串類(lèi)型？ 答案是 “ 沒(méi)有 ” ?。?/p>

char *p = " hello";

那么p 的類(lèi)型是一個(gè)字符串類(lèi)型么？ 不是，p是一個(gè)指針！！

而在 Java當(dāng)中 是有 字符串類(lèi)型的——String

一、定義方式

創(chuàng)建字符串的方式有很多種，常見(jiàn)的構(gòu)造 String 的方式如以下：

方式一：直接賦值法

String str1 = "hello";

方式二： new String()

String str2 = new String("hello");

方式三：創(chuàng)建一個(gè)字符數(shù)組ch，new String ( ch )

char chs[] = {'h','e','l','l','l','o'};
String str3 = new String(chs);

二、內(nèi)存

在此之前我們要先引入一個(gè)概念 字符串常量池

Sting constant pool 字符串常量池 的特性

1.在JDK.7 開(kāi)始，字符串常量池 被挪到堆里了

2.池內(nèi)的數(shù)據(jù)不存在重復(fù)

下面我們通過(guò)一系列的練習(xí)來(lái)熟悉 字符串常量池以及 字符串類(lèi)型數(shù)據(jù)在內(nèi)存中的存放。

public static void main(String[] args) {
       String str1 = "hello";
       String str2 = new String("hello");
        System.out.println(str1 == str2);
        String str3 = "hello";
        System.out.println(str1 == str3);
    }

我們來(lái)看這樣的代碼，str 代表的是引用\地址，請(qǐng)判斷 兩次打印分別是什么？

我們來(lái)看結(jié)果

這個(gè)結(jié)果說(shuō)明 str1 和 str2存放的地址是不一樣的， str1 和 str3 存放的地址是一樣的。

好的，為什么是這樣的結(jié)果呢？我們來(lái)看一下這幾個(gè)字符串類(lèi)型變量的內(nèi)存。

"hello"如果存放在常量池當(dāng)中，就會(huì)占用內(nèi)存，假如這塊空間的地址為111，那么str1中存放的就是111.

str2 new一個(gè)String對(duì)象，那么肯定在堆上開(kāi)辟內(nèi)存，假設(shè)內(nèi)存地址是888，在這個(gè)String 對(duì)象中，存在一個(gè)value[] 保存著 orginal傳入的字符串，這個(gè)val ==“hello”,因?yàn)樵谧址Ａ砍刂幸呀?jīng)有了"hello",所以val 直接指向 常量池中的"hello".但是str2 指向的依然是 888在堆中的空間。

所以 str1 不等于 str2。

之后呢,str3 也等于"hello",他也準(zhǔn)備把hello放在常量池當(dāng)中.此時(shí)常量池中已經(jīng)存在"hello",那么之后str3 在存放"hello"地址的時(shí)候，就指向的是常量池中原來(lái)hello的地址。

所以 str1 等于 str3

再看一組練習(xí)

    public static void main(String[] args) {
        String str1 = "hello";
        String str2 = "hel"+"lo";
        System.out.println(str1==str2);
        String str3 = new String("hel")+"lo";
        System.out.println(str1==str3);
    }

請(qǐng)判斷兩次打印的結(jié)果…

結(jié)果如下：

下面我們來(lái)分析，這組代碼中str變量的內(nèi)存存放

str1 指向字符串常量池中的 “hello”

str2 是"hel"與"lo" 組合而成的，常量在編譯的時(shí)候就已經(jīng)確定了,所以在編譯時(shí)，已經(jīng)被處理為"hello",所以也指向 常量池中的"hello"。

所以 str1 等于 str2

str3 首先new 了一個(gè)String(“hel”)對(duì)象，在堆中開(kāi)辟一塊空間，這個(gè)對(duì)象中的"hel"同時(shí)存放在常量池中，之后又在常量池中開(kāi)辟一塊空間存放 “lo”。兩塊部分之間的"+",將 String 的對(duì)象 與常量池中的 "lo"結(jié)合在堆中再次開(kāi)辟一塊新的空間，這塊內(nèi)存中的val ==“hello”，str3指向的是合并之后的對(duì)象 ，地址為999.

所以 str1 不等于 str3.

再看一組練習(xí)

 public static void func(String str,char[] array){
        str = "abcdef";
        array[0] = 'g';
    }
    public static void main(String[] args) {
        String str1 = "hello";
        char[] val = {'a'};
        System.out.println(str1);
        System.out.println(Arrays.toString(val));
        func(str1,val);
        System.out.println("=================");
        System.out.println(str1);
        System.out.println(Arrays.toString(val));
    }

請(qǐng)看一下，我們將String str 作為參數(shù)，改變str 的內(nèi)容，以及傳入 數(shù)組 val 改變 數(shù)組元素，其打印結(jié)果是什么？

我們看到 String str 的內(nèi)容并未改變，但是數(shù)組 val 的元素卻改變了。

我們從內(nèi)存的角度來(lái)分析。

str1 指向字符串常量區(qū)的"hello"，地址為888

val 作為數(shù)組引用，指向堆中開(kāi)辟的數(shù)組空間，地址為777

str 作為函數(shù)的形參，接收str1實(shí)參的值，也就是888，此時(shí)str指向常量區(qū)的”hello“,但是在方法的內(nèi)部，str = “abcde”,在字符串常量區(qū)中有開(kāi)辟一塊"abcde"的內(nèi)存，地址為000，最后 str 存放的地址為000.

array 作為函數(shù)的形參，接收val 實(shí)參的值，也就是777，此時(shí)array 指向堆中 開(kāi)辟的數(shù)組空間，此時(shí)通過(guò)array 來(lái)改變數(shù)組元素的內(nèi)容，最終 改變的也同樣是val 實(shí)參的內(nèi)容.

三、字符串比較相等

如果現(xiàn)在有兩個(gè)int型變量，判斷其相等可以使用 == 完成。

str1 = "world";
System.out.println(str2);
// 執(zhí)行結(jié)果
//Hello
int x = 10 ;
int y = 10 ;
System.out.println(x == y); 
// 執(zhí)行結(jié)果
//true

如果說(shuō)現(xiàn)在在String類(lèi)對(duì)象上使用 == ？

代碼1

String str1 = "Hello";
String str2 = "Hello"; 
System.out.println(str1 == str2); 
// 執(zhí)行結(jié)果
//true 

看起來(lái)貌似沒(méi)啥問(wèn)題, 再換個(gè)代碼試試, 發(fā)現(xiàn)情況不太妙.

代碼2

String str1 = new String("Hello");
String str2 = new String("Hello");
System.out.println(str1 == str2);
// 執(zhí)行結(jié)果
//false

在上面的幾個(gè)練習(xí)中，我們 用 str1 == str2 比較的是兩個(gè)字符串的引用/地址，如果比較字符串里面的內(nèi)容，我們需要用到 equals 方法。

 public static void main(String[] args) {
        String str1 = "hello";
        String str2 = new String("hello");
        
        System.out.println(str1==str2);          //比較的是引用
        System.out.println(str1.equals(str2));   //比較 str1 和 str2 字符串的內(nèi)容
        
        String str3 = "hello";
        System.out.println(str1.equals(str3));   //比較 str1 和 str3 字符串的內(nèi)容
    }

最后的打印結(jié)果

打印的結(jié)果符合字符串的內(nèi)容比較。

常用的比較方式：

我們?cè)賮?lái)看一種情況，

 public static void main(String[] args) {
        String str1 = null;
        String str2 = "hello";
        System.out.println(str1.equals(str2));
    }

這時(shí)候運(yùn)行程序，就會(huì)出現(xiàn)以下情況：

空指針異常，因?yàn)?null. 任何方法都會(huì)出現(xiàn)異常。

所以一定要保證 str1 不能為null。

那么如果我們改一下，

public static void main(String[] args) {
        String str1 = null;
        String str2 = "hello";
        System.out.println(str2.equals(str1));
    }

所以我們知道 equals（），括號(hào)里可以是null,但是 點(diǎn)之前一定不能是 null.

public static void main(String[] args) {
        String str1 = "hello";
        System.out.println(str1.equals("hello"));  // 方式1
        System.out.println("hello".equals(str1));  // 方式2
    }

當(dāng)我們寫(xiě)代碼遇到以上的情況時(shí)，我們應(yīng)該盡量選方式2，這樣保證 equals之前一定不為null，以防出現(xiàn)異常.

四、字符串常量池

在上面的例子中, String類(lèi)的兩種實(shí)例化操作, 直接賦值和 new 一個(gè)新的 String.

（1） 直接賦值

System.out.println("Hello".equals(str));  // 執(zhí)行結(jié)果 false
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

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

在JVM底層實(shí)際上會(huì)自動(dòng)維護(hù)一個(gè)對(duì)象池（字符串常量池)

如果現(xiàn)在采用了直接賦值的模式進(jìn)行String類(lèi)的對(duì)象實(shí)例化操作，那么該實(shí)例化對(duì)象（字符串內(nèi)容）將自動(dòng)保存到這個(gè)對(duì)象池之中.

如果下次繼續(xù)使用直接賦值的模式聲明String類(lèi)對(duì)象，此時(shí)對(duì)象池之中如若有指定內(nèi)容，將直接進(jìn)行引用

如若沒(méi)有，則開(kāi)辟新的字符串對(duì)象而后將其保存在對(duì)象池之中以供下次使用

理解 “池” (pool)

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

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

類(lèi)對(duì)象使用構(gòu)造方法實(shí)例化是標(biāo)準(zhǔn)做法。分析如下程序：

String str = new String("hello");

這樣的做法有兩個(gè)缺點(diǎn):

1.  如果使用String構(gòu)造方法就會(huì)開(kāi)辟兩塊堆內(nèi)存空間，并且其中一塊堆內(nèi)存將成為垃圾空間(字符串常量 “hello” 也是一個(gè)匿名對(duì)象, 用了一次之后就不再使用了, 就成為垃圾空間, 會(huì)被 JVM 自動(dòng)回收掉).

2.  字符串共享問(wèn)題. 同一個(gè)字符串可能會(huì)被存儲(chǔ)多次, 比較浪費(fèi)空間.

（3）intern 的使用

String str1 = "hello";
String str2 = new String("hello").intren();

從上面的由 構(gòu)造方法定義字符串，我們會(huì)浪費(fèi)內(nèi)存空間，而這里有一個(gè)方法 ，叫做intern(),手動(dòng)入池。

那這是什么意思呢？

這是先看一下傳入構(gòu)造方法的字符串在字符串常量池中是否存在，如果有的話(huà)，就把常量池中的引用傳給當(dāng)前的引用類(lèi)型變量。

綜上所述，我們一般使用 直接賦值法來(lái) 創(chuàng)建 String 對(duì)象。

我們?cè)賮?lái)看這樣一組代碼，來(lái)畫(huà)一下他的內(nèi)存結(jié)構(gòu)

在第一步的代碼中，new 了兩個(gè)字符串"1"，在堆中創(chuàng)建了兩個(gè)對(duì)象，指向常量池中的"1",拼接在一起，s3.interb(),s3手動(dòng)入池，“11"在池中沒(méi)有，所以就把 堆中的"11"的引用 555 傳入常量池中。s4 指向池中的"11”,而這時(shí)池中已經(jīng)有了"11"的引用，所以s4 指向的就是 s3在入池的引用。

所以結(jié)果為 true。

所以呢，我們解決了一個(gè)疑問(wèn)

在常量池當(dāng)中，可以放 字符串的字面值常量，也可以放引用。什么時(shí)候放引用，就是類(lèi)似于上面的那種情況之下，s3.intern(),s3所指向的這個(gè)對(duì)象在字符串常量池中是不存在的,那么入池的時(shí)候就把堆中s3的引用放入。

五、理解字符串不可變

字符串是一種不可變對(duì)象. 它的內(nèi)容不可改變.這是什么意思呢？

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

對(duì)于這種代碼，乍一看我們以為成功的將str 每次與其他的字符串拼接，但是這樣是不可以的， str 原來(lái)指向的是"hello",但是 在與" world"拼接之后，又會(huì)產(chǎn)生一個(gè)新的對(duì)象"helll world",再次拼接一個(gè)"!!!",那么又會(huì)產(chǎn)生一個(gè)新的對(duì)象"hello world!!!",在內(nèi)存中就會(huì)產(chǎn)生多個(gè)對(duì)象。

我們最后需要的是"hello world!!!",但是卻開(kāi)辟了5塊內(nèi)存空間。

如果在一個(gè)循環(huán)中拼接，那么會(huì)開(kāi)辟更多的內(nèi)存空間！！

所以這樣的代碼是極為不可取的！??！

那么如何拼接呢，具體在之后的StringBuff、StringBuilder中介紹。

六、字符、字節(jié)、字符串

（1）字符與字符串

字符串內(nèi)部包含一個(gè)字符數(shù)組，String 可以和 char[] 相互轉(zhuǎn)換

1.字符數(shù)組轉(zhuǎn)字符串

    public static void main(String[] args) {
        char[] val = {'h','e','l','l','o'};
        String str = new String(val);
        System.out.println(val);
    }

此時(shí)我們 的 str 結(jié)果就是 “hello”,同時(shí)他也可以再給兩個(gè)參數(shù).

2.將部分字符數(shù)組中的內(nèi)容轉(zhuǎn)換為字符串

offset–偏移量

count-- 轉(zhuǎn)換幾個(gè)

 public static void main(String[] args) {
        char[] val = {'h','e','l','l','o'};
        String str = new String(val,1,2);
        System.out.println(str);
    }

此時(shí)我們將val 中偏移1個(gè)，轉(zhuǎn)換之后的兩個(gè)數(shù)組元素為字符串

打印結(jié)果應(yīng)該為 el

運(yùn)行結(jié)果如下：

3.將字符串中對(duì)應(yīng)索引轉(zhuǎn)換為字符

public static void main(String[] args) {
        String str = "hello";
        char ch = str.charAt(1);
        System.out.println(ch);
    }

索引從0開(kāi)始，我們輸入1，所以轉(zhuǎn)換的為字符串中的e

運(yùn)行結(jié)果如下：

4.將字符串轉(zhuǎn)換為字符數(shù)組

public static void main(String[] args) {
        String str = "hello";
        char[] val = str.toCharArray();
        System.out.println(Arrays.toString(val));
    }

我們用字符數(shù)組接收 str轉(zhuǎn)換后的字符。

運(yùn)行結(jié)果如下：

好了，了解了這幾種字符與字符串的方法，我們通過(guò)幾個(gè)練習(xí)來(lái)繼續(xù)熟悉。

練習(xí)一

給定字符串一個(gè)字符串, 判斷其是否全部由數(shù)字所組成.

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

  public static boolean func1(String str){
        for (int i = 0; i <str.length() ; i++) {
            if(str.charAt(i)>'9' || str.charAt(i)<'0'){
                return false;
            }
        }
        return true;
    }

（2）字節(jié)與字符串

字節(jié)常用于數(shù)據(jù)傳輸以及編碼轉(zhuǎn)換的處理之中，String 也能方便的和 byte[] 相互轉(zhuǎn)換

常用方法:

1.字節(jié)數(shù)組轉(zhuǎn)換為字符串

 public static void main(String[] args) {
        byte[] bytes = {97,98,99,100};
        String str = new String(bytes);
        System.out.println(str);
    }

運(yùn)行結(jié)果： 字符串中的內(nèi)容是字節(jié)數(shù)組與Ascii 碼表中對(duì)應(yīng)的字符。

2.部分字節(jié)數(shù)組的內(nèi)容轉(zhuǎn)換為字符串

public static void main(String[] args) {
        byte[] bytes = {97,98,99,100};
        String str = new String(bytes,2,1);
        System.out.println(str);
    }

運(yùn)行結(jié)果：

3.字符串轉(zhuǎn)換為字節(jié)數(shù)組

   public static void main(String[] args) {
        String str = "abcd";
        byte[] bytes = str.getBytes();
        System.out.println(Arrays.toString(bytes));
    }

運(yùn)行結(jié)果：

（3） 小結(jié)

那么何時(shí)使用 byte[], 何時(shí)使用 char[] 呢?

byte[] 是把 String 按照一個(gè)字節(jié)一個(gè)字節(jié)的方式處理, 這種適合在網(wǎng)絡(luò)傳輸, 數(shù)據(jù)存儲(chǔ)這樣的場(chǎng)景下使用. 更適合針對(duì)二進(jìn)制數(shù)據(jù)來(lái)操作.

char[] 是吧 String 按照一個(gè)字符一個(gè)字符的方式處理, 更適合針對(duì)文本數(shù)據(jù)來(lái)操作, 尤其是包含中文的時(shí)候.

七、字符串的常見(jiàn)操作

（1）字符串比較

上面使用過(guò)String類(lèi)提供的equals()方法，該方法本身是可以進(jìn)行區(qū)分大小寫(xiě)的相等判斷。除了這個(gè)方法之外，String類(lèi)還提供有如下的比較操作.

1.區(qū)分大小寫(xiě)比較

   public static void main(String[] args) {
        String str1 = "abcd";
        String str2 = "Abcd";
        System.out.println(str1.equals(str2));
    }

運(yùn)行結(jié)果：

我們常

用的equals 方法 是區(qū)分大小寫(xiě)的，這點(diǎn)要注意。

2.不區(qū)分大小寫(xiě)的比較

 public static void main(String[] args) {
        String str1 = "abcd";
        String str2 = "Abcd";
        System.out.println(str1.equalsIgnoreCase(str2));
    }

運(yùn)行結(jié)果：

這種不區(qū)分大小寫(xiě)的比較還是很常見(jiàn)的，比如應(yīng)用于驗(yàn)證碼上，不區(qū)分大小寫(xiě)。

3.比較兩個(gè)字符串的大小關(guān)系

public static void main(String[] args) {
        String str1 = "abcd";
        String str2 = "Abcd";
        System.out.println(str1.compareTo(str2));
    }

運(yùn)行時(shí)結(jié)果

掌握了字符串比較相等的方法，下來(lái)我們來(lái)做一道練習(xí)題

比較字符串是否相等

題解思路：

將word1 字符串?dāng)?shù)組的內(nèi)容都在str1 追加，word2 字符串?dāng)?shù)組的內(nèi)容在str2 追加，最終equals 比較str1 str2 字符串的內(nèi)容，相等返回 true,不等返回 false.

注意：參數(shù)等問(wèn)題要考慮全面

（2）字符串查找

從一個(gè)完整的字符串之中可以判斷指定內(nèi)容是否存在，對(duì)于查找方法有如下定義：

判斷一個(gè)字符串中是否存在子字符串

我們可以先看一下 contains 方法的源碼

contains 方法的使用

public static void main(String[] args) {
       String str = "bcdabc";
       boolean flg = str.contains("abc");
        System.out.println(flg);
    }

運(yùn)行結(jié)果：

所以可判斷在"badabc" 這個(gè)字符串中存在 這個(gè) “abc” 的子字符串。

找到子字符串的下標(biāo)

我們先來(lái)看一下一個(gè)參數(shù)的 index 方法的源碼

帶一個(gè)參數(shù)的 index 方法的使用

 public static void main(String[] args) {
        String str = "ababcabcdabcde";
        int index1 = str.indexOf("abc");
        int index2 = str.indexOf("hello");
        System.out.println(index1);
        System.out.println("============");
        System.out.println(index2);
    }

運(yùn)行結(jié)果：

兩個(gè)參數(shù)的index 方法的使用

在下面我們又看到了一個(gè)index 方法，這說(shuō)明 默認(rèn)情況下，index 是從0下標(biāo)開(kāi)始查找的，如果再給他一個(gè)下標(biāo)參數(shù)，那么就從指定的下標(biāo)位置進(jìn)行字符串查找。

使用:

public static void main(String[] args) {
        String str = "abcabcdabcdef";
        int index1 = str.indexOf("abc");
        int index2 = str.indexOf("abc",6);
        System.out.println(index1);
        System.out.println("=================");
        System.out.println(index2);
    }

運(yùn)行結(jié)果：

從后往前查找到子字符串的位置

lastIndexOf 是從后向前查找 子字符串的位置

lastIndexOf 方法的使用

public static void main(String[] args) {
        String str = "abcabcdabcdef";
        int index = str.lastIndexOf("abc");
        System.out.println(index);
    }

運(yùn)行結(jié)果：

同時(shí) lastIndexOf 也有兩個(gè)參數(shù)的方法，從指定下標(biāo)開(kāi)始從后向前進(jìn)行查找。

判斷是否由 參數(shù)字符串開(kāi)頭的

同時(shí)也有兩個(gè)參數(shù)的方法，從指定位置判斷是否由 指定字符串開(kāi)頭

判斷是否由指定字符串進(jìn)行結(jié)尾的

（3）字符串替換

（1）替換所有的指定內(nèi)容

replaceAll 的使用

public static void main(String[] args) {
        String str = "abcabcacbabc";
        System.out.println(str);
        System.out.println("=================");
        String ret = str.replaceAll("ab","AB");
        System.out.println(ret);
    }

運(yùn)行結(jié)果：

成功的把所有的 “ab” 替換成為 “AB”.

（2）替換首個(gè)要替換的內(nèi)容.

replaceFirst 的使用

 public static void main(String[] args) {
        String str = "abcabcacbabc";
        System.out.println(str);
        System.out.println("=================");
        String ret = str.replaceFirst("ab","AB");
        System.out.println(ret);
    }

運(yùn)行結(jié)果：

注意說(shuō)明：

由于字符串是不可變對(duì)象, 替換不修改當(dāng)前字符串, 而是產(chǎn)生一個(gè)新的字符串.

（4）字符串拆分

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

1.將字符串全部拆分

接收的類(lèi)型是字符串?dāng)?shù)組類(lèi)型，傳參數(shù)時(shí)，傳一個(gè)我們想要分割的符號(hào)。

split 的使用

  public static void main(String[] args) {
        String str = "rain7 is cool";
        String[] strs = str.split(" ");
        for (String s:strs) {
            System.out.println(s);
        }
    }

我們?cè)谟?split 方法時(shí)， 以 空格 為分割符，將我們的str 字符串 進(jìn)行拆分

我們來(lái)看拆分的效果

2.帶兩個(gè)參數(shù)的split 方法

還是以上面的字符串為例

  public static void main(String[] args) {
        String str = "rain7 is cool";
        String[] strs = str.split(" ",2);
        for (String s:strs) {
            System.out.println(s);
        }
    }

運(yùn)行結(jié)果：

我們除了將字符串作為參數(shù)，還將limit 設(shè)置為2，那么拆分后的數(shù)組長(zhǎng)度就為2，所以運(yùn)行結(jié)果就如上所示。

難點(diǎn)：

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

示例1

拆分 IP 地址

比如說(shuō)我們要分割I(lǐng)P 地址，192.168.1.1，以 “.” 分割。

當(dāng)我們運(yùn)行時(shí)會(huì)發(fā)現(xiàn) 打印為空，這是為什么呢？

有些符號(hào)比較特殊，必須用到轉(zhuǎn)義字符

“ \. ”才能表示一個(gè)真正的 “.” 
同時(shí)"\"也需要進(jìn)行轉(zhuǎn)義，那么就又要再加一個(gè)斜杠。
“\\.”這時(shí)字符串才只能被 “ . ”分割。
1

public static void main(String[] args) {
        String str = "192.168.1.1";
        String[] strs = str.split("\\.");
        for (String s:strs) {
            System.out.println(s);
        }
    }

運(yùn)行結(jié)果：

1. 字符"|","*","+"都得加上轉(zhuǎn)義字符，前面加上"\\".

2. 而如果是"\"，那么就得寫(xiě)成"\\".

3. 如果一個(gè)字符串中有多個(gè)分隔符，可以用"|"作為連字符.

連字符 “ | ” 的使用

public static void main(String[] args) {
        String str = "1212@qq.com";
        String[] ret = str.split("@|\\.");
        for (String s:ret) {
            System.out.println(s);
        }
    }

運(yùn)行結(jié)果：

我們來(lái)一道練習(xí)題：

代碼題解：

public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while(scanner.hasNext()){
            String ret ="";
            String str = scanner.nextLine();
            String[] strs = str.split(" ");
            for (String s:strs) {
                ret += s;
            }
            System.out.println(ret);
        }
    }

運(yùn)行結(jié)果：

注意：

1.注意多組輸入 2.不建議在for循環(huán)中拼接字符串，在之后講到的StringBuilder StringBuffer 之后可以知道如何拼接。

（5）字符串截取

從一個(gè)完整的字符串之中截取出部分內(nèi)容。可用方法如下：

1.從指定下標(biāo)截取到字符串結(jié)束

方法的使用

public static void main(String[] args) {
        String str = "ilikeBeijing";
        String ret = str.substring(4);
        System.out.println(ret);
    }

運(yùn)行結(jié)果：

2.帶有兩個(gè)參數(shù)的subString 方法，截取指定下標(biāo)范圍內(nèi)的字符串內(nèi)容

方法的使用

  public static String reverse(String s){
        if(s==null){
            return null;
        }
        int begun = 0;
        int end = s.length()-1;
        char[] chars = s.toCharArray();
        while(begun<end){
            char tmp = chars[begun] ;
            chars [begun] = chars [end];
            chars[end] = tmp;
            begun++;
            end--;
        }
        return new String(chars);
    }
    public static void main(String[] args) {
        String str = "Hello World!";
        String ret = reverse(str);
        System.out.println(ret);
    }

運(yùn)行結(jié)果

 注

意：

1.指定下標(biāo)范圍 是 左閉右開(kāi)的區(qū)間

2.截取后的字符串是一個(gè)新的對(duì)象

（6）其他操作方法

字符串操作還有很多其他的方法，在這里我們只進(jìn)行簡(jiǎn)單介紹。

（7）字符串操作練習(xí)題

1.逆置字符串

題目要求

將字符串進(jìn)行整體逆置

代碼題解：

public static String reverse(String s){
        if(s==null){
            return null;
        }
        int begun = 0;
        int end = s.length()-1;
        char[] chars = s.toCharArray();
        while(begun<end){
            char tmp = chars[begun] ;
            chars [begun] = chars [end];
            chars[end] = tmp;
            begun++;
            end--;
        }
        return new String(chars);
    }
    public static void main(String[] args) {
        String str = "Hello World!";
        String ret = reverse(str);
        System.out.println(ret);
    }

運(yùn)行結(jié)果：

成功的將字符串進(jìn)行逆置

2.翻轉(zhuǎn)字符串

我們首先對(duì)題目進(jìn)行一下解讀，我們要實(shí)現(xiàn)一個(gè)方法，給這個(gè)方法傳入 一個(gè)字符串和一個(gè) 整數(shù) size 。將大小為 size 的左半?yún)^(qū) 翻轉(zhuǎn)到 右半?yún)^(qū)。如圖所示：

思路實(shí)現(xiàn)：

1.首先將size 左半?yún)^(qū)進(jìn)行單獨(dú)逆置。

2.再將 size的右半?yún)^(qū)單獨(dú)逆置。

3.整體字符串進(jìn)行逆置。

代碼展示：

public static String reverse(String s,int begun,int end){
        if(s==null){
            return null;
        }
        char[] chars = s.toCharArray();
        while(begun<end){
            char tmp = chars[begun] ;
            chars [begun] = chars [end];
            chars[end] = tmp;
            begun++;
            end--;
        }
        return new String(chars);
    }
    public static String reversSentence(String str,int k){
        str = reverse(str,0,k-1);
        str = reverse(str,k,str.length()-1);
        str = reverse(str,0,str.length()-1);
        return str;
    }
    public static void main(String[] args) {
       Scanner scanner = new Scanner(System.in);
       String str = scanner.next();
       int n = scanner.nextInt();
       String ret = reversSentence(str,n);
        System.out.println(ret);
    }

運(yùn)行結(jié)果：

八、StringBuffer 和 StringBuilder

StringBuffer 和 StringBuilder 又是一種新的字符串類(lèi)型。

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

StringBuffer 和 StringBuilder 在功能上大部分是相同的，在這里我們著重介紹 StringBuffer.

（1）append 方法

public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
        sb.append("a");
        sb.append("b");
        sb.append("c");
        System.out.println(sb);
    }

在String中使用"+"來(lái)進(jìn)行字符串連接，但是這個(gè)操作在StringBuffer類(lèi)中需要更改為append()方法。

String和StringBuffer最大的區(qū)別在于：String的內(nèi)容無(wú)法修改，而StringBuffer的內(nèi)容可以修改。頻繁修改字符串的情況考慮使用 StingBuffer。

運(yùn)行結(jié)果：

我們來(lái)看一下 StringBuffer 的 append 方法的源碼

  最后返回的是 this，在字符串本身拼接字符串。同時(shí)StringBuffer 有自己重寫(xiě)的 toString 方法，可以直接進(jìn)行打印。

我們來(lái)看一下 以下的代碼：

  public static void main(String[] args) {
       String str1 = "abc";
       String str2 = "def";
       String str3 = str1+str2;
       System.out.println(str3);
    }

我們對(duì)以上代碼進(jìn)行編譯一下：

在編譯的過(guò)程中，我們發(fā)現(xiàn)StringBuilder.append 方法的出現(xiàn)；

我們將這個(gè)過(guò)程用 StringBuilder 寫(xiě)一下：

   public static void main(String[] args) {
        String str1 ="abc";
        String str2 = "def";
        StringBuilder sb = new StringBuilder();
        sb.append(str1);
        sb.append(str2);
        String str3 = sb.toString();
        System.out.println(str3);
    }

說(shuō)明：

String 的“+” 拼接，會(huì)被底層優(yōu)化為一個(gè) StringBuilder ，拼接的時(shí)候會(huì)用到 append 方法

（2）注意

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

String變?yōu)镾tringBuffer:利用StringBuffer的構(gòu)造方法或append()方法   StringBuffer變?yōu)镾tring:調(diào)用toString()方法。

除了append()方法外，StringBuffer也有一些String類(lèi)沒(méi)有的方法:

字符串反轉(zhuǎn)：

public synchronized StringBuffer reverse();

（3）區(qū)別

String 和 StringBuilder 及 StringBuffer 的區(qū)別

String 進(jìn)行拼接時(shí)，底層會(huì)被優(yōu)化為StringBuilder

String的拼接會(huì)產(chǎn)生臨時(shí)對(duì)象，但是后兩者每次都只是返回當(dāng)前對(duì)象的引用。

String的內(nèi)容不可修改，StringBuffer與StringBuilder的內(nèi)容可以修改.

StringBuilder 和 StringBuffer 的區(qū)別

我們來(lái)看一下這兩個(gè)類(lèi)的 append 方法

所以 StringBuffer 和 StringBuilder 的區(qū)別主要體現(xiàn)在線(xiàn)程安全上 。

1.StringBuffer與StringBuilder大部分功能是相似的

2.StringBuffer采用同步處理，屬于線(xiàn)程安全操作；而StringBuilder未采用同步處理，屬于線(xiàn)程不安全操作

九.總結(jié)

字符串操作是我們以后工作中非常常用的操作. 使用起來(lái)都非常簡(jiǎn)單方便, 我們一定要使用熟練.

好了今天的知識(shí)就分享到這里，希望大家多多關(guān)注腳本之家的其他內(nèi)容！