本系列文章將整理到我在GitHub上的《Java面試指南》倉庫，更多精彩內(nèi)容請(qǐng)到我的倉庫里查看

https://github.com/h2pl/Java-Tutorial

喜歡的話麻煩點(diǎn)下Star哈

文章首發(fā)于我的個(gè)人博客：

www.how2playlife.com

本文是微信公眾號(hào)【Java技術(shù)江湖】的《夯實(shí)Java基礎(chǔ)系列博文》其中一篇种呐，本文部分內(nèi)容來源于網(wǎng)絡(luò)宰翅，為了把本文主題講得清晰透徹，也整合了很多我認(rèn)為不錯(cuò)的技術(shù)博客內(nèi)容陕贮，引用其中了一些比較好的博客文章，如有侵權(quán)潘飘，請(qǐng)聯(lián)系作者肮之。

該系列博文會(huì)告訴你如何從入門到進(jìn)階，一步步地學(xué)習(xí)Java基礎(chǔ)知識(shí)卜录，并上手進(jìn)行實(shí)戰(zhàn)戈擒，接著了解每個(gè)Java知識(shí)點(diǎn)背后的實(shí)現(xiàn)原理，更完整地了解整個(gè)Java技術(shù)體系艰毒，形成自己的知識(shí)框架筐高。為了更好地總結(jié)和檢驗(yàn)?zāi)愕膶W(xué)習(xí)成果，本系列文章也會(huì)提供部分知識(shí)點(diǎn)對(duì)應(yīng)的面試題以及參考答案。

如果對(duì)本系列文章有什么建議柑土，或者是有什么疑問的話蜀肘，也可以關(guān)注公眾號(hào)【Java技術(shù)江湖】聯(lián)系作者，歡迎你參與本系列博文的創(chuàng)作和修訂稽屏。

string基礎(chǔ)

Java String 類

字符串廣泛應(yīng)用 在 Java 編程中扮宠，在 Java 中字符串屬于對(duì)象，Java 提供了 String 類來創(chuàng)建和操作字符串狐榔。

創(chuàng)建字符串

創(chuàng)建字符串最簡(jiǎn)單的方式如下:

String greeting = "菜鳥教程";

在代碼中遇到字符串常量時(shí)坛增，這里的值是 "菜鳥教程""，編譯器會(huì)使用該值創(chuàng)建一個(gè) String 對(duì)象薄腻。

和其它對(duì)象一樣收捣，可以使用關(guān)鍵字和構(gòu)造方法來創(chuàng)建 String 對(duì)象。

String 類有 11 種構(gòu)造方法庵楷，這些方法提供不同的參數(shù)來初始化字符串罢艾，比如提供一個(gè)字符數(shù)組參數(shù):

StringDemo.java 文件代碼：

public class StringDemo{    public static void main(String args[]){       char[] helloArray = { 'r', 'u', 'n', 'o', 'o', 'b'};       String helloString = new String(helloArray);         System.out.println( helloString );    } }

以上實(shí)例編譯運(yùn)行結(jié)果如下：

runoob

注意:String 類是不可改變的，所以你一旦創(chuàng)建了 String 對(duì)象嫁乘，那它的值就無法改變了（詳看筆記部分解析）昆婿。

如果需要對(duì)字符串做很多修改，那么應(yīng)該選擇使用 StringBuffer & StringBuilder 類蜓斧。

String基本用法

創(chuàng)建String對(duì)象的常用方法

（1） String s1 = "mpptest"

(2) String s2 = new String();

(3) String s3 = new String("mpptest")

String中常用的方法仓蛆，用法如圖所示，具體問度娘

三個(gè)方法的使用： lenth() substring() charAt()

<pre>package com.mpp.string; public class StringDemo1 { public static void main(String[] args) { //定義一個(gè)字符串"晚來天欲雪 能飲一杯無"
String str = "晚來天欲雪 能飲一杯無";
System.out.println("字符串的長度是："+str.length()); //字符串的雪字打印輸出 charAt(int index)
System.out.println(str.charAt(4)); //取出子串 天欲
System.out.println(str.substring(2)); //取出從index2開始直到最后的子串挎春，包含2
System.out.println(str.substring(2,4)); //取出index從2到4的子串看疙，包含2不包含4 顧頭不顧尾
}
}</pre>

兩個(gè)方法的使用,求字符或子串第一次/最后一次在字符串中出現(xiàn)的位置： indexOf() lastIndexOf()

<pre>package com.mpp.string; public class StringDemo2 { public static void main(String[] args) {
String str = new String("趙客縵胡纓 吳鉤胡纓霜雪明"); //查找胡在字符串中第一次出現(xiàn)的位置
System.out.println(""胡"在字符串中第一次出現(xiàn)的位置："+str.indexOf("胡")); //查找子串"胡纓"在字符串中第一次出現(xiàn)的位置
System.out.println(""胡纓"在字符串中第一次出現(xiàn)的位置"+str.indexOf("胡纓")); //查找胡在字符串中最后一次次出現(xiàn)的位置
System.out.println(str.lastIndexOf("胡")); //查找子串"胡纓"在字符串中最后一次出現(xiàn)的位置
System.out.println(str.lastIndexOf("胡纓")); //從indexof為5的位置，找第一次出現(xiàn)的"吳"
System.out.println(str.indexOf("吳",5));
}
}</pre>

