java String类说明

深碍√TFBOYSˉ_ 2022-12-18 02:57 158阅读 0赞

--------------------

### java String类说明 ###

### \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* ###

**String 类**

**String**

public final class String
        implements java.io.Serializable, Comparable<String>, CharSequence,
                   Constable, ConstantDesc {  //String类用final修饰，不可被继承修改
    
        @Stable
        private final byte[] value;           //使用字节数组存储字符串内容
                                              //value用final修饰，指针指向不可修改
    
        /**
         * The identifier of the encoding used to encode the bytes in
         * {@code value}. The supported values in this implementation are
         *
         * LATIN1
         * UTF16
         */
        private final byte coder;             //字符串编码方式，可选值：LATIN1、UTF16
    
    
        /** Cache the hash code for the string */
        private int hash;                     //缓存字符串hash值，默认0
    
        /**
         * Cache if the hash has been calculated as actually being zero, enabling
         * us to avoid recalculating this.
         */
        private boolean hashIsZero;           //hash是否为0，默认false
                                              //首次返回hashcode后，会用hash缓存，随后获取hashcode时，直接返回hash，避免重复计算
    
        @java.io.Serial
        private static final long serialVersionUID = -6849794470754667710L;
    
    
        static final boolean COMPACT_STRINGS; //是否压缩字符串，默认：true
    
        static {
            COMPACT_STRINGS = true;
        }
    
    
        @java.io.Serial
        private static final ObjectStreamField[] serialPersistentFields =
            new ObjectStreamField[0];

### \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* ###

**字符串存储**

String s1="hello";               //"hello"存储在常量池中，s1指向常量池中的字符串
    
    String s2=new String("hello2");  //若常量池中没有字符串"hello2"，将"hello2"存入常量池
                                     //在堆内存中开辟内存空间，内容为"hello2"，s2指向堆内存中的对象

**示例**

public class MyTest {
    
        public static void main(String[] args){
            String s1="hello";
            String s2="hello";
            System.out.println("s1==s2："+(s1 == s2));
    
            String s3="hello2";
            String s4=new String("hello2");
            System.out.println("s3==s4："+(s3 == s4));
        }
    }

**控制台输出**

s1==s2：true
    s3==s4：false

### \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* ###

**字符串拼接**

**字符串拼接：s1 + s2**

public class MyTest {
    
        public static void main(String[] args){
            String s1="hello";
            String s2="hello";
            String s3=s1+s2;
        }
    }

**java 版本**

E:\java\IdeaProjects\test 2>java -version
    java version "15" 2020-09-15
    Java(TM) SE Runtime Environment (build 15+36-1562)
    Java HotSpot(TM) 64-Bit Server VM (build 15+36-1562, mixed mode, sharing)

**字节码：view ==> show bytecode**

public class stringtest/MyTest {
    
      // compiled from: MyTest.java
      // access flags 0x19
      public final static INNERCLASS java/lang/invoke/MethodHandles$Lookup java/lang/invoke/MethodHandles Lookup
    
      // access flags 0x1
      public <init>()V
       L0
        LINENUMBER 3 L0
        ALOAD 0
        INVOKESPECIAL java/lang/Object.<init> ()V
        RETURN
       L1
        LOCALVARIABLE this Lstringtest/MyTest; L0 L1 0
        MAXSTACK = 1
        MAXLOCALS = 1
    
      // access flags 0x9
      public static main([Ljava/lang/String;)V
       L0
        LINENUMBER 6 L0
        LDC "hello"
        ASTORE 1
       L1
        LINENUMBER 7 L1
        LDC "hello"
        ASTORE 2
       L2
        LINENUMBER 8 L2
        ALOAD 1
        ALOAD 2
        INVOKEDYNAMIC makeConcatWithConstants(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String; [
          // handle kind 0x6 : INVOKESTATIC
          java/lang/invoke/StringConcatFactory.makeConcatWithConstants(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/String;[Ljava/lang/Object;)Ljava/lang/invoke/CallSite;
          // arguments:
          "\u0001\u0001"
        ]
        ASTORE 3
       L3
        LINENUMBER 9 L3
        RETURN
       L4
        LOCALVARIABLE args [Ljava/lang/String; L0 L4 0
        LOCALVARIABLE s1 Ljava/lang/String; L1 L4 1
        LOCALVARIABLE s2 Ljava/lang/String; L2 L4 2
        LOCALVARIABLE s3 Ljava/lang/String; L3 L4 3
        MAXSTACK = 2
        MAXLOCALS = 4
    }

**字符串拼接调用****java/lang/invoke/StringConcatFactory.makeConcatWithConstants**

**StringConcatFactory**

*
     * @since 9
     */
    public final class StringConcatFactory {
    
    
        public static CallSite makeConcatWithConstants(MethodHandles.Lookup lookup,
                                                       String name,
                                                       MethodType concatType,
                                                       String recipe,
                                                       Object... constants)
            throws StringConcatException
        {
            Objects.requireNonNull(lookup, "Lookup is null");
            Objects.requireNonNull(name, "Name is null");
            Objects.requireNonNull(concatType, "Concat type is null");
            Objects.requireNonNull(constants, "Constants are null");
    
            for (Object o : constants) {
                Objects.requireNonNull(o, "Cannot accept null constants");
            }
    
            if ((lookup.lookupModes() & MethodHandles.Lookup.PRIVATE) == 0) {
                throw new StringConcatException("Invalid caller: " +
                        lookup.lookupClass().getName());
            }
    
            List<String> elements = parseRecipe(concatType, recipe, constants);
    
            if (!concatType.returnType().isAssignableFrom(String.class)) {
                throw new StringConcatException(
                        "The return type should be compatible with String, but it is " +
                                concatType.returnType());
            }
    
            if (concatType.parameterSlotCount() > MAX_INDY_CONCAT_ARG_SLOTS) {
                throw new StringConcatException("Too many concat argument slots: " +
                        concatType.parameterSlotCount() +
                        ", can only accept " +
                        MAX_INDY_CONCAT_ARG_SLOTS);
            }
    
            try {
                return new ConstantCallSite(
                        generateMHInlineCopy(concatType, elements)
                                .viewAsType(concatType, true));
                        //调用generateMHInlineCopy创建MethodHandle
            } catch (Error e) {
                // Pass through any error
                throw e;
            } catch (Throwable t) {
                throw new StringConcatException("Generator failed", t);
            }
        }
    
    
    
        /**
         * <p>This strategy replicates what StringBuilders are doing: it builds the
         * byte[] array on its own and passes that byte[] array to String
         * constructor. This strategy requires access to some private APIs in JDK,
         * most notably, the private String constructor that accepts byte[] arrays
         * without copying.
         */
         //这种方法和StringBuilder做的类似：创建字节数组（byte[] array），
         //再将字节数组传递给String的构造函数，构造函数不需要复制字节数组，直接使用
        private static MethodHandle generateMHInlineCopy(MethodType mt, List<String> elements) {

**\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\***

**示例**

public class MyTest {
    
        public static void main(String[] args){
            String s1="hello";
            String s2="hello";
            String s3=s1+s2;                //s3指向堆内存中的对象
    
            String s4="hello"+"hello";      //s4直接在常量池中拼接生成，指向常量池中的字符串
            String s5="hellohello";         //s5指向常量池中的字符串
    
            final String s6="hello";
            final String s7="hello";
            String s8=s6+s7;                //s8在常量池中拼接生成，指向常量池字符串
    
            final String s9=new String("hello");
            final String s10=new String("hello");
            String s11=s9+s10;              //s11由invokedynamic指令在堆内存中创建，指向堆内存对象
    
            System.out.println("s3 == s5："+(s3==s5));
            System.out.println("s4 == s5："+(s4==s5));
            System.out.println("s5 == s8："+(s5==s8));
            System.out.println("s5 == s11："+(s5==s11));
        }
    }

**控制台输出**

s3 == s5：false
    s4 == s5：true
    s5 == s8：true
    s5 == s11：false

**字节码**

public class stringtest.MyTest {
      public stringtest.MyTest();
        Code:
           0: aload_0
           1: invokespecial #1                  // Method java/lang/Object."<init>":()V
           4: return
    
      public static void main(java.lang.String[]);
        Code:
           0: ldc           #7                  // String hello
                        //读取常量：hello
           2: astore_1  //写入局部变量s1
                        //String s1="hello";完成
    
    
           3: ldc           #7                  // String hello
                        //读取常量：hello
           5: astore_2  //写入局部变量s2
                        //String s2="hello";完成
    
    
           6: aload_1   //读取局部变量s1
           7: aload_2   //读取局部变量s2
           8: invokedynamic #9,  0              // InvokeDynamic #0:makeConcatWithConstants:(Ljava/lang/String;Ljava/lang/String;)Ljava/lan
    g/String;
                        //指令invokedynamic调用makeConcatWithConstants拼接字符串
          13: astore_3  //写入局部变量s3
                        //String s3=s1 + s2;完成
    
    
          14: ldc           #13                 // String hellohello
                        //读取常量：hellohello
          16: astore        4
                        //写入局部变量s4
                        //String s4="hello"+"hello";完成
    
    
          18: ldc           #13                 // String hellohello
                        //读取常量：hellohello
          20: astore        5
                        //写入局部变量s5
                        //String s5="hellohello";完成
    
    
                        //final String s6="hello"; 类加载阶段放入常量池
                        //final String s7="hello"; 类加载阶段放入常量池
    
    
          22: ldc           #13                 // String hellohello
                        //读取常量：hellohello
          24: astore        6
                        //写入局部变量
                        //String s8=s6+s7;完成
    
    
          26: new           #15                 // class java/lang/String
                        //new指令创建对象
          29: dup       //保存内存地址引用
          30: ldc           #7                  // String hello
                        //读取常量：hello
          32: invokespecial #17                 // Method java/lang/String."<init>":(Ljava/lang/String;)V
                        //调用类的初始化方法
          35: astore        7
                        //写入局部变量s9
                        //String s9=new String("hello");完成
    
    
          37: new           #15                 // class java/lang/String
                        //创建对象
          40: dup       //保存内存地址引用
          41: ldc           #7                  // String hello
                        //读取常量：hello
          43: invokespecial #17                 // Method java/lang/String."<init>":(Ljava/lang/String;)V
                        //调用字符串初始化方法创建对象
          46: astore        8
                        //写入局部变量s10
                        //String s10=new String("hello");完成
    
    
          48: aload         7
                        //读取引用变量s9
          50: aload         8
                        //读取引用变量s10
          52: invokedynamic #9,  0              // InvokeDynamic #0:makeConcatWithConstants:(Ljava/lang/String;Ljava/lang/String;)Ljava/lan
    g/String;
                        //invokedynamic调用makeConcatWithConstants拼接字符串
          57: astore        9
                        //写入局部变量s11
                        //String s11=s9+s10完成;
    
          59: getstatic     #20                 // Field java/lang/System.out:Ljava/io/PrintStream;
          62: aload_3
          63: aload         5
          65: if_acmpne     72
          68: iconst_1
          69: goto          73
          72: iconst_0
          73: invokedynamic #26,  0             // InvokeDynamic #1:makeConcatWithConstants:(Z)Ljava/lang/String;
          78: invokevirtual #29                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
          81: getstatic     #20                 // Field java/lang/System.out:Ljava/io/PrintStream;
          84: aload         4
          86: aload         5
          88: if_acmpne     95
          91: iconst_1
          92: goto          96
          95: iconst_0
          96: invokedynamic #34,  0             // InvokeDynamic #2:makeConcatWithConstants:(Z)Ljava/lang/String;
         101: invokevirtual #29                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
         104: getstatic     #20                 // Field java/lang/System.out:Ljava/io/PrintStream;
         107: aload         5
         109: aload         6
         111: if_acmpne     118
         114: iconst_1
         115: goto          119
         118: iconst_0
         119: invokedynamic #35,  0             // InvokeDynamic #3:makeConcatWithConstants:(Z)Ljava/lang/String;
         124: invokevirtual #29                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
         127: getstatic     #20                 // Field java/lang/System.out:Ljava/io/PrintStream;
         130: aload         5
         132: aload         9
         134: if_acmpne     141
         137: iconst_1
         138: goto          142
         141: iconst_0
         142: invokedynamic #36,  0             // InvokeDynamic #4:makeConcatWithConstants:(Z)Ljava/lang/String;
         147: invokevirtual #29                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
         150: return
    }