本系列文章將整理到我在GitHub上的《Java面試指南》倉庫，更多精彩內容請到我的倉庫裡檢視
> https://github.com/h2pl/Java-Tutorial

喜歡的話麻煩點下Star哈

文章首發於我的個人部落格：
> www.how2playlife.com

本文是微信公眾號【Java技術江湖】的《夯實Java基礎系列博文》其中一篇，本文部分內容來源於網路，為了把本文主題講得清晰透徹，也整合了很多我認為不錯的技術部落格內容，引用其中了一些比較好的部落格文章，如有侵權，請聯絡作者。

該系列博文會告訴你如何從入門到進階，一步步地學習Java基礎知識，並上手進行實戰，接著瞭解每個Java知識點背後的實現原理，更完整地瞭解整個Java技術體系，形成自己的知識框架。為了更好地總結和檢驗你的學習成果，本系列文章也會提供部分知識點對應的面試題以及參考答案。

如果對本系列文章有什麼建議，或者是有什麼疑問的話，也可以關注公眾號【Java技術江湖】聯絡作者，歡迎你參與本系列博文的創作和修訂。

## string基礎

### Java String 類

字串廣泛應用 在 Java 程式設計中，在 Java 中字串屬於物件，Java 提供了 String 類來建立和操作字串。

### 建立字串

建立字串最簡單的方式如下:

String greeting = "菜鳥教程";

在程式碼中遇到字串常量時，這裡的值是 "**菜鳥教程**""，編譯器會使用該值建立一個 String 物件。

和其它物件一樣，可以使用關鍵字和構造方法來建立 String 物件。

String 類有 11 種構造方法，這些方法提供不同的引數來初始化字串，比如提供一個字元陣列引數:

### 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 );    } }

以上例項編譯執行結果如下：

```
runoob
```

**注意:**String 類是不可改變的，所以你一旦建立了 String 物件，那它的值就無法改變了（詳看筆記部分解析）。

