StringTable（字符串常量池）

最新推荐文章于 2023-12-01 10:18:16 发布

VIP文章小刘你最强

最新推荐文章于 2023-12-01 10:18:16 发布

阅读量445

点赞数 1

分类专栏： JVM

本文链接：https://blog.csdn.net/qq_44346427/article/details/115486583

版权

StringTable（字符串常量池）

String的基本特性

String：字符串，使用一对 “” 引起来表示

String s1 = "chinese";// 字面量的定义方式
String s2 =  new String("hello");// new 对象的方式

String被声明为final的，不可被继承
String实现了Serializable接口：表示字符串是支持序列化的。实现了Comparable接口：表示String可以比较大小
String在jdk8及以前内部定义了final char value[]用于存储字符串数据。JDK9时改为byte[]

为什么 JDK9 改变了 String 的结构

官方文档：http://openjdk.java.net/jeps/254

Motivation

The current implementation of the String class stores characters in a char array, using two bytes (sixteen bits) for each character. Data gathered from many different applications indicates that strings are a major component of heap usage and, moreover, that most String objects contain only Latin-1 characters. Such characters require only one byte of storage, hence half of the space in the internal char arrays of such String objects is going unused.

Description

**We propose to change the internal representation of the String class from a UTF-16 char array to a byte array plus an encoding-flag field. **The new String class will store characters encoded either as ISO-8859-1/Latin-1 (one byte per character), or as UTF-16 (two bytes per character), based upon the contents of the string. The encoding flag will indicate which encoding is used.

为什么改为 byte[] 存储？

String类的当前实现将字符存储在char数组中，每个字符使用两个字节(16位)。
从许多不同的应用程序收集的数据表明，字符串是堆使用的主要组成部分，而且大多数字符串对象只包含拉丁字符（Latin-1）。这些字符只需要一个字节的存储空间，因此这些字符串对象的内部char数组中有一半的空间将不会使用，产生了大量浪费。
之前 String 类使用 UTF-16 的 char[] 数组存储，现在改为 byte[] 数组外加一个编码标识存储。该编码表示如果你的字符是ISO-8859-1或者Latin-1，那么只需要一个字节存。如果你是其它字符集，比如UTF-8，你仍然用两个字节存
结论：String再也不用char[] 来存储了，改成了byte [] 加上编码标记，节约了一些空间
同时基于String的数据结构，例如StringBuffer和StringBuilder也同样做了修改

//jdk 8
private final char value[];
//jdk 9
private final byte[] value;

String 的基本特性

String：代表不可变的字符序列。简称：不可变性。

当对字符串重新赋值时，需要重写指定内存区域赋值，不能使用原有的value进行赋值。
当对现有的字符串进行连接操作时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值。
当调用String的replace()方法修改指定字符或字符串时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值。

通过字面量的方式（区别于new）给一个字符串赋值，此时的字符串值声明在字符串常量池中。

当对字符串重新赋值时，需要重写指定内存区域赋值，不能使用原有的value进行赋值

代码

	@Test
    public void test1() {
   
        String s1 = "abc";//字面量定义的方式，"abc"存储在字符串常量池中
        String s2 = "abc";
        s1 = "hello";

        System.out.println(s1 == s2);//判断地址：true  --> false

        System.out.println(s1);//abc --> hello
        System.out.println(s2);//abc

    }

字节码指令

取字符串 “abc” 时，使用的是同一个符号引用：#2
取字符串 “hello” 时，使用的是另一个符号引用：#3

当对现有的字符串进行连接操作时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值

	@Test
    public void test2() {
   
        String s1 = "abc";
        String s2 = "abc";
        s2 += "def";
        System.out.println(s2);//abcdef
        System.out.println(s1);//abc
    }

当调用string的replace()方法修改指定字符或字符串时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值

@Test
public void test3() {
   
    String s1 = "abc";
    String s2 = s1.replace('a', 'm');
    System.out.println(s1);//abc
    System.out.println(s2);//mbc
}

一道笔试题

public class StringExer {
   
    String str = new String("good");
    char[] ch = {
   't', 'e', 's', 't'};

    public void change(String str, char ch[]) {
   
        str = "test ok";
        ch[0] = 'b';
    }