字符串與byte數(shù)組間的相互轉(zhuǎn)換

<pre>package com.mpp.string; import java.io.UnsupportedEncodingException; public class StringDemo3 { public static void main(String[] args) throws UnsupportedEncodingException { //字符串和byte數(shù)組之間的相互轉(zhuǎn)換
String str = new String("hhhabc銀鞍照白馬 颯沓如流星"); //將字符串轉(zhuǎn)換為byte數(shù)組直奋，并打印輸出
byte[] arrs = str.getBytes("GBK"); for(int i=0;i){
System.out.print(arrs[i]);
} //將byte數(shù)組轉(zhuǎn)換成字符串
System.out.println();
String str1 = new String(arrs,"GBK"); //保持字符集的一致能庆，否則會(huì)出現(xiàn)亂碼
System.out.println(str1);
}
}</pre>

==運(yùn)算符和equals之間的區(qū)別：

<pre>引用指向的內(nèi)容和引用指向的地址</pre>

<pre>package com.mpp.string; public class StringDemo5 { public static void main(String[] args) {
String str1 = "mpp";
String str2 = "mpp";
String str3 = new String("mpp");

    System.out.println(str1.equals(str2)); //true  內(nèi)容相同
    System.out.println(str1.equals(str3));   //true  內(nèi)容相同
    System.out.println(str1==str2);   //true   地址相同
    System.out.println(str1==str3);   //false  地址不同

}
}</pre>

字符串的不可變性

String的對(duì)象一旦被創(chuàng)建，則不能修改脚线，是不可變的

所謂的修改其實(shí)是創(chuàng)建了新的對(duì)象搁胆，所指向的內(nèi)存空間不變

上圖中，s1不再指向imooc所在的內(nèi)存空間邮绿，而是指向了hello,imooc

String的連接

@Test
public void contact () {
    //1連接方式
    String s1 = "a";
    String s2 = "a";
    String s3 = "a" + s2;
    String s4 = "a" + "a";
    String s5 = s1 + s2;
    //表達(dá)式只有常量時(shí)渠旁，編譯期完成計(jì)算
    //表達(dá)式有變量時(shí)，運(yùn)行期才計(jì)算船逮，所以地址不一樣
    System.out.println(s3 == s4); //f
    System.out.println(s3 == s5); //f
    System.out.println(s4 == "aa"); //t

}

String顾腊、String builder和String buffer的區(qū)別

String是Java中基礎(chǔ)且重要的類，并且String也是Immutable類的典型實(shí)現(xiàn)挖胃，被聲明為final class杂靶，除了hash這個(gè)屬性其它屬性都聲明為final,因?yàn)樗牟豢勺冃园鸸撸岳缙唇幼址畷r(shí)候會(huì)產(chǎn)生很多無用的中間對(duì)象，如果頻繁的進(jìn)行這樣的操作對(duì)性能有所影響吗垮。

StringBuffer就是為了解決大量拼接字符串時(shí)產(chǎn)生很多中間對(duì)象問題而提供的一個(gè)類垛吗，提供append和add方法，可以將字符串添加到已有序列的末尾或指定位置抱既，它的本質(zhì)是一個(gè)線程安全的可修改的字符序列职烧，把所有修改數(shù)據(jù)的方法都加上了synchronized。但是保證了線程安全是需要性能的代價(jià)的防泵。

在很多情況下我們的字符串拼接操作不需要線程安全蚀之，這時(shí)候StringBuilder登場(chǎng)了，StringBuilder是JDK1.5發(fā)布的捷泞，它和StringBuffer本質(zhì)上沒什么區(qū)別足删，就是去掉了保證線程安全的那部分，減少了開銷锁右。

StringBuffer 和 StringBuilder 二者都繼承了 AbstractStringBuilder 失受，底層都是利用可修改的char數(shù)組(JDK 9 以后是 byte數(shù)組)。

所以如果我們有大量的字符串拼接咏瑟，如果能預(yù)知大小的話最好在new StringBuffer 或者StringBuilder 的時(shí)候設(shè)置好capacity拂到，避免多次擴(kuò)容的開銷。擴(kuò)容要拋棄原有數(shù)組码泞，還要進(jìn)行數(shù)組拷貝創(chuàng)建新的數(shù)組兄旬。

我們平日開發(fā)通常情況下少量的字符串拼接其實(shí)沒太必要擔(dān)心，例如

String str = "aa"+"bb"+"cc";

像這種沒有變量的字符串余寥，編譯階段就直接合成"aabbcc"了领铐，然后看字符串常量池（下面會(huì)說到常量池）里有沒有，有也直接引用宋舷，沒有就在常量池中生成绪撵，返回引用。

