夯實Java基礎系列3：一文搞懂String常見面試題，從基礎到實戰，更有原理分析和源碼解析！

目錄

• string基礎
  • Java String 類
  • 建立字符串
  • StringDemo.java 文件代碼：
• String基本用法
  • 建立String對象的經常使用方法
  • String中經常使用的方法，用法如圖所示，具體問度娘
  • 三個方法的使用： lenth() substring() charAt()
  • 字符串與byte數組間的相互轉換
  • ==運算符和equals之間的區別：
  • 字符串的不可變性
  • String的鏈接
  • String、String builder和String buffer的區別
• String類的源碼分析
  • String類型的intern
  • String類型的equals
  • StringBuffer和Stringbuilder
  • append方法
  • 擴容 *
  • 刪除
  • system.arraycopy方法
• String和JVM的關係
• String爲何不可變？
  • 不可變有什麼好處？
• String經常使用工具類
• 參考文章
• 微信公衆號
  • Java技術江湖
  • 我的公衆號：黃小斜

本系列文章將整理到我在GitHub上的《Java面試指南》倉庫，更多精彩內容請到個人倉庫裏查看

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

喜歡的話麻煩點下Star哈

文章首發於個人我的博客：

www.how2playlife.com

本文是微信公衆號【Java技術江湖】的《夯實Java基礎系列博文》其中一篇，本文部份內容來源於網絡，爲了把本文主題講得清晰透徹，也整合了不少我認爲不錯的技術博客內容，引用其中了一些比較好的博客文章，若有侵權，請聯繫做者。 該系列博文會告訴你如何從入門到進階，一步步地學習Java基礎知識，並上手進行實戰，接着瞭解每一個Java知識點背後的實現原理，更完整地瞭解整個Java技術體系，造成本身的知識框架。爲了更好地總結和檢驗你的學習成果，本系列文章也會提供每一個知識點對應的面試題以及參考答案。

若是對本系列文章有什麼建議，或者是有什麼疑問的話，也能夠關注公衆號【Java技術江湖】聯繫做者，歡迎你參與本系列博文的創做和修訂。

[TOC]

<!-- more -->

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 類。

String基本用法

建立String對象的經常使用方法

（1） String s1 = "mpptest"

(2) String s2 = new String();

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

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

三個方法的使用： 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>

<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的對象一旦被建立，則不能修改，是不可變的

所謂的修改實際上是建立了新的對象，所指向的內存空間不變

上圖中，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會幫咱們優化了。

一、在字符串不常常發生變化的業務場景優先使用String(代碼更清晰簡潔)。如常量的聲明，少許的字符串操做(拼接，刪除等)。

二、在單線程狀況下，若有大量的字符串操做狀況，應該使用StringBuilder來操做字符串。不能使用String"+"來拼接而是使用，避免產生大量無用的中間對象，耗費空間且執行效率低下（新建對象、回收對象花費大量時間）。如JSON的封裝等。

三、在多線程狀況下，若有大量的字符串操做狀況，應該使用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<br/>
 * ①.入參爲空
 * ②.入參爲空字符串
 * ③.入參爲"null"字符串
 *
 * @param string 須要判斷的字符型
 * @return boolean
 */
public static boolean isNullOrEmptyOrNULLString(String string) {
    return isBlank(string) || NULL_STRING.equalsIgnoreCase(string);
}

/**
 * 把字符串轉爲二進制碼<br/>
 * 本方法不會返回null
 *
 * @param str 須要轉換的字符串
 * @return 二進制字節碼數組
 */
public static byte[] toBytes(String str) {
    return isBlank(str) ? new byte[]{} : str.getBytes();
}

/**
 * 把字符串轉爲二進制碼<br/>
 * 本方法不會返回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());
}

/**
 * 把字符串轉爲二進制碼<br/>
 * 本方法不會返回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));
}

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

/**
 * 二進制碼轉字符串<br/>
 * 本方法不會返回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());
}

/**
 * 二進制碼轉字符串<br/>
 * 本方法不會返回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();
}

}

參考文章

http://www.javashuo.com/article/p-pmrcdgfg-n.html 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 http://www.javashuo.com/article/p-zxkurinh-bg.html

微信公衆號

Java技術江湖

若是你們想要實時關注我更新的文章以及分享的乾貨的話，能夠關注個人公衆號【Java技術江湖】一位阿里 Java 工程師的技術小站，做者黃小斜，專一 Java 相關技術：SSM、SpringBoot、MySQL、分佈式、中間件、集羣、Linux、網絡、多線程，偶爾講點Docker、ELK，同時也分享技術乾貨和學習經驗，致力於Java全棧開發！

Java工程師必備學習資源: 一些Java工程師經常使用學習資源，關注公衆號後，後臺回覆關鍵字 「Java」 便可免費無套路獲取。

我的公衆號：黃小斜

做者是 985 碩士，螞蟻金服 JAVA 工程師，專一於 JAVA 後端技術棧：SpringBoot、MySQL、分佈式、中間件、微服務，同時也懂點投資理財，偶爾講點算法和計算機理論基礎，堅持學習和寫做，相信終身學習的力量！

程序員3T技術學習資源： 一些程序員學習技術的資源大禮包，關注公衆號後，後臺回覆關鍵字 「資料」 便可免費無套路獲取。