如果需要對字串做很多修改，那麼應該選擇使用 [StringBuffer & StringBuilder 類](https://www.runoob.com/java/java-stringbuffer.html)。

## String基本用法

###  建立String物件的常用方法

（1） String s1 = "mpptest"

(2)  String s2 = new String();

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

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

![](https://img2018.cnblogs.com/blog/710412/201902/710412-20190213220237169-1966705420.png)

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

<pre>package com.mpp.string; public class StringDemo1 { public static void main(String[] args) { //定義一個字串"晚來天欲雪 能飲一杯無"
 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>

兩個方法的使用,求字元或子串第一次/最後一次在字串中出現的位置： indexOf()   lastIndexOf()

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

### 字串與byte陣列間的相互轉換

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

### ==運算子和equals之間的區別：

<pre>引用指向的內容和引用指向的地址</pre>

![](https://img2018.cnblogs.com/blog/710412/201902/710412-20190214223341972-1204335921.png)

<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 內容相同
 System.out.println(str1.equals(str3)); //true 內容相同
 System.out.println(str1==str2); //true 地址相同
 System.out.println(str1==str3); //false 地址不同
 }
}</pre>

### 字串的不可變性

String的物件一旦被建立，則不能修改，是不可變的

所謂的修改其實是建立了新的物件，所指向的記憶體空間不變

![](https://img2018.cnblogs.com/blog/710412/201902/710412-20190214224055939-746946317.png)

上圖中，s1不再指向imooc所在的記憶體空間，而是指向了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;
        //表示式只有常量時，編譯期完成計算
        //表示式有變數時，執行期才計算，所以地址不一樣
        System.out.println(s3 == s4); //f
        System.out.println(s3 == s5); //f
        System.out.println(s4 == "aa"); //t
    
    }
### String、String builder和String buffer的區別
String是Java中基礎且重要的類，並且String也是Immutable類的典型實現，被宣告為final class，除了hash這個屬性其它屬性都宣告為final,因為它的不可變性，所以例如拼接字串時候會產生很多無用的中間物件，如果頻繁的進行這樣的操作對效能有所影響。

StringBuffer就是為了解決大量拼接字串時產生很多中間物件問題而提供的一個類，提供append和add方法，可以將字串新增到已有序列的末尾或指定位置，它的本質是一個執行緒安全的可修改的字元序列，把所有修改資料的方法都加上了synchronized。但是保證了執行緒安全是需要效能的代價的。

在很多情況下我們的字串拼接操作不需要執行緒安全，這時候StringBuilder登場了，StringBuilder是JDK1.5釋出的，它和StringBuffer本質上沒什麼區別，就是去掉了保證執行緒安全的那部分，減少了開銷。

StringBuffer 和 StringBuilder 二者都繼承了 AbstractStringBuilder ，底層都是利用可修改的char陣列(JDK 9 以後是 byte陣列)。

所以如果我們有大量的字串拼接，如果能預知大小的話最好在new StringBuffer 或者StringBuilder 的時候設定好capacity，避免多次擴容的開銷。擴容要拋棄原有陣列，還要進行陣列複製建立新的陣列。

我們平日開發通常情況下少量的字串拼接其實沒太必要擔心，例如

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

像這種沒有變數的字串，編譯階段就直接合成"aabbcc"了，然後看字串常量池（下面會說到常量池）裡有沒有，有也直接引用，沒有就在常量池中生成，返回引用。

如果是帶變數的，其實影響也不大，JVM會幫我們最佳化了。

> 1、在字串不經常發生變化的業務場景優先使用String(程式碼更清晰簡潔)。如常量的宣告，少量的字串操作(拼接，刪除等)。
> 
> 2、在單執行緒情況下，如有大量的字串操作情況，應該使用StringBuilder來操作字串。不能使用String"+"來拼接而是使用，避免產生大量無用的中間物件，耗費空間且執行效率低下（新建物件、回收物件花費大量時間）。如JSON的封裝等。
> 
> 3、在多執行緒情況下，如有大量的字串操作情況，應該使用StringBuffer。如HTTP引數解析和封裝等。

## String類的原始碼分析

### String型別的intern

public void intern () {
        //2：string的intern使用
        //s1是基本型別，比較值。s2是string例項，比較例項地址
        //字串型別用equals方法比較時只會比較值
        String s1 = "a";
        String s2 = new String("a");
        //呼叫intern時,如果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
底層是繼承父類的可變字元陣列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);
      }
      這兩個類的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關鍵字來保證執行緒安全，效率較低。

String型別在使用 + 運算子例如

String a = "a"

a = a + a;時，實際上先把a封裝成stringbuilder，呼叫append方法後再用tostring返回，所以當大量使用字串加法時，會大量地生成stringbuilder例項，這是十分浪費的，這種時候應該用stringbuilder來代替string。

### 擴容
#注意在append方法中呼叫到了一個函式

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

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陣列長度則進行擴容

擴容後的長度一般為原來的兩倍 + 2；

假如擴容後的長度超過了jvm支援的最大陣列長度MAX_ARRAY_SIZE。

考慮兩種情況

如果新的字串長度超過int最大值，則丟擲異常，否則直接使用陣列最大長度作為新陣列的長度。

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

### 刪除
這兩個型別的刪除操作：

都是呼叫父類的delete方法進行刪除

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;
 }
 
事實上是將剩餘的字元重新複製到字元陣列value。

這裡用到了system.arraycopy來複製陣列，速度是比較快的

### system.arraycopy方法
轉自知乎：

> 在主流高效能的JVM上（HotSpot VM系、IBM J9 VM系、JRockit系等等），可以認為System.arraycopy()在複製陣列時是可靠高效的——如果發現不夠高效的情況，請報告performance bug，肯定很快就會得到改進。
> 
> java.lang.System.arraycopy()方法在Java程式碼裡宣告為一個native方法。所以最naïve的實現方式就是透過JNI呼叫JVM裡的native程式碼來實現。
> 
> String的不可變性
> 關於String的不可變性，這裡轉一個不錯的回答
> 
> 什麼是不可變？
> String不可變很簡單，如下圖，給一個已有字串"abcd"第二次賦值成"abcedl"，不是在原記憶體地址上修改資料，而是重新指向一個新物件，新地址。
>

## String和JVM的關係

下面我們瞭解下Java棧、Java堆、方法區和常量池：

Java棧（執行緒私有資料區）：

```
    每個Java虛擬機器執行緒都有自己的Java虛擬機器棧，Java虛擬機器棧用來存放棧幀，每個方法被執行的時候都會同時建立一個棧幀（Stack Frame）用於儲存區域性變數表、操作棧、動態連結、方法出口等資訊。每一個方法被呼叫直至執行完成的過程，就對應著一個棧幀在虛擬機器棧中從入棧到出棧的過程。
```

Java堆（執行緒共享資料區）：

```
   在虛擬機器啟動時建立，此記憶體區域的唯一目的就是存放物件例項，幾乎所有的物件例項都在這裡分配。
```

方法區（執行緒共享資料區）：

```
   方法區在虛擬機器啟動的時候被建立，它儲存了每一個類的結構資訊，例如執行時常量池、欄位和方法資料、建構函式和普通方法的位元組碼內容、還包括在類、例項、介面初始化時用到的特殊方法。在JDK8之前永久代是方法區的一種實現，而JDK8元空間替代了永久代，永久代被移除，也可以理解為元空間是方法區的一種實現。
```

常量池（執行緒共享資料區）：

```
    常量池常被分為兩大類：靜態常量池和執行時常量池。

靜態常量池也就是Class檔案中的常量池，存在於Class檔案中。

執行時常量池（Runtime Constant Pool）是方法區的一部分，存放一些執行時常量資料。
```

下面重點了解的是字串常量池：

```
    字串常量池存在執行時常量池之中（在JDK7之前存在執行時常量池之中，在JDK7已經將其轉移到堆中）。

字串常量池的存在使JVM提高了效能和減少了記憶體開銷。

使用字串常量池，每當我們使用字面量（String s=”1”;）建立字串常量時，JVM會首先檢查字串常量池，如果該字串已經存在常量池中，那麼就將此字串物件的地址賦值給引用s（引用s在Java棧中）。如果字串不存在常量池中，就會例項化該字串並且將其放到常量池中，並將此字串物件的地址賦值給引用s（引用s在Java棧中）。
```

```
    使用字串常量池，每當我們使用關鍵字new（String s=new String(”1”);）建立字串常量時，JVM會首先檢查字串常量池，如果該字串已經存在常量池中，那麼不再在字串常量池建立該字串物件，而直接堆中複製該物件的副本，然後將堆中物件的地址賦值給引用s，如果字串不存在常量池中，就會例項化該字串並且將其放到常量池中，然後在堆中複製該物件的副本，然後將堆中物件的地址賦值給引用s。
```

## String為什麼不可變？
翻開JDK原始碼，java.lang.String類起手前三行，是這樣寫的：

public final class String implements java.io.Serializable, Comparable<string>, CharSequence { 
 /** String本質是個char陣列. 而且用final關鍵字修飾.*/ 
 private final char value[]; ... ...
 }

首先String類是用final關鍵字修飾，這說明String不可繼承。再看下面，String類的主力成員欄位value是個char[]陣列，而且是用final修飾的。

final修飾的欄位建立以後就不可改變。 有的人以為故事就這樣完了，其實沒有。因為雖然value是不可變，也只是value這個引用地址不可變。擋不住Array陣列是可變的事實。

Array的資料結構看下圖。

也就是說Array變數只是stack上的一個引用，陣列的本體結構在heap堆。

String類裡的value用final修飾，只是說stack裡的這個叫value的引用地址不可變。沒有說堆裡array本身資料不可變。看下面這個例子，

final int[] value={1,2,3} ；
    int[] another={4,5,6};
     value=another;    //編譯器報錯，final不可變 value用final修飾，編譯器不允許我把value指向堆區另一個地址。
    但如果我直接對陣列元素動手，分分鐘搞定。
    
     final int[] value={1,2,3};
     value[2]=100;  //這時候陣列裡已經是{1,2,100}   所以String是不可變，關鍵是因為SUN公司的工程師。
     在後面所有String的方法裡很小心的沒有去動Array裡的元素，沒有暴露內部成員欄位。private final char value[]這一句裡，private的私有訪問許可權的作用都比final大。而且設計師還很小心地把整個String設成final禁止繼承，避免被其他人繼承後破壞。所以String是不可變的關鍵都在底層的實現，而不是一個final。考驗的是工程師構造資料型別，封裝資料的功力。

### 不可變有什麼好處？
這個最簡單地原因，就是為了安全。看下面這個場景（有評論反應例子不夠清楚，現在完整地寫出來），一個函式appendStr( )在不可變的String引數後面加上一段“bbb”後返回。appendSb( )負責在可變的StringBuilder後面加“bbb”。

總結以下String的不可變性。

> 1 首先final修飾的類只保證不能被繼承，並且該類的物件在堆記憶體中的地址不會被改變。
> 
> 2 但是持有String物件的引用本身是可以改變的，比如他可以指向其他的物件。
> 
> 3 final修飾的char陣列保證了char陣列的引用不可變。但是可以透過char[0] = 'a’來修改值。不過String內部並不提供方法來完成這一操作，所以String的不可變也是基於程式碼封裝和訪問控制的。

舉個例子

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例項化的物件在堆中記憶體地址是不可變的。
        //雖然記憶體地址不可變，但是可以對內部的資料做改變。
        Fi f = new Fi();
        f.a = 1;
        System.out.println(f);
        f.a = 2;
        System.out.println(f);
        //改變例項中的值並不改變記憶體地址。

```
Fi ff = f;
//讓引用指向新的Fi物件，原來的f物件由新的引用ff持有。
//引用的指向改變也不會改變原來物件的地址
f = new Fi();
System.out.println(f);
System.out.println(ff);

}
```

這裡的對f.a的修改可以理解為char[0] = 'a'這樣的操作。只改變資料值，不改變記憶體值。

## String常用工具類
問題描述
很多時候我們需要對字串進行很多固定的操作,而這些操作在JDK/JRE中又沒有預置,於是我們想到了apache-commons元件,但是它也不能完全覆蓋我們的業務需求,所以很多時候還是要自己寫點程式碼的,下面就是基於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 
 * ①.入參為空
 * ②.入參為空字串
 * ③.入參為"null"字串
 *
 * @param string 需要判斷的字元型
 * @return boolean
 */
 public static boolean isNullOrEmptyOrNULLString(String string) {
 return isBlank(string) || NULL_STRING.equalsIgnoreCase(string);
 }

/**
 * 把字串轉為二進位制碼 
 * 本方法不會返回null
 *
 * @param str 需要轉換的字串
 * @return 二進位制位元組碼陣列
 */
 public static byte[] toBytes(String str) {
 return isBlank(str) ? new byte[]{} : str.getBytes();
 }

/**
 * 把字串轉為二進位制碼 
 * 本方法不會返回null
 *
 * @param str 需要轉換的字串
 * @param charset 編碼型別
 * @return 二進位制位元組碼陣列
 * @throws UnsupportedEncodingException 字串轉換的時候編碼不支援時出現
 */
 public static byte[] toBytes(String str, Charset charset) throws UnsupportedEncodingException {
 return isBlank(str) ? new byte[]{} : str.getBytes(charset.displayName());
 }

/**
 * 把字串轉為二進位制碼 
 * 本方法不會返回null
 *
 * @param str 需要轉換的字串
 * @param charset 編碼型別
 * @param locale 編碼型別對應的地區
 * @return 二進位制位元組碼陣列
 * @throws UnsupportedEncodingException 字串轉換的時候編碼不支援時出現
 */
 public static byte[] toBytes(String str, Charset charset, Locale locale) throws UnsupportedEncodingException {
 return isBlank(str) ? new byte[]{} : str.getBytes(charset.displayName(locale));
 }

/**
 * 二進位制碼轉字串 
 * 本方法不會返回null
 *
 * @param bytes 二進位制碼
 * @return 字串
 */
 public static String bytesToString(byte[] bytes) {
 return bytes == null || bytes.length == 0 ? EMPTY : new String(bytes);
 }

/**
 * 二進位制碼轉字串 
 * 本方法不會返回null
 *
 * @param bytes 二進位制碼
 * @param charset 編碼集
 * @return 字串
 * @throws UnsupportedEncodingException 當前二進位制碼可能不支援傳入的編碼
 */
 public static String byteToString(byte[] bytes, Charset charset) throws UnsupportedEncodingException {
 return bytes == null || bytes.length == 0 ? EMPTY : new String(bytes, charset.displayName());
 }

/**
 * 二進位制碼轉字串 
 * 本方法不會返回null
 *
 * @param bytes 二進位制碼
 * @param charset 編碼集
 * @param locale 本地化
 * @return 字串
 * @throws UnsupportedEncodingException 當前二進位制碼可能不支援傳入的編碼
 */
 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));
 }