如果是帶變量的祝蝠，其實(shí)影響也不大音诈，JVM會(huì)幫我們優(yōu)化了。

1绎狭、在字符串不經(jīng)常發(fā)生變化的業(yè)務(wù)場(chǎng)景優(yōu)先使用String(代碼更清晰簡(jiǎn)潔)细溅。如常量的聲明，少量的字符串操作(拼接坟岔，刪除等)谒兄。

2摔桦、在單線程情況下社付，如有大量的字符串操作情況承疲，應(yīng)該使用StringBuilder來操作字符串。不能使用String"+"來拼接而是使用鸥咖，避免產(chǎn)生大量無用的中間對(duì)象燕鸽，耗費(fèi)空間且執(zhí)行效率低下（新建對(duì)象、回收對(duì)象花費(fèi)大量時(shí)間）啼辣。如JSON的封裝等啊研。

3、在多線程情況下鸥拧，如有大量的字符串操作情況党远，應(yīng)該使用StringBuffer。如HTTP參數(shù)解析和封裝等富弦。

String類的源碼分析

String類型的intern

public void intern () {
    //2：string的intern使用
    //s1是基本類型沟娱，比較值。s2是string實(shí)例腕柜，比較實(shí)例地址
    //字符串類型用equals方法比較時(shí)只會(huì)比較值
    String s1 = "a";
    String s2 = new String("a");
    //調(diào)用intern時(shí),如果s2中的字符不在常量池济似，則加入常量池并返回常量的引用
    String s3 = s2.intern();
    System.out.println(s1 == s2);
    System.out.println(s1 == s3);
}

String類型的equals

//字符串的equals方法
//    public boolean equals(Object anObject) {
//            if (this == anObject) {
//                return true;
//            }
//            if (anObject instanceof String) {
//                String anotherString = (String)anObject;
//                int n = value.length;
//                if (n == anotherString.value.length) {
//                    char v1[] = value;
//                    char v2[] = anotherString.value;
//                    int i = 0;
//                    while (n-- != 0) {
//                        if (v1[i] != v2[i])
//                            return false;
//                        i++;
//                    }
//                    return true;
//                }
//            }
//            return false;
//        }

StringBuffer和Stringbuilder

底層是繼承父類的可變字符數(shù)組value

/**

- The value is used for character storage.
  */
  char[] value;
  初始化容量為16

/**

- Constructs a string builder with no characters in it and an
- initial capacity of 16 characters.
  */
  public StringBuilder() {
  super(16);
  }
  這兩個(gè)類的append方法都是來自父類AbstractStringBuilder的方法

public AbstractStringBuilder append(String str) {
    if (str == null)
        return appendNull();
    int len = str.length();
    ensureCapacityInternal(count + len);
    str.getChars(0, len, value, count);
    count += len;
    return this;
}
@Override
public StringBuilder append(String str) {
    super.append(str);
    return this;
}

@Override
public synchronized StringBuffer append(String str) {
    toStringCache = null;
    super.append(str);
    return this;
}

append方法

Stringbuffer在大部分涉及字符串修改的操作上加了synchronized關(guān)鍵字來保證線程安全，效率較低盏缤。

String類型在使用 + 運(yùn)算符例如

String a = "a"

a = a + a;時(shí)砰蠢，實(shí)際上先把a(bǔ)封裝成stringbuilder，調(diào)用append方法后再用tostring返回唉铜，所以當(dāng)大量使用字符串加法時(shí)台舱，會(huì)大量地生成stringbuilder實(shí)例，這是十分浪費(fèi)的打毛，這種時(shí)候應(yīng)該用stringbuilder來代替string柿赊。

擴(kuò)容

注意在append方法中調(diào)用到了一個(gè)函數(shù)

ensureCapacityInternal(count + len);
該方法是計(jì)算append之后的空間是否足夠，不足的話需要進(jìn)行擴(kuò)容

public void ensureCapacity(int minimumCapacity) {
    if (minimumCapacity > 0)
        ensureCapacityInternal(minimumCapacity);
}
private void ensureCapacityInternal(int minimumCapacity) {
    // overflow-conscious code
    if (minimumCapacity - value.length > 0) {
        value = Arrays.copyOf(value,
                newCapacity(minimumCapacity));
    }
}

如果新字符串長度大于value數(shù)組長度則進(jìn)行擴(kuò)容

擴(kuò)容后的長度一般為原來的兩倍 + 2幻枉；

假如擴(kuò)容后的長度超過了jvm支持的最大數(shù)組長度MAX_ARRAY_SIZE碰声。

考慮兩種情況

如果新的字符串長度超過int最大值，則拋出異常熬甫，否則直接使用數(shù)組最大長度作為新數(shù)組的長度胰挑。

