Java教程之String类的底层原理和版本演变

时间:2024-10-10 09:19:07

1 String类的底层演变

JDK8以及之前的版本在这里插入图片描述
JDK9以及之后的版本在这里插入图片描述

	JDK8的字符串存储在char类型的数组里面,在java中,一个char类型占两个字节。但是很多时候,一个字符只需要一个字节就可存储,比如各种字母什么的,两个字节存储势必会浪费空间,JDK9的一个优化就在这,内存的优化,所以JDK9之后字符串改成byte类型数组进行存储。

    private final byte coder;    
	在JDK9的String类中,新增了一个属性coder,它是一个编码格式的标识,使用LATIN1还是UTF16,这个是在String生成的时候自动确定的,如果字符串中都是能用LATIN1编码表示,那coder的值就是0,否则就是UTF16编码,coder的值就是1。
        
	可以看到JDK9在这方面的优化,在较多情况下不包含那些奇奇怪怪的字符的时候,足以应付,而这个空间却小了1byte,实现了String空间的压缩。
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

2 String常量池的演变

2.1 StringTable变化
StringString Pool是一个固定大小的 Hashtable。
    
	在jdk6中,StringTable的长度固定为1009。
    如果放进 String PoolString非常多,就会造成Hash冲突严重,从而导致链表会很长,而链表长了后直接会造成的影响就是当调用 intern() 时性能会大幅下降。
    
    从jdk7起,StringTable的长度默认值是60013。
    
    使用-XX:StringTableSize可设置StringTable的长度。     
	在jdk8之前,对StringTableSize的设置没有最小限制。
	jdk8开始,StringTable可设置的最小值是1009。
        

验证:
	通过 jps 命令查看进程号
    使用 jinfo -flag StringTableSize 进程号 查看StringTable大小    
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
2.2 内存位置变化
Java6及以前,字符串常量池存放在永久代。
    
Java7开始,字符串常量池的位置调整到Java堆内。
所有的字符串都保存在堆(Heap)中,和其他普通对象一样,这样在进行调优应用时仅需要调整堆大小就可以了。
  • 1
  • 2
  • 3
  • 4

官网说明

https://www.oracle.com/technetwork/java/javase/#jdk7changes

在这里插入图片描述

JDK6环境下测试:

/*
    jdk6中,修改JVM内存大小:
    -XX:PermSize=6m -XX:MaxPermSize=6m -Xms6m -Xmx6m
 */
public class StringTableTest {
    public static void main(String[] args) {
        Set<String> set = new HashSet<String>();

        int i=0;
        while (true){
            set.add(String.valueOf(i++).intern());
        }
    }
}

执行结果异常信息:
    Exception in thread "main" java.lang.OutOfMemoryError: PermGen space
	at java.lang.String.intern(Native Method)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

JDK7环境下测试:

/*
    jdk7中,修改JVM内存大小:
    -XX:PermSize=6m -XX:MaxPermSize=6m -Xms6m -Xmx6m -XX:-UseGCOverheadLimit
 */
public class StringTableTest {
    public static void main(String[] args) {
        Set<String> set = new HashSet<String>();

        int i=0;
        while (true){
            set.add(String.valueOf(i++).intern());
        }
    }
}

执行结果异常信息:
    Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
	at java.lang.Integer.toString(Integer.java:331)
	at java.lang.String.valueOf(String.java:2954)
	at StringTableTest.main(StringTableTest.java:14)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20

3 String的拼接原理

3.1 拼接原理

源代码:

public static void main(String[] args) {
    String s1 ="hello";
    String s2 ="world";
    String s3 = s1+s2;
    System.out.println(s3);
} 

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

使用 JDK8 编译后字节码:

 0 ldc #2 <hello>
 2 astore_1
 3 ldc #3 <world>
 5 astore_2
 6 new #4 <java/lang/StringBuilder>
 9 dup
10 invokespecial #5 <java/lang/StringBuilder.<init>>
13 aload_1
14 invokevirtual #6 <java/lang/StringBuilder.append>
17 aload_2
18 invokevirtual #6 <java/lang/StringBuilder.append>
21 invokevirtual #7 <java/lang/StringBuilder.toString>
24 astore_3
25 getstatic #8 <java/lang/System.out>
28 aload_3
29 invokevirtual #9 <java/io/PrintStream.println>
32 return
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

使用 JDK9 编译后字节码:

 0 ldc #2 <hello>
 2 astore_1
 3 ldc #3 <world>
 5 astore_2
 6 aload_1
 7 aload_2
 8 invokedynamic #4 <makeConcatWithConstants, BootstrapMethods #0>
13 astore_3
14 getstatic #5 <java/lang/System.out>
17 aload_3
18 invokevirtual #6 <java/io/PrintStream.println>
21 return
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

结论:

