08-字符串常量池

2022-07-18

08-字符串常量池

字符串常量池

一. String基础知识

1.1 定义

  1. String:字符串,使用一对 “” 引起来表示

     String s1 = "mahaonan" ;               // 字面量的定义方式
     String s2 =  new String("hello");     // new 对象的方式
    
  2. String被声明为final的,不可被继承

  3. String实现了Serializable接口:表示字符串是支持序列化的。实现了Comparable接口:表示String可以比较大小

  4. String在jdk8及以前内部定义了final char value[]用于存储字符串数据。JDK9时改为byte[]

1.2 基本特征

  • String:代表不可变的字符序列。简称:不可变性。
  1. 当对字符串重新赋值时,需要重写指定内存区域赋值,不能使用原有的value进行赋值。
  2. 当对现有的字符串进行连接操作时,也需要重新指定内存区域赋值,不能使用原有的value进行赋值。
  3. 当调用String的replace()方法修改指定字符或字符串时,也需要重新指定内存区域赋值,不能使用原有的value进行赋值。
  • 通过字面量的方式(区别于new)给一个字符串赋值,此时的字符串值声明在字符串常量池中。

1.3 底层结构

  1. String的String Pool(字符串常量池)是一个固定大小的Hashtable,默认值大小长度是1009。如果放进String Pool的String非常多,就会造成Hash冲突严重,从而导致链表会很长,而链表长了后直接会造成的影响就是当调用String.intern()方法时性能会大幅下降。

  2. 使用-XX:StringTableSize可设置StringTable的长度

  3. 在JDK6中StringTable是固定的,就是1009的长度,所以如果常量池中的字符串过多就会导致效率下降很快,StringTablesize设置没有要求

  4. 在JDK7中,StringTable的长度默认值是60013,StringTablesize设置没有要求

  5. 在JDK8中,StringTable的长度默认值是60013,StringTable可以设置的最小值为1009

    如果小于,则会抛出如下异常

    Error: Could not create the Java Virtual Machine.
    Error: A fatal exception has occurred. Program will exit.
    StringTable size of 1000 is invalid; must be between 1009 and 2305843009213693951
    

下面的测试类,显示了不同长度配置的StringTableSize对程序性能的影响。

//生成10w个不同的字符串
public class GenerateStr {

    public static void main(String[] args) throws IOException {
        FileWriter fw =  new FileWriter("words.txt");

        for (int i = 0; i < 100000; i++) {
            //1 - 10
            int length = (int)(Math.random() * (10 - 1 + 1) + 1);
            fw.write(getString(length) + "\n");
        }

        fw.close();
    }

    public static String getString(int length){
        String str = "";
        for (int i = 0; i < length; i++) {
            //65 - 90, 97-122
            int num = (int)(Math.random() * (90 - 65 + 1) + 65) + (int)(Math.random() * 2) * 32;
            str += (char)num;
        }
        return str;
    }
}
public class StringTest2 {
    public static void main(String[] args) {

        BufferedReader br = null;
        try {
            br = new BufferedReader(new FileReader("words.txt"));
            long start = System.currentTimeMillis();
            String data;
            while((data = br.readLine()) != null){
                data.intern(); //如果字符串常量池中没有对应data的字符串的话,则在常量池中生成
            }

            long end = System.currentTimeMillis();

            System.out.println("花费的时间为:" + (end - start) + "ms");//1009:74ms  60031:24ms
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(br != null){
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }

            }
        }
    }
}

通过测试可以看出,当设置为1009是耗时74ms,使用默认的60031时耗时24ms

1.4 内存分配

  1. 在Java语言中有8种基本数据类型和一种比较特殊的类型String。这些类型为了使它们在运行过程中速度更快、更节省内存,都提供了一种常量池的概念。

  2. 常量池就类似一个Java系统级别提供的缓存。8种基本数据类型的常量池都是系统协调的,String类型的常量池比较特殊。它的主要使用方法有两种。

    • 直接使用双引号声明出来的String对象会直接存储在常量池中。比如:String info="mahaonan";
    • 如果不是用双引号声明的String对象,可以使用String提供的intern()方法。这个后面重点谈
  3. Java 6及以前,字符串常量池存放在永久代

  4. Java 7中 Oracle的工程师对字符串池的逻辑做了很大的改变,即将字符串常量池的位置调整到Java堆内

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

