string对象的方法有哪些，string的存储结构
chanong
|1. String 类型概述2. String 存储虚拟机的运行时内存（JDK1.8 以�**姹荆� 常量池创建String 对象3. String 类型的连接（concat 方法+符号连接） 4. 字符串比较的相等方法'=='运算符（以下源码基于jdk11）
1. String 类型概述String 类型是表示字符串类型的参考数据类型。 String底层使用byte[]数组来存储char[]数组。 （JDK1.9及之后的版本，JDK1.9之前的版本使用char数组来存储，但是为了节省空间，JDK1.9开始使用byte数组来存储。）
@Stableprivate Final byte[] value;//定义一个字节数组，用于存储构造函数传入的char数组。这在下面的代码中使用。 12 从上面的代码可以看出，String类型是不可变的，因为String用来存储数据的数组是私有的、最终的。
//String 的构造函数public String(char value[]) { this(value, 0, value.length, null); //调用另一个构造函数。代码如下} 12String(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 );} 1234567891011121314151617 2. String 存储的虚拟机运行时内存（JDK1.8 及更高版本） JVM 内存中与String 存储相关的结构包括： 主要包括堆和虚拟机堆栈。
常量池Java的常量池用于存储编译时确定的编译类文件中的数据。这包括类、方法、接口等的常量，以及字符串常量，例如String s='java'。当然，它是可以扩展的，执行器生成的常量也是常量池，所以可以把常量池看成是JVM中的一个特殊的内存空间。
在常量池中使用String允许多个引用指向同一个常量池中的对象，从而节省大量的内存空间开销。从JDK1.8开始，常量池存储在JVM运行时内存中的堆内存中。
创建String对象主要有两种方法： 1. String a='abcd'; 使用这种创建方法时，如果常量池中不存在String对象'abcd'，则创建的两个对象：一个对象'abcd' String类型的'在常量池中。常量池位于堆内存中，如上图所示。在栈中创建一个引用a，保存'abcd'的内存地址，并指向对象中的'abcd'对象。常量池堆栈就是上图所示的虚拟机堆栈。
如果常量池中已经存在“abcd”对象，则直接返回该对象，并且仅在堆栈上创建指向该对象的引用a。
2. String a=new String('abcd'); 使用这种创建方法，如果常量池中不存在值为'abcd'的String对象，则在常量池中创建值为'abcd'的String对象。马苏。首先我们创建一个常量池，将字符串对象复制到堆内存中（常量池外和堆内存中的地址不同），并在栈上创建一个引用来保存‘abcd’的地址。 heap指的是对象的堆内存。总共会创建3个对象，但是如果常量池中已经存在对象‘abcd’，那么会跳过常量池中对象的创建，总共会创建2个对象。
3、字符串类型拼接： String a='a'; String b='b'; System.out.println(a.concat(b));//通过a对象的concat方法连接b对象，结果为：对于'ab'123，我们看一下concat方法的源码。
public String concat(String str) { int olen=str.length(); if (olen==0) { return this; } if (coder()==str.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); }12345678910111213141516171819 从concat 源代码来看，很容易得出结论，concat 方法通过创建以下内容来存储两个字符串：长度等于两个字符串长度之和的字节数组。然后将两个字符串依次放入一个数组中，实现字符串拼接。之所以使用字节数组，是因为上面提到了，底层的String类型使用字节数组来存储char数组，所以concat使用字节数组来存储字符串，但是其他类型使用数组时需要进行类型转换。注意：concat方法不会修改原始对象，而是返回一个新的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); }}12345678下一步进入DOS 。在界面中，在DOS界面进入该文件所在的文件夹，使用javac Test.java命令生成字节码，然后使用javap -verbose Test命令反编译，你会看到如下结果： 就大功告成了。 （下面的结果只会出现在JDK1.9及以后的版本中，JDK1.8及之前的版本请参见这篇博文：Java字符串+字符串拼接原理）
很容易看出下面两行代码对应的是String str=str1 + str2; 语句。
8: invokedynamic #4, 0//InvokeDynamic #0:makeConcatWithConstants:(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;13: astore_312 动态指令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 + ' 在这里是' + concatType + ', {' + Recipe + '}, ' + Arrays.toString(constants)); } return doStringConcat(lookup, name, concatType, false, Recipe,constants);}1234567891011以下是部分源代码。 doStringConcat方法，过多则省略。在返回值中，您可以看到mh 调用asType 方法来适应和检索MethodHandle 对象。返回值逻辑简单来说就是返回结果。字符串连接是在创建mh 对象时执行的。在生成方法内。
私有静态CallSite doStringConcat（MethodHandles.Lookup查找，字符串名称，MethodType concatType，booleangenerateRecipe，字符串配方，对象.常量）抛出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));12345678910111213141516171819以下是generate方法的源码。
私有静态MethodHandlegenerate（Lookup Lookup，String className，MethodType mt，Recipe Recipe）抛出StringConcatException { try { switch（STRATEGY）{ case BC_SB:返回BytecodeStringBuilderStrategy.generate（lookup，className，mt，Recipe，Mode.DEFAULT）; case BC_SB_SIZED:返回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('连接策略' + STRATEGY + ' 未实现。否' ） ; } } catch (Error | StringConcatException e) { //传递错误或已有的StringConcatException throw e; } catch (Throwable t) { new StringConcatException('生成器失败', t); }}12345678910111213141516171819202122232425抛出另一个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 }1234567891011121314151617181920212223242526272829303132333435主要根据情况使用不同的策略值，一共6种策略，所以可以调用适合当前情况的生成方法。以上五种策略实现都是基于StringBuilder的。现在我们以上面的BytecodeStringBuilderStrategy的Generate方法为例，仔细看看如何实现字符串拼接（经过一番折腾终于进入正题）。首先，调用String 的ValueOf() 方法。
if (mode.isExact()) {/*精确模式要求将所有参数转换为字符串表示形式，以便可以准确计算字符串大小。此处不能使用私有原始方法，因此也必须对其进行转换。它还记录了转换结果中保证非空的参数。 String.valueOf 检查它是否为空。唯一的极端情况是string.valueOf(object) 返回null 本身。此外，如果发生转换，传递参数的槽索引将不等于最终的本地映射。唯一可能损坏的情况是将2 个槽位的长/双精度转换为1 个槽位。因此，转换不会覆盖传入的参数，从而允许您跟踪更改的偏移量。 */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;保证NonNull[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://保证不为空，不需要空检查.break; case TAG_ARG://空检查仅对于字符串参数是必需的，并且仅当在前一阶段未进行隐式null 检查时才需要。如果String 为null，请立即将其替换为“null”常量。 //当心。这里省略了对象。 //不要调用下面的.length()。 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('Not处理标签: ' + el.getTag()); } }1234567891011121314151617181920212223242526272829303132333435363738 394041424344454647484950515253 545556575859606162636465 接下来，创建一个StringBuilder对象并使用append方法按顺序追加字符串。
//准备一个StringBuilder 实例mv.visitTypeInsn(NEW, 'java/lang/StringBuilder');mv.visitInsn(DUP);if (mode.isSized()) { /*Size 模式迭代参数和最终长度。在严格模式下，这只适用于字符串。此代码将最终长度累加到堆栈上。 */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: /* 如果参数是字符串，则可以对其调用.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: 抛出新的StringConcatException ('Unhandled tag: ' + el.getTag()); } } //如果常量长度非零则混合if (len 0) { icont(mv, len); mv.visitInsn(IADD); } mv .visitMethodInsn( INVOKESPECIAL , 'java/lang/StringBuilder',
"", "(I)V", false );} else { mv.visitMethodInsn( INVOKESPECIAL, "java/lang/StringBuilder", "", "()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) 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", "", "(Ljava/lang/Object;)V", false); mv.visitInsn(ATHROW); mv.visitLabel(l0); }123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161下面是该方法中末尾的几行代码，主要就是调用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);}12345678910111213141516171819202122232425所以，总结一下，有字符串变量参与拼接的过程：首先调用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;}1234567891011121314下面是StringLatin1对象(以Latin1为编码格式的String对象)的equals方法 @HotSpotIntrinsicCandidatepublic 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;}123456789101112然后是StringUTF16对象的equals方法 @HotSpotIntrinsicCandidatepublic 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;}12345678910111213可以看出equals方法的实现逻辑就是通过for循环遍历保存字符串的byte数组，一位一位地进行判断。 "=="运算符“==”运算符用于比较两个对象的地址是否相等。用在字符串比较时，需要注意"abcd"与new String(“abcd”)所返回的地址值不相同，具体看上方String对象的创建。注意：上面我们具体分析了有字符串变量参与的连接预算，最后的对象是由StringBuilder的toString()方法返回的，而toString()方法底层是返回的是new String()对象，存储的地址是在堆中，而不是在常量池中。 @Override@HotSpotIntrinsicCandidatepublic String toString() {//StringBuilder对象的toString方法 // Create a copy, don't share the array return isLatin1() StringLatin1.newString(value, 0, count) : StringUTF16.newString(value, 0, count);}1234567//StringLatin1对象的newString方法public static String newString(byte[] val, int index, int len) { return new String(Arrays.copyOfRange(val, index, index + len), LATIN1);}12345//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);}