JDK8及之前,字符串变量的拼接,底层使用的是StringBuilder对象,利用append方法进行拼接。
(注:jdk1.4之前使用StringBuffer)
    
    
JDK9以后的编译器已经改成使用动态指令invokedynamic,
	调用StringConcatFactory.makeConcatWithConstants方法进行字符串拼接优化。

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
3.2 核心方法
makeConcatWithConstants方法在StringConcatFactory类中定义。
        
	makeConcatWithConstants内部调用了doStringConcat,
    而doStringConcat方法则调用了generate方法来生成MethodHandle;
    generate根据不同的STRATEGY来生成MethodHandle,这些STRATEGY(策略)有
        BC_SB(等价于JDK8的优化方式)
        BC_SB_SIZED
        BC_SB_SIZED_EXACT
        MH_SB_SIZED
        MH_SB_SIZED_EXACT
        MH_INLINE_SIZED_EXACT(默认)

    前五种策略本质还是用StringBuilder的实现,而默认的策略MH_INLINE_SIZED_EXACT是直接使用字节数组来操作,并且字节数组长度预先计算好,可以减少字符串复制操作。
    
    可以通过添加JVM参数来改变默认的策略,例如将策略改为BC_SB
    	-Djava.lang.invoke.stringConcat=BC_SB
    	-Djava.lang.invoke.stringConcat.debug=true

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

源码:

makeConcatWithConstants内部调用了doStringConcat方法

在这里插入图片描述

doStringConcat方法则调用了generate方法来生成MethodHandle

在这里插入图片描述

generate根据不同的STRATEGY来生成MethodHandle

在这里插入图片描述

这些STRATEGY(策略)分别是

 private enum Strategy {
        /**
         * Bytecode generator, calling into {@link }.
         */
        BC_SB,

        /**
         * Bytecode generator, calling into {@link };
         * but trying to estimate the required storage.
         */
        BC_SB_SIZED,

        /**
         * Bytecode generator, calling into {@link };
         * but computing the required storage exactly.
         */
        BC_SB_SIZED_EXACT,

        /**
         * MethodHandle-based generator, that in the end calls into {@link }.
         * This strategy also tries to estimate the required storage.
         */
        MH_SB_SIZED,

        /**
         * MethodHandle-based generator, that in the end calls into {@link }.
         * This strategy also estimate the required storage exactly.
         */
        MH_SB_SIZED_EXACT,

        /**
         * MethodHandle-based generator, that constructs its own byte[] array from
         * the arguments. It computes the required storage exactly.
         */
        MH_INLINE_SIZED_EXACT
    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36

默认的策略MH_INLINE_SIZED_EXACT

在这里插入图片描述

3.3 常见笔试题
/*
	产生2个字符串对象:字符串常量池中一个,堆内存中一个。
*/
String s = new String("abc");



/*
    产生1个字符串对象:常量池中的"abc"。
    代码在编译阶段会优化为 String s = "abc";
*/
String s = "a"+"b"+"c";



/*
    5个字符串对象
    常量池:"a", "b"
    堆内存:new方式的"a",new方式的"b",new方式的"ab"
    注意:常量池中不会产生"ab"
*/
String s = new String("a") + new String("b");



/*
jdk8及之前创建3个字符串对象:
    常量池: "c" , "ab"
    堆中: new "abc"

jdk9之后创建2个字符串对象:
    常量池: "c"
    堆中: new "abc"
*/
String s1 = "c";
String s2 = "a"+"b"+s1;

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37

4 intern()方法的演变

4.1 intern()方法调用区别
public class StringDemo5 {
    public static void main(String[] args) {
        String s1 = new String("ab");
        String s2 = "ab";
        System.out.println(s1==s2); //fasle


        //intern()方法从常量池中取出"ab"对象
        String s1 = new String("ab").intern();
        String s2 = "ab";
        System.out.println(s1==s2); //true

         /*
            从常量池中取出和s1内容相同的"ab"对象,此时常量池中没有"ab"对象。

            如果常量池中没有该字符串对象:
                jdk6及之前,intern()方法会创建新的字符串对象,放入常量池并返回新的地址。
                jdk7及之后,intern()方法会将调用者对象的地址放入常量池,并返回调用者对象地址。
         */
        String s1 = new String("a") + new String("b");
        s1.intern();
        String s2 = "ab";
        System.out.println(s1==s2); //jdk6 false;  jdk7之后true
    }

}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
4.2 intern()方法总结
intern()方法将这个字符串对象尝试放入常量池中,并返回地址。
    
jdk1.6中:
    如果池中有,则不会放入,返回已有的池中的对象的地址。
    如果池中没有,则把此对象重新创建一份,放入池中,并返回池中新的对象地址。
    
jdk1.7起:
    如果池中有,则不会放入,返回已有的池中的对象的地址。
     如果池中没有,则把此对象的引用地址复制一份,放入池中,并返回池中的引用地址。
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9