为什么要调整字符串常量池位置

  • 永久代的默认空间大小比较小
  • 永久代垃圾回收频率低,大量的字符串无法及时回收,容易进行Full GC产生STW或者容易产生OOM:PermGen Space
  • 堆中空间足够大,字符串可被及时回收

二. String基本操作

Java语言规范里要求完全相同的字符串字面量,应该包含同样的Unicode字符序列(包含同一份码点序列的常量),并且必须是指向同一个String类实例。

2.1 举例1

public class StringTest4 {
    public static void main(String[] args) {
        System.out.println();//3904
        System.out.println("1");//3905
        System.out.println("2");
        System.out.println("3");
        System.out.println("4");
        System.out.println("5");
        System.out.println("6");
        System.out.println("7");
        System.out.println("8");
        System.out.println("9");
        System.out.println("10");//3916
        //如下的字符串"1" 到 "10"不会再次加载
        System.out.println("1");//3916
        System.out.println("2");//3916
        System.out.println("3");
        System.out.println("4");
        System.out.println("5");
        System.out.println("6");
        System.out.println("7");
        System.out.println("8");
        System.out.println("9");
        System.out.println("10");//3916
    }
}

执行上述代码过程中开启debug,可以看到执行到某一行时内存中字符串的数量

可以看到,对于重复的字符串,在字符串常量池中只会有一份。

2.2 举例2

public static void main(String[] args) {
    String s1 = "hello";
    String str = new String("hello");
    System.out.println(s1.equals(str)); //true
    System.out.println(s1 == str); //false   
}

上述代码的结果很简单,s1指向的是常量池中的字符串对象,而str指向的是普通堆中的String对象,二者自然不是一个对象。而对于equals的比较则是基于字符串值比较的。

那么,有个问题,众所周知,字符串内部是使用char[]实现的(jdk9以前)。那么对于这两个String对象,其内部的char[]是同一个对象吗?

如下图所示,在equals方法中打上断点,由于有很多类用到了这个方法,因此需要设置断点的条件:

当代码运行到这里时,判断v1是否等于v2,结果如下图,可以看出v1和v2是同一个char数组

另外从字符串的构造方法中也可以看出,对于这种方法创建的字符串,就是原本字符串的value和hash

public String(String original) {
    this.value = original.value;
    this.hash = original.hash;
}

因此,结论如下:

  1. 不同对象的字符串所引用的char数组可能是同一个对象
  2. 字符串对象可以在常量池中,也可以在普通的堆中,取决中字符串的创建方式,是字面量还是new出来的,亦或者是intern()产生的。

2.3. 字符串拼接操作

  1. 常量与常量的拼接结果在常量池,原理是编译期优化
  2. 常量池中不会存在相同内容的变量
  3. 拼接前后,只要其中有一个是变量,结果就在堆中。变量拼接的原理是StringBuilder
  4. 如果拼接的结果调用intern()方法,根据该字符串是否在常量池中存在,分为:
    • 如果存在,则返回字符串在常量池中的地址
    • 如果字符串常量池中不存在该字符串,则在常量池中创建一份,并返回此对象的地址

2.4 字符串拼接的底层细节

@Test
public void test3(){
    String s1 = "a";
    String s2 = "b";
    String s3 = "ab";
    /*
        如下的s1 + s2 的执行细节:(变量s是我临时定义的)
        ① StringBuilder s = new StringBuilder();
        ② s.append("a")
        ③ s.append("b")
        ④ s.toString()  --> 约等于 new String("ab"),但不等价

        补充:在jdk5.0之后使用的是StringBuilder,在jdk5.0之前使用的是StringBuffer
         */
    String s4 = s1 + s2;//
    System.out.println(s3 == s4);//false
}
/*
    1. 字符串拼接操作不一定使用的是StringBuilder!
       如果拼接符号左右两边都是字符串常量或常量引用,则仍然使用编译期优化,即非StringBuilder的方式。
    2. 针对于final修饰类、方法、基本数据类型、引用数据类型的量的结构时,能使用上final的时候建议使用上。
     */