private int hugeCapacity(int minCapacity) {
    if (Integer.MAX_VALUE - minCapacity < 0) { // overflow
        throw new OutOfMemoryError();
    }
    return (minCapacity > MAX_ARRAY_SIZE)
        ? minCapacity : MAX_ARRAY_SIZE;
}

刪除

這兩個(gè)類型的刪除操作：

都是調(diào)用父類的delete方法進(jìn)行刪除

public AbstractStringBuilder delete(int start, int end) {
    if (start < 0)
        throw new StringIndexOutOfBoundsException(start);
    if (end > count)
        end = count;
    if (start > end)
        throw new StringIndexOutOfBoundsException();
    int len = end - start;
    if (len > 0) {
        System.arraycopy(value, start+len, value, start, count-end);
        count -= len;
    }
    return this;
}

事實(shí)上是將剩余的字符重新拷貝到字符數(shù)組value。

這里用到了system.arraycopy來拷貝數(shù)組椿肩，速度是比較快的

system.arraycopy方法

轉(zhuǎn)自知乎：

在主流高性能的JVM上（HotSpot VM系瞻颂、IBM J9 VM系、JRockit系等等）郑象，可以認(rèn)為System.arraycopy()在拷貝數(shù)組時(shí)是可靠高效的——如果發(fā)現(xiàn)不夠高效的情況贡这，請(qǐng)報(bào)告performance bug，肯定很快就會(huì)得到改進(jìn)厂榛。

java.lang.System.arraycopy()方法在Java代碼里聲明為一個(gè)native方法盖矫。所以最na?ve的實(shí)現(xiàn)方式就是通過JNI調(diào)用JVM里的native代碼來實(shí)現(xiàn)丽惭。

String的不可變性
關(guān)于String的不可變性，這里轉(zhuǎn)一個(gè)不錯(cuò)的回答

什么是不可變辈双？
String不可變很簡(jiǎn)單责掏，如下圖，給一個(gè)已有字符串"abcd"第二次賦值成"abcedl"湃望，不是在原內(nèi)存地址上修改數(shù)據(jù)换衬，而是重新指向一個(gè)新對(duì)象，新地址证芭。

String和JVM的關(guān)系

下面我們了解下Java棧瞳浦、Java堆、方法區(qū)和常量池：

Java棧（線程私有數(shù)據(jù)區(qū)）：

    每個(gè)Java虛擬機(jī)線程都有自己的Java虛擬機(jī)棧废士，Java虛擬機(jī)棧用來存放棧幀术幔，每個(gè)方法被執(zhí)行的時(shí)候都會(huì)同時(shí)創(chuàng)建一個(gè)棧幀（Stack Frame）用于存儲(chǔ)局部變量表、操作棧湃密、動(dòng)態(tài)鏈接诅挑、方法出口等信息。每一個(gè)方法被調(diào)用直至執(zhí)行完成的過程泛源，就對(duì)應(yīng)著一個(gè)棧幀在虛擬機(jī)棧中從入棧到出棧的過程拔妥。

Java堆（線程共享數(shù)據(jù)區(qū)）：

   在虛擬機(jī)啟動(dòng)時(shí)創(chuàng)建，此內(nèi)存區(qū)域的唯一目的就是存放對(duì)象實(shí)例达箍，幾乎所有的對(duì)象實(shí)例都在這里分配没龙。

方法區(qū)（線程共享數(shù)據(jù)區(qū)）：

   方法區(qū)在虛擬機(jī)啟動(dòng)的時(shí)候被創(chuàng)建，它存儲(chǔ)了每一個(gè)類的結(jié)構(gòu)信息缎玫，例如運(yùn)行時(shí)常量池硬纤、字段和方法數(shù)據(jù)、構(gòu)造函數(shù)和普通方法的字節(jié)碼內(nèi)容赃磨、還包括在類筝家、實(shí)例、接口初始化時(shí)用到的特殊方法邻辉。在JDK8之前永久代是方法區(qū)的一種實(shí)現(xiàn)溪王，而JDK8元空間替代了永久代，永久代被移除值骇，也可以理解為元空間是方法區(qū)的一種實(shí)現(xiàn)莹菱。

常量池（線程共享數(shù)據(jù)區(qū)）：

    常量池常被分為兩大類：靜態(tài)常量池和運(yùn)行時(shí)常量池。

    靜態(tài)常量池也就是Class文件中的常量池吱瘩，存在于Class文件中道伟。

    運(yùn)行時(shí)常量池（Runtime Constant Pool）是方法區(qū)的一部分，存放一些運(yùn)行時(shí)常量數(shù)據(jù)使碾。