/**
     * 把物件轉為字串
     *
     * @param object 需要轉化的字串
     * @return 字串, 可能為空
     */
    public static String parseString(Object object) {
        if (object == null) {
            return null;
        }
        if (object instanceof byte[]) {
            return bytesToString((byte[]) object);
        }
        return object.toString();
    }

/**
     * 把字串轉為int型別
     *
     * @param str 需要轉化的字串
     * @return int
     * @throws NumberFormatException 字串格式不正確時丟擲
     */
    public static int parseInt(String str) throws NumberFormatException {
        return isBlank(str) ? 0 : Integer.parseInt(str);
    }

/**
     * 把字串轉為double型別
     *
     * @param str 需要轉化的字串
     * @return double
     * @throws NumberFormatException 字串格式不正確時丟擲
     */
    public static double parseDouble(String str) throws NumberFormatException {
        return isBlank(str) ? 0D : Double.parseDouble(str);
    }

/**
     * 把字串轉為long型別
     *
     * @param str 需要轉化的字串
     * @return long
     * @throws NumberFormatException 字串格式不正確時丟擲
     */
    public static long parseLong(String str) throws NumberFormatException {
        return isBlank(str) ? 0L : Long.parseLong(str);
    }

/**
     * 把字串轉為float型別
     *
     * @param str 需要轉化的字串
     * @return float
     * @throws NumberFormatException 字串格式不正確時丟擲
     */
    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 "";
    }