@Test
public void test4(){
    final String s1 = "a";
    final String s2 = "b";
    String s3 = "ab";
    String s4 = s1 + s2;
    System.out.println(s3 == s4);//true
}

关于StringBuilder和String字符串拼接的效率问题

  1. 通过StringBuilder的append()的方式添加字符串的效率要远高于使用String的字符串拼接方式!
  2. 原因:
    1. StringBuilder的append()的方式:
      • 自始至终中只创建过一个StringBuilder的对象
    2. 使用String的字符串拼接方式:
      • 创建过多个StringBuilder和String(调的toString方法)的对象,内存占用更大;
      • 如果进行GC,需要花费额外的时间(在拼接的过程中产生的一些中间字符串可能永远也用不到,会产生大量垃圾字符串)。
  3. 改进的空间:
    • 在实际开发中,如果基本确定要前前后后添加的字符串长度不高于某个限定值highLevel的情况下,建议使用构造器实例化:
    • StringBuilder s = new StringBuilder(highLevel); //new char[highLevel]
    • 这样可以避免频繁扩容

三. intern()

3.1 基本介绍

public native String intern();
  1. intern是一个native方法,调用的是底层C的方法

  2. 字符串常量池池最初是空的,由String类私有地维护。在调用intern方法时,如果池中已经包含了由equals(object)方法确定的与该字符串内容相等的字符串,则返回池中的字符串地址。否则,该字符串对象将被添加到池中,并返回对该字符串对象的地址。(这是源码里的大概翻译)

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

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

     ("a"+"b"+"c").intern()=="abc"
    
  5. 通俗点讲,Interned String就是确保字符串在内存里只有一份拷贝,这样可以节约内存空间,加快字符串操作任务的执行速度。注意,这个值会被存放在字符串内部池(String Intern Pool)

3.2 关于new String()

new String(“ab”)会创建几个对象?

/**
 * 题目:
 * new String("ab")会创建几个对象?看字节码,就知道是两个。
 *     一个对象是:new关键字在堆空间创建的
 *     另一个对象是:字符串常量池中的对象"ab"。 字节码指令:ldc
 *
 */
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 <ab>
6 invokespecial #4 <java/lang/String.<init>>
9 astore_1
10 return

理解如下:

  1. new操作首先会创建一个字符串对象
  2. 由于"ab"是一个字面量,因此会先在字符串常量池中创建一份
  3. 此时str和"ab"虽然是两个对象,但其内部的char数组是同一个

new String(“a”) + new String(“b”) 会创建几个对象?

/**
 * 思考:
 * new String("a") + new String("b")呢?
 *  对象1:new StringBuilder()
 *  对象2: new String("a")
 *  对象3: 常量池中的"a"
 *  对象4: new String("b")
 *  对象5: 常量池中的"b"
 *
 *  深入剖析: StringBuilder的toString():
 *      对象6 :new String("ab")
 *       强调一下,toString()的调用,在字符串常量池中,没有生成"ab"
 *
 */
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.<init>>
7 new #4 <java/lang/String>
10 dup
11 ldc #5 <a>
13 invokespecial #6 <java/lang/String.<init>>
16 invokevirtual #7 <java/lang/StringBuilder.append>
19 new #4 <java/lang/String>
22 dup
23 ldc #8 <b>
25 invokespecial #6 <java/lang/String.<init>>
28 invokevirtual #7 <java/lang/StringBuilder.append>
31 invokevirtual #9 <java/lang/StringBuilder.toString>
34 astore_1
35 return

答案是4个或5个或6个

字节码指令分析:

  1. 0 new #2 <java/lang/StringBuilder> :拼接字符串会创建一个 StringBuilder 对象
  2. 7 new #4 <java/lang/String> :创建 String 对象,对应于 new String(“a”)
  3. 11 ldc #5 <a> :在字符串常量池中放入 “a”(如果之前字符串常量池中没有 “a” 的话)
  4. 19 new #4 <java/lang/String> :创建 String 对象,对应于 new String(“b”)
  5. 23 ldc #8 <b> :在字符串常量池中放入 “b”(如果之前字符串常量池中没有 “b” 的话)
  6. 31 invokevirtual #9 <java/lang/StringBuilder.toString> :调用 StringBuilder 的 toString() 方法,会生成一个 String 对象