下面重點(diǎn)了解的是字符串常量池：

    字符串常量池存在運(yùn)行時(shí)常量池之中（在JDK7之前存在運(yùn)行時(shí)常量池之中蜜徽，在JDK7已經(jīng)將其轉(zhuǎn)移到堆中）裹芝。

    字符串常量池的存在使JVM提高了性能和減少了內(nèi)存開銷。

    使用字符串常量池娜汁，每當(dāng)我們使用字面量（String s=”1”;）創(chuàng)建字符串常量時(shí)，JVM會(huì)首先檢查字符串常量池兄朋，如果該字符串已經(jīng)存在常量池中掐禁，那么就將此字符串對(duì)象的地址賦值給引用s（引用s在Java棧中）。如果字符串不存在常量池中颅和，就會(huì)實(shí)例化該字符串并且將其放到常量池中傅事，并將此字符串對(duì)象的地址賦值給引用s（引用s在Java棧中）。

    使用字符串常量池峡扩，每當(dāng)我們使用關(guān)鍵字new（String s=new String(”1”);）創(chuàng)建字符串常量時(shí)蹭越，JVM會(huì)首先檢查字符串常量池，如果該字符串已經(jīng)存在常量池中教届，那么不再在字符串常量池創(chuàng)建該字符串對(duì)象响鹃，而直接堆中復(fù)制該對(duì)象的副本，然后將堆中對(duì)象的地址賦值給引用s案训，如果字符串不存在常量池中买置，就會(huì)實(shí)例化該字符串并且將其放到常量池中，然后在堆中復(fù)制該對(duì)象的副本强霎，然后將堆中對(duì)象的地址賦值給引用s忿项。

String為什么不可變？

翻開JDK源碼城舞，java.lang.String類起手前三行轩触，是這樣寫的：

public final class String implements java.io.Serializable, Comparable<String>, CharSequence {   
  /** String本質(zhì)是個(gè)char數(shù)組. 而且用final關(guān)鍵字修飾.*/     
private final char value[];  ...  ...
 } 

首先String類是用final關(guān)鍵字修飾，這說明String不可繼承家夺。再看下面脱柱，String類的主力成員字段value是個(gè)char[]數(shù)組，而且是用final修飾的拉馋。

final修飾的字段創(chuàng)建以后就不可改變褐捻。 有的人以為故事就這樣完了，其實(shí)沒有椅邓。因?yàn)殡m然value是不可變柠逞，也只是value這個(gè)引用地址不可變。擋不住Array數(shù)組是可變的事實(shí)景馁。

Array的數(shù)據(jù)結(jié)構(gòu)看下圖板壮。

也就是說Array變量只是stack上的一個(gè)引用，數(shù)組的本體結(jié)構(gòu)在heap堆合住。

String類里的value用final修飾绰精，只是說stack里的這個(gè)叫value的引用地址不可變撒璧。沒有說堆里array本身數(shù)據(jù)不可變”渴梗看下面這個(gè)例子卿樱，

final int[] value={1,2,3} ；
int[] another={4,5,6};
 value=another;    //編譯器報(bào)錯(cuò)硫椰，final不可變 value用final修飾繁调，編譯器不允許我把value指向堆區(qū)另一個(gè)地址。
但如果我直接對(duì)數(shù)組元素動(dòng)手靶草，分分鐘搞定蹄胰。

 final int[] value={1,2,3};
 value[2]=100;  //這時(shí)候數(shù)組里已經(jīng)是{1,2,100}   所以String是不可變，關(guān)鍵是因?yàn)镾UN公司的工程師奕翔。
 在后面所有String的方法里很小心的沒有去動(dòng)Array里的元素裕寨，沒有暴露內(nèi)部成員字段。private final char value[]這一句里派继，private的私有訪問權(quán)限的作用都比final大宾袜。而且設(shè)計(jì)師還很小心地把整個(gè)String設(shè)成final禁止繼承，避免被其他人繼承后破壞驾窟。所以String是不可變的關(guān)鍵都在底層的實(shí)現(xiàn)试和，而不是一個(gè)final∪移眨考驗(yàn)的是工程師構(gòu)造數(shù)據(jù)類型阅悍，封裝數(shù)據(jù)的功力。 

不可變有什么好處昨稼？

這個(gè)最簡(jiǎn)單地原因节视，就是為了安全〖偎ǎ看下面這個(gè)場(chǎng)景（有評(píng)論反應(yīng)例子不夠清楚寻行，現(xiàn)在完整地寫出來），一個(gè)函數(shù)appendStr( )在不可變的String參數(shù)后面加上一段“bbb”后返回匾荆。appendSb( )負(fù)責(zé)在可變的StringBuilder后面加“bbb”拌蜘。

總結(jié)以下String的不可變性。

1 首先final修飾的類只保證不能被繼承牙丽，并且該類的對(duì)象在堆內(nèi)存中的地址不會(huì)被改變简卧。

2 但是持有String對(duì)象的引用本身是可以改變的，比如他可以指向其他的對(duì)象烤芦。

3 final修飾的char數(shù)組保證了char數(shù)組的引用不可變举娩。但是可以通過char[0] = 'a’來修改值。不過String內(nèi)部并不提供方法來完成這一操作，所以String的不可變也是基于代碼封裝和訪問控制的铜涉。

舉個(gè)例子

