浅谈JVM01：字符串总结

最新推荐文章于 2024-03-26 12:45:31 发布

NickHuangA

最新推荐文章于 2024-03-26 12:45:31 发布

阅读量166

点赞数

分类专栏：面试文章标签： java

本文链接：https://blog.csdn.net/Hyouhuo/article/details/107727126

版权

面试专栏收录该内容

1 篇文章 0 订阅

订阅专栏

前言

本文在第一部分介绍了String的基本特性；第二部分简要的介绍了String的内存分配，在各个JDK版本中的变动；第三部分结合相关难点，介绍了字符串的拼接操作。

第一部分 String的基本特性

java声明为final，不可被继承
String实现了Serializable接口：表示字符串是支持序列化的。实现了Comparable接口：表示String可以比较大小
String在jdk8及以前内部定义了final char[] value用于存储字符串数据。JDK9时改为byte[]。（String再也不用char[] 来存储了，改成了byte [] 加上编码标记，节约了一些空间）
String的不可变性：当对字符串重新赋值时，需要重写指定内存区域赋值，不能使用原有的value进行赋值。当对现有的字符串进行连接操作时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值。当调用string的replace（）方法修改指定字符或字符串时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值。通过字面量的方式（区别于new）给一个字符串赋值，此时的字符串值声明在字符串常量池中。
在字符串常量池不会存储相同的字符串，使用了HashTable。

第二部分 String的内存分配

Java 6及以前，字符串常量池存放在永久代
Java 7中 oracle的工程师对字符串池的逻辑做了很大的改变，即将字符串常量池的位置调整到Java堆内
Java8元空间，字符串常量在堆

所有的字符串都保存在堆（Heap）中，和其他普通对象一样，这样可以让你在进行调优应用时仅需要调整堆大小就可以了。
字符串常量池概念原本使用得比较多，但是这个改动使得我们有足够的理由让我们重新考虑在Java 7中使用string.intern()

为什么StringTable从永久代调整到堆中
原因

永久代的默认比较小
永久代垃圾回收频率低

第三部分:字符串拼接

常量与常量的拼接结果在常量池中，原理是编译器优化
常量池中不会存在相同内容的变量
只要其中有一个是变量，结果就在堆中。变量拼接的原理是StringBuilder
如果拼接的结果调用intern()方法，则主动将常量池中还没有的字符串对象放入池中，并返回此对象地址

public static void test1() {
        String s1 = "a" + "b" + "c";
        String s2 = "abc";

        /**
         *  编译器优化
         */
        System.out.println(s1 == s2); // true，因为存放在字符串常量池
        System.out.println(s1.equals(s2)); // true
    }

    public static void test2() {

        String s1 = "javaEE";
        String s2 = "hadoop";
        String s3 = "javaEEhadoop";
        String s4 = "javaEE" + "hadoop";
        String s5 = s1 + "hadoop";
        String s6 = "javaEE" + s2;
        String s7 = s1 + s2;

        System.out.println(s3 == s4); //true
        System.out.println(s3 == s5); //false
        System.out.println(s3 == s6); //false
        System.out.println(s3 == s7); //false
        System.out.println(s5 == s6); //false
        System.out.println(s5 == s7); //false
        System.out.println(s6 == s7); //false

        String s8 = s6.intern();
        System.out.println(s3 == s8); //true

    }

从上述的结果我们可以知道：
如果拼接符号的前后出现了变量，则相当于（这里的相当于在后面解释）在堆空间中new String()，具体的内容为拼接的结果
而调用intern方法，则会判断字符串常量池中是否存在JavaEEhadoop值，如果存在则返回常量池中的值，否者就在常量池中创建
底层原理
拼接操作底层其实使用了StringBuilder

s1 + s2的执行细节

StringBuilder s = new StringBuilder ();
s.append(s1);
s.append(s2);
s.toString(); -> 类似于new String(“ab”);

在JDK5之后，使用的是StringBuilder，在JDK5之前使用的是StringBuffer
注意，我们左右两边如果是变量的话，就是需要new StringBuilder进行拼接，但是如果使用的是final修饰，则是从常量池中获取。所以说拼接符号左右两边都是字符串常量或常量引用则仍然使用编译器优化。也就是说被final修饰的变量，将会变成常量，类和方法将不能被继承。

在开发中，能够使用final的时候，建议使用上
通过StringBuilder的append()方式添加字符串的效率，要远远高于String的字符串拼接方法
StringBuilder的append的方式，自始至终只创建一个StringBuilder的对象
对于字符串拼接的方式，还需要创建很多StringBuilder对象和调用toString时候创建的String对象
内存中由于创建了较多的StringBuilder和String对象，内存占用过大，如果进行GC那么将会耗费更多的时间

改进的空间