    public static void main(String[] args) {
   
        StringExer ex = new StringExer();
        ex.change(ex.str, ex.ch);
        System.out.println(ex.str);//good
        System.out.println(ex.ch);//best
    }
}

str 的内容并没有变：“test ok” 位于字符串常量池中的另一个区域（地址），进行赋值操作并没有修改原来 str 指向的引用的内容

String 的底层结构

字符串常量池是不会存储相同内容的字符串的

String的String Pool（字符串常量池）是一个固定大小的Hashtable，默认值大小长度是1009。如果放进String Pool的String非常多，就会造成Hash冲突严重，从而导致链表会很长，而链表长了后直接会造成的影响就是当调用String.intern()方法时性能会大幅下降
使用-XX:StringTablesize可设置StringTable的长度
在JDK6中StringTable是固定的，就是1009的长度，所以如果常量池中的字符串过多就会导致效率下降很快，StringTablesize设置没有要求
在JDK7中，StringTable的长度默认值是60013，StringTablesize设置没有要求
在JDK8中，StringTable的长度默认值是60013，StringTable可以设置的最小值为1009

测试不同 StringTable 长度下，程序的性能

代码：

/**
 * 产生10万个长度不超过10的字符串，包含a-z,A-Z
 */
public class GenerateString {
   
    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));//1009:143ms  100009:47ms
        } catch (IOException e) {
   
            e.printStackTrace();
        } finally {
   
            if(br != null){
   
                try {
   
                    br.close();
                } catch (IOException e) {
   
                    e.printStackTrace();
                }

            }
        }
    }
}

-XX:StringTableSize=1009 ：程序耗时 143ms
-XX:StringTableSize=100009 ：程序耗时 47ms

String 的内存分配

在Java语言中有8种基本数据类型和一种比较特殊的类型String。这些类型为了使它们在运行过程中速度更快、更节省内存，都提供了一种常量池的概念。
常量池就类似一个Java系统级别提供的缓存。8种基本数据类型的常量池都是系统协调的，String类型的常量池比较特殊。它的主要使用方法有两种。
- 直接使用双引号声明出来的String对象会直接存储在常量池中。比如：String info="atguigu.com";
- 如果不是用双引号声明的String对象，可以使用String提供的intern()方法。这个后面重点谈
Java 6及以前，字符串常量池存放在永久代
Java 7中 Oracle的工程师对字符串池的逻辑做了很大的改变，即将字符串常量池的位置调整到Java堆内
- 所有的字符串都保存在堆（Heap）中，和其他普通对象一样，这样可以让你在进行调优应用时仅需要调整堆大小就可以了。
- 字符串常量池概念原本使用得比较多，但是这个改动使得我们有足够的理由让我们重新考虑在Java 7中使用String.intern()。
Java8元空间，字符串常量在堆

StringTable 为什么要调整？

官方文档：https://www.oracle.com/java/technologies/javase/jdk7-relnotes.html#jdk7changes

为什么要调整位置？
- 永久代的默认空间大小比较小
- 永久代垃圾回收频率低，大量的字符串无法及时回收，容易进行Full GC产生STW或者容易产生OOM：PermGen Space
- 堆中空间足够大，字符串可被及时回收
在JDK 7中，interned字符串不再在Java堆的永久代中分配，而是在Java堆的主要部分（称为年轻代和年老代）中分配，与应用程序创建的其他对象一起分配。
此更改将导致驻留在主Java堆中的数据更多，驻留在永久生成中的数据更少，因此可能需要调整堆大小。

代码示例

/**
 * jdk6中：
 * -XX:PermSize=6m -XX:MaxPermSize=6m -Xms6m -Xmx6m
 *
 * jdk8中：
 * -XX:MetaspaceSize=6m -XX:MaxMetaspaceSize&#

最低0.47元/天解锁文章

小刘你最强

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
4
评论
StringTable（字符串常量池）

StringTable（字符串常量池）String的基本特性String：字符串，使用一对 “” 引起来表示String s1 = "chinese";// 字面量的定义方式String s2 = new String("hello");// new 对象的方式String被声明为final的，不可被继承String实现了Serializable接口：表示字符串是支持序列化的。实现了Comparable接口：表示String可以比较大小String在jdk8及以前内部定义了
复制链接

扫一扫