final class Fi {
    int a;
    final int b = 0;
    Integer s;

}
final char[]a = {'a'};
final int[]b = {1};
@Test
public void final修飾類() {
    //引用沒有被final修飾智玻，所以是可變的。
    //final只修飾了Fi類型芙代，即Fi實(shí)例化的對(duì)象在堆中內(nèi)存地址是不可變的吊奢。
    //雖然內(nèi)存地址不可變，但是可以對(duì)內(nèi)部的數(shù)據(jù)做改變纹烹。
    Fi f = new Fi();
    f.a = 1;
    System.out.println(f);
    f.a = 2;
    System.out.println(f);
    //改變實(shí)例中的值并不改變內(nèi)存地址页滚。

Fi ff = f;
//讓引用指向新的Fi對(duì)象，原來的f對(duì)象由新的引用ff持有滔韵。
//引用的指向改變也不會(huì)改變?cè)瓉韺?duì)象的地址
f = new Fi();
System.out.println(f);
System.out.println(ff);

}

這里的對(duì)f.a的修改可以理解為char[0] = 'a'這樣的操作。只改變數(shù)據(jù)值掌实，不改變內(nèi)存值陪蜻。

String常用工具類

問題描述
很多時(shí)候我們需要對(duì)字符串進(jìn)行很多固定的操作,而這些操作在JDK/JRE中又沒有預(yù)置,于是我們想到了apache-commons組件,但是它也不能完全覆蓋我們的業(yè)務(wù)需求,所以很多時(shí)候還是要自己寫點(diǎn)代碼的,下面就是基于apache-commons組件寫的部分常用方法:

MAVEN依賴
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>${commons-lang3.version}</version>
 </dependency>

代碼成果