我们使用的是StringBuilder的空参构造器，默认的字符串容量是16，然后将原来的字符串拷贝到新的字符串中，我们也可以默认初始化更大的长度，减少扩容的次数
因此在实际开发中，我们能够确定，前前后后需要添加的字符串不高于某个限定值，那么建议使用构造器创建一个阈值的长度

intern()的使用
intern是一个native方法，调用的是底层C的方法

字符串池最初是空的，由String类私有地维护。在调用intern方法时，如果池中已经包含了由equals(object)方法确定的与该字符串对象相等的字符串，则返回池中的字符串。否则，该字符串对象将被添加到池中，并返回对该字符串对象的引用。

如果不是用双引号声明的string对象，可以使用string提供的intern方法：intern方法会从字符串常量池中查询当前字符串是否存在，若不存在就会将当前字符串放入常量池中。

也就是说，如果在任意字符串上调用string.intern方法，那么其返回结果所指向的那个类实例，必须和直接以常量形式出现的字符串实例完全相同。因此，下列表达式的值必定是true

（"a"+"b"+"c"）.intern（）=="abc"

通俗点讲，Interned string就是确保字符串在内存里只有一份拷贝，这样可以节约内存空间，加快字符串操作任务的执行速度。注意，这个值会被存放在字符串内部池（String Intern Pool）
intern的空间效率测试

public class StringIntern2 {

    static final int MAX_COUNT = 1000 * 10000;
    static final String[] arr = new String[MAX_COUNT];

    public static void main(String[] args) {
        Integer [] data = new Integer[]{1,2,3,4,5,6,7,8,9,10};
        long start = System.currentTimeMillis();
        for (int i = 0; i < MAX_COUNT; i++) {
            //不加intern耗时6079ms
            //加intern耗时2229ms
           arr[i] = new           String(String.valueOf(data[i%data.length])).intern();
        }
        long end = System.currentTimeMillis();
        System.out.println("花费的时间为：" + (end - start));
    }

}

结论：对于程序中大量使用存在的字符串时，尤其存在很多已经重复的字符串时，使用intern()方法能够节省内存空间。

大的网站平台，需要内存中存储大量的字符串。比如社交网站，很多人都存储：北京市、海淀区等信息。这时候如果字符串都调用intern() 方法，就会很明显降低内存的大小。
难点分析
new String(“ab”)会创建一个对象

public class StringNewTest {
    public static void main(String[] args) {
        String str = new String("ab");
    }
}

通过字节码来进行查看

0 new #2 <java/lang/String>
3 dup
4 ldc #3
6 invokespecial #4 <java/lang/String.>
9 astore_1
10 return
这里面就是两个对象

一个对象是：new 关键字在堆空间中创建（第0行）
另一个对象：字符串常量池中的对象（第4行）
new String(“a”) +new String(“b”)会创建几个对象

public class StringNewTest {
    public static void main(String[] args) {
        String str = new String("a") + new String("b");
    }
}

通过字节码文件查看

0 new #2 <java/lang/StringBuilder>
3 dup
4 invokespecial #3 <java/lang/StringBuilder.>
7 new #4 <java/lang/String>
10 dup
11 ldc #5
13 invokespecial #6 <java/lang/String.>
16 invokevirtual #7 <java/lang/StringBuilder.append>
19 new #4 <java/lang/String>
22 dup
23 ldc #8
25 invokespecial #6 <java/lang/String.>
28 invokevirtual #7 <java/lang/StringBuilder.append>
31 invokevirtual #9 <java/lang/StringBuilder.toString>
34 astore_1
35 return

创建了6个对象

对象1：new StringBuilder()(0行)
对象2：new String(“a”)（7行）
常量池a（11行）
对象2：new String(“b”)（19行）
常量池b（23行）
toString中会创建一个new String(“ab”)（31）
- 调用toString方法，不会在常量池中生成ab

intern的使用：JDK6和JDK7
jdk6中

String s = new String("1");  // 在常量池中已经有了
s.intern(); // 将该对象放入到常量池。但是调用此方法没有太多的区别，因为已经存在了1
//导致此时的s指向的是堆中new出来的对象
String s2 = "1";
System.out.println(s == s2); // false

String s3 = new String("1") + new String("1");
s3.intern();//常量池中没有，会在常量池中创建一个，同时将s3指向常量池中对象
String s4 = "11";
System.out.println(s3 == s4); // true

如果换成下面的写法

String s = new String("1");
s = s.intern();
String s2 = "1";
System.out.println(s == s2); // true

JDK7中

String s = new String("1");
s.intern();
String s2 = "1";
System.out.println(s == s2); // true

String s3 = new String("1") + new String("1");
s3.intern();
String s4 = "11";
System.out.println(s3 == s4); // true