/**
     * 獲得使用者遠端地址
     *
     * @param request 請求頭
     * @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);
    }

/**
 * 把字串轉換為JS獲取物件值的三目運算表示式
 *
 * @param objectString 物件串
 * 例如：入參: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
>

## 微信公眾號

### 個人公眾號：黃小斜

黃小斜是跨考軟體工程的 985 碩士，自學 Java 兩年，拿到了 BAT 等近十家大廠 offer，從技術小白成長為阿里工程師。

作者專注於 JAVA 後端技術棧，熱衷於分享程式設計師乾貨、學習經驗、求職心得和程式人生，目前黃小斜的CSDN部落格有百萬+訪問量，知乎粉絲2W+，全網已有10W+讀者。

黃小斜是一個斜槓青年，堅持學習和寫作，相信終身學習的力量，希望和更多的程式設計師交朋友，一起進步和成長！

**原創電子書:**
關注微信公眾號【黃小斜】後回覆【原創電子書】即可領取我原創的電子書《菜鳥程式設計師修煉手冊：從技術小白到阿里巴巴Java工程師》這份電子書總結了我2年的Java學習之路，包括學習方法、技術總結、求職經驗和麵試技巧等內容，已經幫助很多的程式設計師拿到了心儀的offer！

**程式設計師3T技術學習資源：** 一些程式設計師學習技術的資源大禮包，關注公眾號後，後臺回覆關鍵字 **“資料”** 即可免費無套路獲取，包括Java、python、C++、大資料、機器學習、前端、移動端等方向的技術資料。

![](https://img-blog.csdnimg.cn/20190829222750556.jpg)

### 技術公眾號：Java技術江湖

如果大家想要實時關注我更新的文章以及分享的乾貨的話，可以關注我的微信公眾號【Java技術江湖】

這是一位阿里 Java 工程師的技術小站。作者黃小斜，專注 Java 相關技術：SSM、SpringBoot、MySQL、分散式、中介軟體、叢集、Linux、網路、多執行緒，偶爾講點Docker、ELK，同時也分享技術乾貨和學習經驗，致力於Java全棧開發！

（關注公眾號後回覆”Java“即可領取 Java基礎、進階、專案和架構師等免費學習資料，更有資料庫、分散式、微服務等熱門技術學習影片，內容豐富，兼顧原理和實踐，另外也將贈送作者原創的Java學習指南、Java程式設計師面試指南等乾貨資源）

**Java工程師必備學習資源:** 一些Java工程師常用學習資源，關注公眾號後，後臺回覆關鍵字 **“Java”** 即可免費無套路獲取。

![我的公眾號](https://img-blog.csdnimg.cn/20190805090108984.jpg)

</string>

夯實Java基礎系列3：一文搞懂String常見面試題，從基礎到實戰

相關文章