public class StringUtils extends org.apache.commons.lang3.StringUtils {

/** 值為"NULL"的字符串 */
private static final String NULL_STRING = "NULL";

private static final char SEPARATOR = '_';


/**
 * 滿足一下情況返回true<br/>
 * ①.入?yún)榭? * ②.入?yún)榭兆址? * ③.入?yún)?null"字符串
 *
 * @param string 需要判斷的字符型
 * @return boolean
 */
public static boolean isNullOrEmptyOrNULLString(String string) {
    return isBlank(string) || NULL_STRING.equalsIgnoreCase(string);
}

/**
 * 把字符串轉(zhuǎn)為二進(jìn)制碼<br/>
 * 本方法不會(huì)返回null
 *
 * @param str 需要轉(zhuǎn)換的字符串
 * @return 二進(jìn)制字節(jié)碼數(shù)組
 */
public static byte[] toBytes(String str) {
    return isBlank(str) ? new byte[]{} : str.getBytes();
}

/**
 * 把字符串轉(zhuǎn)為二進(jìn)制碼<br/>
 * 本方法不會(huì)返回null
 *
 * @param str     需要轉(zhuǎn)換的字符串
 * @param charset 編碼類型
 * @return 二進(jìn)制字節(jié)碼數(shù)組
 * @throws UnsupportedEncodingException 字符串轉(zhuǎn)換的時(shí)候編碼不支持時(shí)出現(xiàn)
 */
public static byte[] toBytes(String str, Charset charset) throws UnsupportedEncodingException {
    return isBlank(str) ? new byte[]{} : str.getBytes(charset.displayName());
}

/**
 * 把字符串轉(zhuǎn)為二進(jìn)制碼<br/>
 * 本方法不會(huì)返回null
 *
 * @param str     需要轉(zhuǎn)換的字符串
 * @param charset 編碼類型
 * @param locale  編碼類型對(duì)應(yīng)的地區(qū)
 * @return 二進(jìn)制字節(jié)碼數(shù)組
 * @throws UnsupportedEncodingException 字符串轉(zhuǎn)換的時(shí)候編碼不支持時(shí)出現(xiàn)
 */
public static byte[] toBytes(String str, Charset charset, Locale locale) throws UnsupportedEncodingException {
    return isBlank(str) ? new byte[]{} : str.getBytes(charset.displayName(locale));
}

/**
 * 二進(jìn)制碼轉(zhuǎn)字符串<br/>
 * 本方法不會(huì)返回null
 *
 * @param bytes 二進(jìn)制碼
 * @return 字符串
 */
public static String bytesToString(byte[] bytes) {
    return bytes == null || bytes.length == 0 ? EMPTY : new String(bytes);
}

/**
 * 二進(jìn)制碼轉(zhuǎn)字符串<br/>
 * 本方法不會(huì)返回null
 *
 * @param bytes   二進(jìn)制碼
 * @param charset 編碼集
 * @return 字符串
 * @throws UnsupportedEncodingException 當(dāng)前二進(jìn)制碼可能不支持傳入的編碼
 */
public static String byteToString(byte[] bytes, Charset charset) throws UnsupportedEncodingException {
    return bytes == null || bytes.length == 0 ? EMPTY : new String(bytes, charset.displayName());
}

/**
 * 二進(jìn)制碼轉(zhuǎn)字符串<br/>
 * 本方法不會(huì)返回null
 *
 * @param bytes   二進(jìn)制碼
 * @param charset 編碼集
 * @param locale  本地化
 * @return 字符串
 * @throws UnsupportedEncodingException 當(dāng)前二進(jìn)制碼可能不支持傳入的編碼
 */
public static String byteToString(byte[] bytes, Charset charset, Locale locale) throws UnsupportedEncodingException {
    return bytes == null || bytes.length == 0 ? EMPTY : new String(bytes, charset.displayName(locale));
}

/**
 * 把對(duì)象轉(zhuǎn)為字符串
 *
 * @param object 需要轉(zhuǎn)化的字符串
 * @return 字符串, 可能為空
 */
public static String parseString(Object object) {
    if (object == null) {
        return null;
    }
    if (object instanceof byte[]) {
        return bytesToString((byte[]) object);
    }
    return object.toString();
}

/**
 * 把字符串轉(zhuǎn)為int類型
 *
 * @param str 需要轉(zhuǎn)化的字符串
 * @return int
 * @throws NumberFormatException 字符串格式不正確時(shí)拋出
 */
public static int parseInt(String str) throws NumberFormatException {
    return isBlank(str) ? 0 : Integer.parseInt(str);
}

/**
 * 把字符串轉(zhuǎn)為double類型
 *
 * @param str 需要轉(zhuǎn)化的字符串
 * @return double
 * @throws NumberFormatException 字符串格式不正確時(shí)拋出
 */
public static double parseDouble(String str) throws NumberFormatException {
    return isBlank(str) ? 0D : Double.parseDouble(str);
}

/**
 * 把字符串轉(zhuǎn)為long類型
 *
 * @param str 需要轉(zhuǎn)化的字符串
 * @return long
 * @throws NumberFormatException 字符串格式不正確時(shí)拋出
 */
public static long parseLong(String str) throws NumberFormatException {
    return isBlank(str) ? 0L : Long.parseLong(str);
}

/**
 * 把字符串轉(zhuǎn)為float類型
 *
 * @param str 需要轉(zhuǎn)化的字符串
 * @return float
 * @throws NumberFormatException 字符串格式不正確時(shí)拋出
 */
public static float parseFloat(String str) throws NumberFormatException {
    return isBlank(str) ? 0L : Float.parseFloat(str);
}

/**
 * 獲取i18n字符串
 *
 * @param code
 * @param args
 * @return
 */
public static String getI18NMessage(String code, Object[] args) {
    //LocaleResolver localLocaleResolver = (LocaleResolver) SpringContextHolder.getBean(LocaleResolver.class);
    //HttpServletRequest request = ((ServletRequestAttributes)RequestContextHolder.getRequestAttributes()).getRequest();
    //Locale locale = localLocaleResolver.resolveLocale(request);
    //return SpringContextHolder.getApplicationContext().getMessage(code, args, locale);
    return "";
}

/**
 * 獲得用戶遠(yuǎn)程地址
 *
 * @param request 請(qǐng)求頭
 * @return 用戶ip
 */
public static String getRemoteAddr(HttpServletRequest request) {
    String remoteAddr = request.getHeader("X-Real-IP");
    if (isNotBlank(remoteAddr)) {
        remoteAddr = request.getHeader("X-Forwarded-For");
    } else if (isNotBlank(remoteAddr)) {
        remoteAddr = request.getHeader("Proxy-Client-IP");
    } else if (isNotBlank(remoteAddr)) {
        remoteAddr = request.getHeader("WL-Proxy-Client-IP");
    }
    return remoteAddr != null ? remoteAddr : request.getRemoteAddr();
}

/**
 * 駝峰命名法工具
 *
 * @return toCamelCase(" hello_world ") == "helloWorld"
 * toCapitalizeCamelCase("hello_world") == "HelloWorld"
 * toUnderScoreCase("helloWorld") = "hello_world"
 */
public static String toCamelCase(String s, Locale locale, char split) {
    if (isBlank(s)) {
        return "";
    }

    s = s.toLowerCase(locale);

    StringBuilder sb = new StringBuilder();
    for (char c : s.toCharArray()) {
        sb.append(c == split ? Character.toUpperCase(c) : c);
    }

    return sb.toString();
}

public static String toCamelCase(String s) {
    return toCamelCase(s, Locale.getDefault(), SEPARATOR);
}

public static String toCamelCase(String s, Locale locale) {
    return toCamelCase(s, locale, SEPARATOR);
}

public static String toCamelCase(String s, char split) {
    return toCamelCase(s, Locale.getDefault(), split);
}

public static String toUnderScoreCase(String s, char split) {
    if (isBlank(s)) {
        return "";
    }

    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < s.length(); i++) {
        char c = s.charAt(i);
        boolean nextUpperCase = (i < (s.length() - 1)) && Character.isUpperCase(s.charAt(i + 1));
        boolean upperCase = (i > 0) && Character.isUpperCase(c);
        sb.append((!upperCase || !nextUpperCase) ? split : "").append(Character.toLowerCase(c));
    }