3.3 面试题

**
 * 如何保证变量s指向的是字符串常量池中的数据呢?
 * 有两种方式:
 * 方式一: String s = "shkstart";//字面量定义的方式
 * 方式二: 调用intern()
 *         String s = new String("shkstart").intern();
 *         String s = new StringBuilder("shkstart").toString().intern();
 *
 */
public class StringIntern {
    public static void main(String[] args) {

        String s = new String("1");
        s.intern();//调用此方法之前,字符串常量池中已经存在了"1"
        String s2 = "1";
        System.out.println(s == s2);//jdk6:false   jdk7/8:false
        
        /*
         1、s3变量记录的地址为:new String("11")
         2、经过上面的分析,我们已经知道执行完pos_1的代码,在堆中有了一个new String("11")
         这样的String对象。但是在字符串常量池中没有"11"
         3、接着执行s3.intern(),在字符串常量池中生成"11"
           3-1、在JDK6的版本中,字符串常量池还在永久代,所以直接在永久代生成"11",也就有了新的地址
           3-2、而在JDK7的后续版本中,字符串常量池被移动到了堆中,此时堆里已经有new String("11")了
           出于节省空间的目的,直接将堆中的那个字符串的引用地址储存在字符串常量池中。没错,字符串常量池
           中存的是new String("11")在堆中的地址
         4、所以在JDK7后续版本中,s3和s4指向的完全是同一个地址。
         */
        String s3 = new String("1") + new String("1");//pos_1
        s3.intern();
        
        String s4 = "11";//s4变量记录的地址:使用的是上一行代码代码执行时,在常量池中生成的"11"的地址
        System.out.println(s3 == s4);//jdk6:false  jdk7/8:true
    }
}
/**
 * StringIntern.java中练习的拓展:
 *
 */
public class StringIntern1 {
    public static void main(String[] args) {
        //执行完下一行代码以后,字符串常量池中,是否存在"11"呢?答案:不存在!!
        String s3 = new String("1") + new String("1");//new String("11")
        //在字符串常量池中生成对象"11",代码顺序换一下,实打实的在字符串常量池里有一个"11"对象
        String s4 = "11";  
        String s5 = s3.intern();

        // s3 是堆中的 "ab" ,s4 是字符串常量池中的 "ab"
        System.out.println(s3 == s4);//false

        // s5 是从字符串常量池中取回来的引用,当然和 s4 相等
        System.out.println(s5 == s4);//true
    }
}

3.4 intern效率分析

/**
 * 使用intern()测试执行效率:空间使用上
 *
 * 结论:对于程序中大量存在存在的字符串,尤其其中存在很多重复字符串时,使用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++) {
//            arr[i] = new String(String.valueOf(data[i % data.length]));
            arr[i] = new String(String.valueOf(data[i % data.length])).intern();

        }
        long end = System.currentTimeMillis();
        System.out.println("花费的时间为:" + (end - start));

        try {
            Thread.sleep(1000000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.gc();
    }
}

1、直接 new String :由于每个 String 对象都是 new 出来的,所以程序需要维护大量存放在堆空间中的 String 实例,程序内存占用也会变高

arr[i] = new String(String.valueOf(data[i % data.length]));

2、使用 intern() 方法:由于数组中字符串的引用都指向字符串常量池中的字符串,所以程序需要维护的 String 对象更少,内存占用也更低

//调用了intern()方法使用了字符串常量池里的字符串,那么前面堆里的字符串便会被GC掉,这也是intern省内存的关键原因
arr[i] = new String(String.valueOf(data[i % data.length])).intern();

结论

  1. 对于程序中大量使用存在的字符串时,尤其存在很多已经重复的字符串时,使用intern()方法能够节省很大的内存空间。
  2. 大的网站平台,需要内存中存储大量的字符串。比如社交网站,很多人都存储:北京市、海淀区等信息。这时候如果字符串都调用intern() 方法,就会很明显降低内存的大小。

标题:08-字符串常量池
作者:mahaonan
地址:https://mahaonan.fun/articles/2022/07/18/1658147072057.html