String物件的儲存、拼接和比較
String物件的儲存、拼接和比較
( 以下原始碼都基於jdk11)
一、String型別介紹
String型別是參照資料型別，表示字串型別。String底層使用byte[]陣列來儲存char[]陣列。(JDK1.9及以後的版本，JDK1.9之前是使用char陣列儲存，1.9為了節省空間，開始使用byte陣列儲存)
@Stable
private final byte[] value;//定義byte陣列用於儲存建構函式傳進的char陣列，最下方的程式碼中有用到。
從上方的程式碼中可以看出，String用於儲存資料的陣列是private、final的，因此String型別是不可變的。
//String的建構函式
public String(char value[]) { this(value, 0, value.length, null);//呼叫另一個建構函式，程式碼在下方 }
String(char[] value, int off, int len, Void sig) {
if (len == 0) {
this.value = "".value;
this.coder = "".coder;
return;
}
if (COMPACT_STRINGS) {
byte[] val = StringUTF16.compress(value, off, len);
if (val != null) {
this.value = val;
this.coder = LATIN1;
return;
}
}
this.coder = UTF16;
this.value = StringUTF16.toBytes(value, off, len);
}
二、String型別的儲存
虛擬機器器執行時記憶體（JDK1.8以後）
JVM記憶體中與String型別儲存相關的結構主要有堆和虛擬機器器棧。
常數池
常數池在java用於儲存在編譯期已確定的，已編譯的class檔案中的一份資料。它包括了關於類，方法，介面等中的常數，也包括字串常數，如String s = "java"這種申明方式；當然也可擴充，執行器產生的常數也會放入常數池，故認為常數池是JVM的一塊特殊的記憶體空間。
通過常數池的使用String實現了多個參照指向同一個常數池中的物件，大大的節省了記憶體空間的開銷。
JDK1.8之後，常數池存放於JVM執行時記憶體中的堆記憶體中。
String物件的建立
主要有以下兩種建立String物件的方式
1、String a="abcd";
使用這種建立方式時，若常數池中不存在"abcd"這個String物件，則會建立2個物件：在常數池中建立String型別的物件"abcd"，常數池位於上圖所示的堆記憶體中、在棧中建立參照a儲存"abcd"的記憶體地址，從而指向常數池中的"abcd"物件，棧既上圖所示的虛擬機器器棧。
若常數池中已存在"abcd"物件，則會直接返回這個物件，只在棧中建立一個參照a指向該物件。
2、String a=new String("abcd");
使用這種建立方式時，若常數池中不存在值為"abcd"的String物件，則會先在常數池中建立一個值為「abcd」的String物件，然後將其複製一份到堆記憶體中（常數池外，堆記憶體中，地址不同），然後在棧中建立一個參照a儲存"abcd"在堆中的地址，從而指向堆記憶體中的該物件。共建立了三個物件
若常數池重已存在物件「abcd」，則省去在常數池中建立物件的這一步，共建立兩個物件。
三、String型別的拼接
通過concat方法拼接
String a="a";
String b="b";
System.out.println(a.concat(b));//通過a物件concat方法連線b物件，結果為"ab"
下面來看看concat方法的原始碼
public String concat(String str) {
int olen = str.length();
if (olen == 0) {
return this;
}
if (coder() == str.coder()) {//coder來標識字串的編碼格式是LATIN1還是UTF16,若兩個字串的編碼格式相等，則不用進行編碼格式轉換
byte[] val = this.value;
byte[] oval = str.value;
int len = val.length + oval.length;//拼接後字串的長度
byte[] buf = Arrays.copyOf(val, len);//建立一個新陣列存放拼接後的字串
System.arraycopy(oval, 0, buf, val.length, oval.length);
return new String(buf, coder);
}
int len = length();
byte[] buf = StringUTF16.newBytesFor(len + olen);
getBytes(buf, 0, UTF16);
str.getBytes(buf, len, UTF16);
return new String(buf, UTF16);
}
從concat原始碼中容易得出，concat方法通過建立一個長度為兩字串長度之和的byte陣列來存放兩字串，然後將兩個字串依次放入陣列中，實現了字串的拼接。
至於為什麼使用byte陣列，上面講過，String型別底層使用byte陣列儲存char陣列，因此concat使用byte陣列來儲存字串，如果用其他型別的陣列就要進行型別轉換。
注意：concat方法並不會對原物件進行改變，而是會返回一個新的String物件。
通過+號拼接
通過+號的拼接主要分為兩種情況：有字串變數(既在棧中建立的參照)參與的拼接，無字串變數參與，只有字串常數(常數池中的String物件)參與的拼接。
有字串變數(既在棧中建立的參照)參與的拼接：
在網上找了下有字串變數參與+號拼接的實現原理，大部分說的都是：
執行時， 兩個字串str1, str2的拼接首先會呼叫String.valueOf(obj)，這個Obj為str1，而String.valueOf(Obj)中的實現是return obj ==null ? 「null」 : obj.toString()。
然後產生StringBuilder， 呼叫的StringBuilder(str1)構造方法， 把StringBuilder初始化，長度為str1.length()+16，並且呼叫append(str1)！接下來呼叫StringBuilder.append(str2), 把第二個字串拼接進去， 然後呼叫StringBuilder.toString返回結果。
下面我就得從底層中看看它們是如何實現拼接的。
打以下程式碼：
public class Test{
public static void main(String[] args){
String str1 = "111111";
String str2 = "222222";
String str = str1 + str2;
System.out.println(str);
}
}
然後進入dos介面，在dos介面中進入檔案所在資料夾，使用javac Test.java命令生成位元組碼，再使用javap -verbose Test命令進行反編譯，可以看到以下結果。(JDK1.9及以後的版本才能看到如下結果,JDK1.8及以前的可參考這篇博文:Java String + 拼接字串原理)
容易看出以下兩行程式碼 ，對應的是String str = str1 + str2;語句
8: invokedynamic #4, 0 // InvokeDynamic #0:makeConcatWithConstants:(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;
13: astore_3
動態指令invokedynamic指令會呼叫makeConcatWithConstants方法進行字串的連線。
該方法位於java.lang.invoke.StringConcatFactory類中。
下面是原始碼，容易看出這個方法裡如果沒出問題，是直接呼叫doStringConcat方法
public static CallSite makeConcatWithConstants(MethodHandles.Lookup lookup,
String name,
MethodType concatType,
String recipe,
Object... constants) throws StringConcatException {
if (DEBUG) {
System.out.println("StringConcatFactory " + STRATEGY + " is here for " + concatType + ", {" + recipe + "}, " + Arrays.toString(constants));
}
return doStringConcat(lookup, name, concatType, false, recipe, constants);
}
下面是doStringConcat方法的部分原始碼，多的就省略了。可以看到返回值中，mh呼叫asType方法適配得到MethodHandle物件，返回值的邏輯就是單純的返回一個結果，字串拼接是在mh物件生成的時候進行的，也就是在generate方法中進行。
private static CallSite doStringConcat(MethodHandles.Lookup lookup,
String name,
MethodType concatType,
boolean generateRecipe,
String recipe,
Object... constants) throws StringConcatException {
......
MethodHandle mh;
if (CACHE_ENABLE) {
Key key = new Key(className, mt, rec);
mh = CACHE.get(key);
if (mh == null) {
mh = generate(lookup, className, mt, rec);
CACHE.put(key, mh);
}
} else {
mh = generate(lookup, className, mt, rec);
}
return new ConstantCallSite(mh.asType(concatType));
下面是generate方法的原始碼
private static MethodHandle generate(Lookup lookup, String className, MethodType mt, Recipe recipe) throws StringConcatException {
try {
switch (STRATEGY) {
case BC_SB:
return BytecodeStringBuilderStrategy.generate(lookup, className, mt, recipe, Mode.DEFAULT);
case BC_SB_SIZED:
return BytecodeStringBuilderStrategy.generate(lookup, className, mt, recipe, Mode.SIZED);
case BC_SB_SIZED_EXACT:
return BytecodeStringBuilderStrategy.generate(lookup, className, mt, recipe, Mode.SIZED_EXACT);
case MH_SB_SIZED:
return MethodHandleStringBuilderStrategy.generate(mt, recipe, Mode.SIZED);
case MH_SB_SIZED_EXACT:
return MethodHandleStringBuilderStrategy.generate(mt, recipe, Mode.SIZED_EXACT);
case MH_INLINE_SIZED_EXACT:
return MethodHandleInlineCopyStrategy.generate(mt, recipe);
default:
throw new StringConcatException("Concatenation strategy " + STRATEGY + " is not implemented");
}
} catch (Error | StringConcatException e) {
// Pass through any error or existing StringConcatException
throw e;
} catch (Throwable t) {
throw new StringConcatException("Generator failed", t);
}
}
generate方法通過不同的STRATEGY(策略)值來呼叫不同物件的generate方法。那麼，接下來看看Strategy型別，對檔案中的英文進行了一些簡單的翻譯。
private enum Strategy {
/**
* 位元組碼生成器，呼叫{@link java.lang.StringBuilder}.
*/
BC_SB,
/**
* 位元組碼生成器，呼叫 {@link java.lang.StringBuilder};
* 但要估計所需的儲存空間。
*/
BC_SB_SIZED,
/**
* 位元組碼生成器，呼叫 {@link java.lang.StringBuilder};
* 但需要精確地計算所需的儲存空間。
*/
BC_SB_SIZED_EXACT,
/**
*基於MethodHandle的生成器，最終呼叫 {@link java.lang.StringBuilder}.
* 此策略還嘗試估計所需的儲存空間。
*/
MH_SB_SIZED,
/**
* 基於MethodHandle的生成器，最終呼叫 {@link java.lang.StringBuilder}.
* 此策略也需要準確地計算所需的儲存空間。
*/
MH_SB_SIZED_EXACT,
/**
* 基於MethodHandle的生成器, 基於MethodHandle的生成器，從引數構造自己的byte[]陣列。它精確地計算所需的儲存空間。
*/
MH_INLINE_SIZED_EXACT
}
主要就是針對不同的情況，使用不同的策略值，共六種策略，從而能呼叫適用於當前情況的generate方法。上面五種策略的實現都是基於StringBuilder。
接下來以上面的BytecodeStringBuilderStrategy中的generate方法為例，來具體看一看是怎麼實現字串拼接的（套了一堆娃，終於到正題了）
首先，是呼叫String的ValueOf()方法
if (mode.isExact()) {
/*在精確模式下，我們需要將所有引數轉換為字串表示，因為這允許精確計算它們的字串大小。我們不能在這裡使用私有的原語方法，因此我們也需要轉換它們。
我們還記錄了轉換結果中保證為非null的引數。字串.valueOf是否為我們檢查空。唯一極端的情況是字串.valueOf（物件）返回null本身。
此外，如果發生任何轉換，則傳入引數中的插槽索引不等於最終的本地對映。唯一可能會中斷的情況是將2-slot long/double轉換為1-slot時。因此，我們可以跟蹤修改過的偏移，因為沒有轉換可以覆蓋即將到來的引數。
*/
int off = 0;
int modOff = 0;
for (int c = 0; c < arr.length; c++) {
Class<?> cl = arr[c];
if (cl == String.class) {
if (off != modOff) {
mv.visitIntInsn(getLoadOpcode(cl), off);
mv.visitIntInsn(ASTORE, modOff);
}
} else {
mv.visitIntInsn(getLoadOpcode(cl), off);
mv.visitMethodInsn(
INVOKESTATIC,
"java/lang/String",
"valueOf",
getStringValueOfDesc(cl),
false
);
mv.visitIntInsn(ASTORE, modOff);
arr[c] = String.class;
guaranteedNonNull[c] = cl.isPrimitive();
}
off += getParameterSize(cl);
modOff += getParameterSize(String.class);
}
}
if (mode.isSized()) {
/*在調整大小模式（包括精確模式）下操作時，讓StringBuilder附加鏈看起來熟悉優化StringConcat是有意義的。為此，我們需要儘早進行空檢查，而不是使附加鍊形狀更簡單。*/
int off = 0;
for (RecipeElement el : recipe.getElements()) {
switch (el.getTag()) {
case TAG_CONST:
// Guaranteed non-null, no null check required.
break;
case TAG_ARG:
// Null-checks are needed only for String arguments, and when a previous stage
// did not do implicit null-checks. If a String is null, we eagerly replace it
// with "null" constant. Note, we omit Objects here, because we don't call
// .length() on them down below.
int ac = el.getArgPos();
Class<?> cl = arr[ac];
if (cl == String.class && !guaranteedNonNull[ac]) {
Label l0 = new Label();
mv.visitIntInsn(ALOAD, off);
mv.visitJumpInsn(IFNONNULL, l0);
mv.visitLdcInsn("null");
mv.visitIntInsn(ASTORE, off);
mv.visitLabel(l0);
}
off += getParameterSize(cl);
break;
default:
throw new StringConcatException("Unhandled tag: " + el.getTag());
}
}
}
然後是生成StringBuilder物件並使用append方法依次將字串加入
// 準備StringBuilder範例
mv.visitTypeInsn(NEW, "java/lang/StringBuilder");
mv.visitInsn(DUP);
if (mode.isSized()) {
/*大小模式要求我們遍歷引數，並估計最終長度。
在精確模式下，這將僅在字串上操作。此程式碼將在堆疊上累積最終長度。*/
int len = 0;
int off = 0;
mv.visitInsn(ICONST_0);
for (RecipeElement el : recipe.getElements()) {
switch (el.getTag()) {
case TAG_CONST:
len += el.getValue().length();
break;
case TAG_ARG:
/*
如果一個引數是String，那麼我們可以對它呼叫.length（）。大小/精確模式為我們轉換了引數。
如果一個引數是原始的，我們可以猜測它的字串表示大小。
*/
Class<?> cl = arr[el.getArgPos()];
if (cl == String.class) {
mv.visitIntInsn(ALOAD, off);
mv.visitMethodInsn(
INVOKEVIRTUAL,
"java/lang/String",
"length",
"()",
false
);
mv.visitInsn(IADD);
} else if (cl.isPrimitive()) {
len += estimateSize(cl);
}
off += getParameterSize(cl);
break;
default:
throw new StringConcatException("Unhandled tag: " + el.getTag());
}
}
// 常數具有非零長度，混合
if (len > 0) {
iconst(mv, len);
mv.visitInsn(IADD);
}
mv.visitMethodInsn(
INVOKESPECIAL,
"java/lang/StringBuilder",
"<init>",
"(I)V",
false
);
} else {
mv.visitMethodInsn(
INVOKESPECIAL,
"java/lang/StringBuilder",
"<init>",
"()V",
false
);
}
// 此時，堆疊上有一個空的StringBuilder，用.append呼叫填充它。
{
int off = 0;
for (RecipeElement el : recipe.getElements()) {
String desc;
switch (el.getTag()) {
case TAG_CONST:
mv.visitLdcInsn(el.getValue());
desc = getSBAppendDesc(String.class);
break;
case TAG_ARG:
Class<?> cl = arr[el.getArgPos()];
mv.visitVarInsn(getLoadOpcode(cl), off);
off += getParameterSize(cl);
desc = getSBAppendDesc(cl);
break;
default:
throw new StringConcatException("Unhandled tag: " + el.getTag());
}
mv.visitMethodInsn(//呼叫append方法
INVOKEVIRTUAL,
"java/lang/StringBuilder",
"append",
desc,
false
);
}
}
if (DEBUG && mode.isExact()) {
/*
Exactness checks compare the final StringBuilder.capacity() with a resulting
String.length(). If these values disagree, that means StringBuilder had to perform
storage trimming, which defeats the purpose of exact strategies.
*/
/*
The logic for this check is as follows:
Stack before: Op:
(SB) dup, dup
(SB, SB, SB) capacity()
(int, SB, SB) swap
(SB, int, SB) toString()
(S, int, SB) length()
(int, int, SB) if_icmpeq
(SB) <end>
Note that it leaves the same StringBuilder on exit, like the one on enter.
*/
mv.visitInsn(DUP);
mv.visitInsn(DUP);
mv.visitMethodInsn(
INVOKEVIRTUAL,
"java/lang/StringBuilder",
"capacity",
"()I",
false
);
mv.visitInsn(SWAP);
mv.visitMethodInsn(
INVOKEVIRTUAL,
"java/lang/StringBuilder",
"toString",
"()Ljava/lang/String;",
false
);
mv.visitMethodInsn(
INVOKEVIRTUAL,
"java/lang/String",
"length",
"()I",
false
);
Label l0 = new Label();
mv.visitJumpInsn(IF_ICMPEQ, l0);
mv.visitTypeInsn(NEW, "java/lang/AssertionError");
mv.visitInsn(DUP);
mv.visitLdcInsn("Failed exactness check");
mv.visitMethodInsn(INVOKESPECIAL,
"java/lang/AssertionError",
"<init>",
"(Ljava/lang/Object;)V",
false);
mv.visitInsn(ATHROW);
mv.visitLabel(l0);
}
下面是該方法中末尾的幾行程式碼，主要就是呼叫StringBuilder的toString()方法並返回該方法得到的物件。
mv.visitMethodInsn(//呼叫StringBuilder的toString()方法
INVOKEVIRTUAL,
"java/lang/StringBuilder",
"toString",
"()Ljava/lang/String;",
false
);
mv.visitInsn(ARETURN);
mv.visitMaxs(-1, -1);
mv.visitEnd();
cw.visitEnd();
byte[] classBytes = cw.toByteArray();
try {
Class<?> hostClass = lookup.lookupClass();
Class<?> innerClass = UNSAFE.defineAnonymousClass(hostClass, classBytes, null);
UNSAFE.ensureClassInitialized(innerClass);
dumpIfEnabled(innerClass.getName(), classBytes);
return Lookup.IMPL_LOOKUP.findStatic(innerClass, METHOD_NAME, args);
} catch (Exception e) {
dumpIfEnabled(className + "$$FAILED", classBytes);
throw new StringConcatException("Exception while spinning the class", e);
}
所以，總結一下，有字串變數參與拼接的過程：首先呼叫String的ValueOf方法，然後是生成一個StringBuilder物件並將用append方法將兩個字串依次加入，然後返回StringBuilder的toString()方法。
只有字串常數(常數池中的String物件)參與的拼接：例如：String a=「ab」+cd;這種拼接，在編譯時，編譯器會自動將a變數編譯為"abcd"
例如以下程式碼：
public class Test2{
public static void main(String[] args){
String str = 「12」+「34」;
System.out.println(str);
}
}
用上述的方法同樣檢視反編譯程式碼
可以看到編譯器直接將str字串編譯為了」1234「.
四、字串的比較
equals方法
String型別的物件有個equals方法，用於比較兩個String物件的值是否相等。
public boolean equals(Object anObject) {
if (this == anObject) {
return true;
}
if (anObject instanceof String) {
String aString = (String)anObject;
if (coder() == aString.coder()) {//判斷編碼格式是否相等
return isLatin1() ? StringLatin1.equals(value, aString.value)
: StringUTF16.equals(value, aString.value);
//根據編碼格式呼叫不同的equals方法
}
}
return false;
}
下面是StringLatin1物件(以Latin1為編碼格式的String物件)的equals方法
@HotSpotIntrinsicCandidate
public static boolean equals(byte[] value, byte[] other) {
if (value.length == other.length) {
for (int i = 0; i < value.length; i++) {
if (value[i] != other[i]) {
return false;
}
}
return true;
}
return false;
}
然後是StringUTF16物件的equals方法
@HotSpotIntrinsicCandidate
public static boolean equals(byte[] value, byte[] other) {
if (value.length == other.length) {
int len = value.length >> 1;
for (int i = 0; i < len; i++) {
if (getChar(value, i) != getChar(other, i)) {
return false;
}
}
return true;
}
return false;
}
可以看出equals方法的實現邏輯就是通過for迴圈遍歷儲存字串的byte陣列，一位一位地進行判斷。
"=="運運算元
「==」運運算元用於比較兩個物件的地址是否相等。用在字串比較時，需要注意"abcd"與new String(「abcd」)所返回的地址值不相同，具體看上方String物件的建立。
注意：上面我們具體分析了有字串變數參與的連線預算，最後的物件是由StringBuilder的toString()方法返回的，而toString()方法底層是返回的是new String()物件，儲存的地址是在堆中，而不是在常數池中。
@Override
@HotSpotIntrinsicCandidate
public String toString() {//StringBuilder物件的toString方法
// Create a copy, don't share the array
return isLatin1() ? StringLatin1.newString(value, 0, count)
: StringUTF16.newString(value, 0, count);
}
//StringLatin1物件的newString方法
public static String newString(byte[] val, int index, int len) {
return new String(Arrays.copyOfRange(val, index, index + len),
LATIN1);
}
//StringUTF16的toString方法
public static String newString(byte[] val, int index, int len) {
if (String.COMPACT_STRINGS) {
byte[] buf = compress(val, index, len);
if (buf != null) {
return new String(buf, LATIN1);
}
}
int last = index + len;
return new String(Arrays.copyOfRange(val, index << 1, last << 1), UTF16);
}