    return sb.toString();
}

public static String toUnderScoreCase(String s) {
    return toUnderScoreCase(s, SEPARATOR);
}

/**
 * 把字符串轉(zhuǎn)換為JS獲取對(duì)象值的三目運(yùn)算表達(dá)式
 *
 * @param objectString 對(duì)象串
 *                     例如：入?yún)?row.user.id/返回：!row?'':!row.user?'':!row.user.id?'':row.user.id
 */
public static String toJsGetValueExpression(String objectString) {
    StringBuilder result = new StringBuilder();
    StringBuilder val = new StringBuilder();
    String[] fileds = split(objectString, ".");
    for (int i = 0; i < fileds.length; i++) {
        val.append("." + fileds[i]);
        result.append("!" + (val.substring(1)) + "?'':");
    }
    result.append(val.substring(1));
    return result.toString();
}


}

參考文章

https://blog.csdn.net/qq_34490018/article/details/82110578

https://www.runoob.com/java/java-string.html

https://www.cnblogs.com/zhangyinhua/p/7689974.html

https://blog.csdn.net/sinat_21925975/article/details/86493248

https://www.cnblogs.com/niew/p/9597379.html

微信公眾號(hào)

個(gè)人公眾號(hào)：黃小斜

黃小斜是跨考軟件工程的 985 碩士，自學(xué) Java 兩年贱鼻，拿到了 BAT 等近十家大廠 offer宴卖，從技術(shù)小白成長為阿里工程師。

作者專注于 JAVA 后端技術(shù)棧邻悬，熱衷于分享程序員干貨症昏、學(xué)習(xí)經(jīng)驗(yàn)、求職心得和程序人生父丰，目前黃小斜的CSDN博客有百萬+訪問量肝谭，知乎粉絲2W+，全網(wǎng)已有10W+讀者蛾扇。

黃小斜是一個(gè)斜杠青年攘烛，堅(jiān)持學(xué)習(xí)和寫作，相信終身學(xué)習(xí)的力量镀首，希望和更多的程序員交朋友坟漱，一起進(jìn)步和成長！

原創(chuàng)電子書:
關(guān)注微信公眾號(hào)【黃小斜】后回復(fù)【原創(chuàng)電子書】即可領(lǐng)取我原創(chuàng)的電子書《菜鳥程序員修煉手冊(cè)：從技術(shù)小白到阿里巴巴Java工程師》這份電子書總結(jié)了我2年的Java學(xué)習(xí)之路更哄，包括學(xué)習(xí)方法芋齿、技術(shù)總結(jié)、求職經(jīng)驗(yàn)和面試技巧等內(nèi)容成翩，已經(jīng)幫助很多的程序員拿到了心儀的offer觅捆！

程序員3T技術(shù)學(xué)習(xí)資源： 一些程序員學(xué)習(xí)技術(shù)的資源大禮包，關(guān)注公眾號(hào)后麻敌，后臺(tái)回復(fù)關(guān)鍵字 “資料” 即可免費(fèi)無套路獲取惠拭，包括Java、python、C++职辅、大數(shù)據(jù)棒呛、機(jī)器學(xué)習(xí)、前端域携、移動(dòng)端等方向的技術(shù)資料簇秒。

技術(shù)公眾號(hào)：Java技術(shù)江湖

如果大家想要實(shí)時(shí)關(guān)注我更新的文章以及分享的干貨的話，可以關(guān)注我的微信公眾號(hào)【Java技術(shù)江湖】

這是一位阿里 Java 工程師的技術(shù)小站秀鞭。作者黃小斜趋观，專注 Java 相關(guān)技術(shù)：SSM、SpringBoot锋边、MySQL皱坛、分布式、中間件豆巨、集群剩辟、Linux、網(wǎng)絡(luò)往扔、多線程贩猎，偶爾講點(diǎn)Docker、ELK萍膛，同時(shí)也分享技術(shù)干貨和學(xué)習(xí)經(jīng)驗(yàn)吭服，致力于Java全棧開發(fā)！

（關(guān)注公眾號(hào)后回復(fù)”Java“即可領(lǐng)取 Java基礎(chǔ)蝗罗、進(jìn)階艇棕、項(xiàng)目和架構(gòu)師等免費(fèi)學(xué)習(xí)資料，更有數(shù)據(jù)庫串塑、分布式欠肾、微服務(wù)等熱門技術(shù)學(xué)習(xí)視頻，內(nèi)容豐富拟赊，兼顧原理和實(shí)踐刺桃，另外也將贈(zèng)送作者原創(chuàng)的Java學(xué)習(xí)指南、Java程序員面試指南等干貨資源）

Java工程師必備學(xué)習(xí)資源: 一些Java工程師常用學(xué)習(xí)資源吸祟，關(guān)注公眾號(hào)后瑟慈，后臺(tái)回復(fù)關(guān)鍵字 “Java” 即可免費(fèi)無套路獲取。

我的公眾號(hào)

?