JVM：StringTable

最新推荐文章于 2024-02-25 08:35:51 发布
最新推荐文章于 2024-02-25 08:35:51 发布
阅读量495 收藏 1
点赞数
分类专栏： JVM 文章标签： jvm StringTable itern方法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012068483/article/details/106914007
版权

文章目录

String基本特性

在这里插入图片描述

测试StringTableSize参数大小

/**
 *  -XX:StringTableSize=1009
 */
public class StringTest {
    public static void main(String[] args) {
        //测试StringTableSize参数
        System.out.println("暂停一会……");
        try {
            Thread.sleep(1000000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

在这里插入图片描述

在这里插入图片描述

/**
 * String的基本使用:体现String的不可变性
 *
 */
public class StringTest {
    @Test
    public void test1() {
        String s1 = "abc";//字面量定义的方式，"abc"存储在字符串常量池中
        String s2 = "abc";
        s1 = "hello";

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

        System.out.println(s1);//
        System.out.println(s2);//abc

    }

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

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

String的内存分配

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

StringTable为什么要调整？

  1. permSize默认比较小
  2. 永久代垃圾回收频率低
/**
 * jdk6中：
 * -XX:PermSize=6m -XX:MaxPermSize=6m -Xms6m -Xmx6m
 *
 * jdk8中：
 * -XX:MetaspaceSize=6m -XX:MaxMetaspaceSize=6m -Xms6m -Xmx6m
 */
public class StringTest3 {
    public static void main(String[] args) {
        //使用Set保持着常量池引用，避免full gc回收常量池行为
        Set<String> set = new HashSet<>();
        //在short可以取值的范围内足以让6MB的PermSize或heap产生OOM了。
        short i = 0;
        while(true){
            set.add(String.valueOf(i++).intern());
        }
    }
}

String的基本操作

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

public class StringTest {
    public static void main(String[] args) {
        System.out.println();//2293
        System.out.println("1");//2294
        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");//2303
        //如下的字符串"1" 到 "10"不会再次加载
        System.out.println("1");//2304
        System.out.println("2");//2304
        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");//2304
    }
}

class Memory {
    public static void main(String[] args) {//line 1
        int i = 1;//line 2
        Object obj = new Object();//line 3
        Memory mem = new Memory();//line 4
        mem.foo(obj);//line 5
    }//line 9

    private void foo(Object param) {//line 6
        String str = param.toString();//line 7
        System.out.println(str);
    }//line 8
}

在这里插入图片描述

字符串拼接操作

在这里插入图片描述

/**
 * 字符串拼接操作
 *
 */
public class StringTest5 {
    @Test
    public void test1() {
        String s1 = "a" + "b" + "c";//编译期优化：等同于"abc"
        String s2 = "abc"; //"abc"一定是放在字符串常量池中，将此地址赋给s2
        /*
         * 最终.java编译成.class,再执行.class
         * String s1 = "abc";
         * String s2 = "abc"
         */
        System.out.println(s1 == s2); //true
        System.out.println(s1.equals(s2)); //true
    }

    @Test
    public void test2() {
        String s1 = "javaEE";
        String s2 = "hadoop";

        String s3 = "javaEEhadoop";
        String s4 = "javaEE" + "hadoop";//编译期优化
        //如果拼接符号的前后出现了变量，则相当于在堆空间中new String()，具体的内容为拼接的结果：javaEEhadoop
        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
        //intern():判断字符串常量池中是否存在javaEEhadoop值，如果存在，则返回常量池中javaEEhadoop的地址；
        //如果字符串常量池中不存在javaEEhadoop，则在常量池中加载一份javaEEhadoop，并返回次对象的地址。
        String s8 = s6.intern();
        System.out.println(s3 == s8);//true
    }

    @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
    }

    @Test
    public void test5() {
        String s1 = "javaEEhadoop";
        String s2 = "javaEE";
        String s3 = s2 + "hadoop";
        System.out.println(s1 == s3);//false

        final String s4 = "javaEE";//s4:常量
        String s5 = s4 + "hadoop";
        System.out.println(s1 == s5);//true

    }

    /*
    体会执行效率：通过StringBuilder的append()的方式添加字符串的效率要远高于使用String的字符串拼接方式！
    详情：① StringBuilder的append()的方式：自始至终中只创建过一个StringBuilder的对象
          使用String的字符串拼接方式：创建过多个StringBuilder和String的对象
         ② 使用String的字符串拼接方式：内存中由于创建了较多的StringBuilder和String的对象，内存占用更大；如果进行GC，需要花费额外的时间。

     改进的空间：在实际开发中，如果基本确定要前前后后添加的字符串长度不高于某个限定值highLevel的情况下,建议使用构造器实例化：
               StringBuilder s = new StringBuilder(highLevel);//new char[highLevel]
     */
    @Test
    public void test6() {

        long start = System.currentTimeMillis();

//        method1(100000);//4014
        method2(100000);//7

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

    public void method1(int highLevel) {
        String src = "";
        for (int i = 0; i < highLevel; i++) {
            src = src + "a";//每次循环都会创建一个StringBuilder、String
        }
//        System.out.println(src);

    }

    public void method2(int highLevel) {
        //只需要创建一个StringBuilder
        StringBuilder src = new StringBuilder();
        for (int i = 0; i < highLevel; i++) {
            src.append("a");
        }
//        System.out.println(src);
    }
}

intern()的使用

在这里插入图片描述

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

new String(“ab”)会创建几个对象？看字节码，就知道是两个。

  • 一个对象是：new关键字在堆空间创建的
  • 另一个对象是：字符串常量池中的对象"ab"。 字节码指令：ldc

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

  1. 对象1：new StringBuilder()

  2. 对象2： new String(“a”)

  3. 对象3： 常量池中的"a"

  4. 对象4： new String(“b”)

  5. 对象5： 常量池中的"b"

  6. 深入剖析： StringBuilder的toString():

  7. 对象6 ：new String(“ab”)

    强调一下，toString()的调用，在字符串常量池中，没有生成"ab"

在这里插入图片描述

/**
 * 如何保证变量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


        String s3 = new String("1") + new String("1");//s3变量记录的地址为：new String("11")
        //执行完上一行代码以后，字符串常量池中，是否存在"11"呢？答案：不存在！！
        s3.intern();//在字符串常量池中生成"11"。
        //如何理解：jdk6:创建了一个新的对象"11",也就有新的地址。
        //         jdk7:此时常量中并没有创建"11",而是创建一个指向堆空间中new String("11")的地址
        String s4 = "11";//s4变量记录的地址：使用的是上一行代码代码执行时，在常量池中生成的"11"的地址
        System.out.println(s3 == s4);//jdk6：false  jdk7/8：true
    }
}

itern()在JDK6中的使用场景

在这里插入图片描述

itern()在JDK7/8中的使用场景

在这里插入图片描述

拓展题

public class StringIntern1 {
    public static void main(String[] args) {
        String s3 = new String("1") + new String("1");//new String("11")
        //执行完上一行代码以后，字符串常量池中，是否存在"11"呢？答案：不存在！！
        String s4 = "11";//在字符串常量池中生成对象"11"
        String s5 = s3.intern();
        System.out.println(s3 == s4);//false
        System.out.println(s5 == s4);//true
    }
}

public class StringExer1 {
    public static void main(String[] args) {
        String s = new String("a") + new String("b");//new String("ab")
        //在上一行代码执行完以后，字符串常量池中并没有"ab"

        String s2 = s.intern();//jdk6中：在串池中创建一个字符串"ab"
        //jdk8中：串池中没有创建字符串"ab",而是创建一个引用，指向new String("ab")，将此引用返回

        System.out.println(s2 == "ab");//jdk6:true  jdk8:true
        System.out.println(s == "ab");//jdk6:false  jdk8:true
    }
}

在这里插入图片描述

public class StringExer2 {
    public static void main(String[] args) {
//        String s1 = new String("ab");//执行完以后，会在字符串常量池中会生成"ab"
        String s = new String("a") + new String("b");//执行完以后，不会在字符串常量池中会生成"ab"
        s.intern();
        String s2 = "ab";
        System.out.println(s == s2);//true
    }
}

在这里插入图片描述

public class StringExer1 {
    public static void main(String[] args) {
        String x = "ab";
        String s = new String("a") + new String("b");//new String("ab")
        //在上一行代码执行完以后，字符串常量池中并没有"ab"

        String s2 = s.intern();//jdk6中：在串池中创建一个字符串"ab"
                               //jdk8中：串池中没有创建字符串"ab",而是创建一个引用，指向new String("ab")，将此引用返回

        System.out.println(s2 == "ab");//jdk6:true  jdk8:true
        System.out.println(s == "ab");//jdk6:false  jdk8:false
    }
}

在这里插入图片描述

使用intern()测试执行效率：空间使用上

  • 结论：对于程序中大量存在存在的字符串，尤其其中存在很多重复字符串时，使用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();
    }
}

在大的网站平台中，需要内存中存储大量的字符串。比如社交网站，很多人都存储：XX市、XX区等信息。这时候如果字符串都调用intern()方法，就会明显降低内存的大小。

小结

总结String的intern()的使用

  • JDK1.6中，将这个字符串对象尝试放入字符串常量池
    • 如果字符串常量池中有，则并不会放入，返回已有的字符串常量池对象的地址
    • 如果没有，会把此对象复制一份，放入字符串常量池，并返回字符串常量池中的对象地址
  • JDK1.7起，将这个字符串对象尝试放入字符串常量池
    • 如果字符串常量池中有，则并不会放入，返回已有的字符串常量池对象的地址
    • 如果没有，则会把对象的引用地址复制一份，放入字符串常量池，并返回字符串常量池中的引用地址

StringTable的垃圾回收

String的垃圾回收示例

/**
 * String的垃圾回收:
 * -Xms15m -Xmx15m -XX:+PrintStringTableStatistics -XX:+PrintGCDetails
 *
 */
public class StringGCTest {
    public static void main(String[] args) {
        for (int j = 0; j < 100000; j++) {
            String.valueOf(j).intern();
        }
    }
}

在这里插入图片描述

G1中的String去重操作

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

慢就是【快】
关注
专栏目录
【硬刚JVM】JVM 专题十六：StringTable
微信搜：import_bigdata，大数据领域硬核原创作者
09-25 278
本文是对《【硬刚大数据之学习路线篇】从零到大数据专家的学习指南(全面升级版)》的JVM部分补充。 1. String的基本特性 1.String：字符串，使用一对""引起来表示。 2.String声明为final的，不可被继承。 3.String实现了Serializable接口：表示字符串是支持序列化的。实现了Comparable接口：表示String可以比较大小。 4.String在jdk8及以前内部定义了final char[] value用于存储字符串数据。jdk9时改为byte[
StringTable详解
勇心在馨
07-19 1734
一、存储结构 jdk8及以前String底层使用char[]，一个char是两个字节，jdk9开始改用byte[]加上编码标记节约空间。 jdk9官网提供的String修改说明：http://openjdk.java.net/jeps/254 修改动机： 二、不可变性 1、当对字符串重新赋值时，需要重写指定内存区域赋值 2、当对现有字符串进行连接操作时，也需要重新指定内存区域。 3、调用String的replace方法时修改指定字符串或者字符时，也需要重新指定内存区域赋值。 4.
StringTable（字符串常量池）
qq_44346427的博客
04-07 487
StringTable（字符串常量池） String的基本特性 String：字符串，使用一对 “” 引起来表示 String s1 = "chinese";// 字面量的定义方式 String s2 = new String("hello");// new 对象的方式 String被声明为final的，不可被继承 String实现了Serializable接口：表示字符串是支持序列化的。实现了Comparable接口：表示String可以比较大小 String在jdk8及以前内部定义了
String Table
帅枫的博客
01-25 227
String Table 一、String的基本特征 一、String的基本特征 String：字符串，使用一对“ “ 引起来表示。 String声明为final的，不可被继承。 String 实现了Serializable：表示字符串是支持序列化的。实现了Comparable接口：表示String可以比较大小。 String在jdk8及之前内部定义了final char[] value用于存储字符串数据。jdk9时改为了byte[]。 二、String在jdk9中存储结构变更 结论：String再也
尚硅谷JVM从入门到精通宋红康版|第十三章、StringTable
weixin_45759791的博客
07-13 748
StringTable String的基本特性 String：字符串，使用一对 ”” 引起来表示 String s1 = “mogublog” ; // 字面量的定义方式 String s2 = new String(“moxi”); string声明为final的，不可被继承 String实现了Serializable接口：表示字符串是支持序列化的。实现了Comparable接口：表示string可以比较大小 string在jdk8及以前内部定义了final char[] value用于存储
JVM——StringTable
qq_52025570的博客
03-12 912
JVM——StringTable
13-StringTable
海涛帅帅的博客
09-28 193
String的基本特性 String: 字符串，使用一对""引起来表示。 String s1 = “atguigu”; // 字面量的定义方式 String s2 = new String(“hello”); String 声明为final的，不可被继承 String 实现了Serializable 接口：表示字符串是支持序列化的。 实现了Comparable 接口：表示String可比较大小 String在jdk8 及以前内部定义了final char[] value 用于存储字符串数
JVM系列之String.intern的性能解析
08-19
在Java虚拟机（JVM）中，`String.intern()` 是一个非常特殊且重要的方法，它与字符串常量池紧密相关。字符串常量池是一种内存优化机制，存储了程序中所有的字符串字面值和通过 `intern()` 方法添加的字符串。这个池...
jvm StringTable
07-25
JVM的StringTable是用于存储字符串常量的数据结构。在JVM中，字符串常量是指在代码中直接使用双引号括起来的字符串。 StringTable是一个哈希表，用于实现字符串常量的唯一性。它的作用是避免在内存中重复存储相同的...
StringTable.pdf
03-11
《深入理解JVM中的StringTable》 在Java虚拟机（JVM）中，StringTable扮演着至关重要的角色，它是字符串常量池的实现，存放着程序中所有的字符串字面量。本文将详细探讨StringTable的原理、特点以及相关优化策略。 ...
【JVM】StringTable 字符串常量池
最新发布
2301_77899321的博客
02-25 969
使用字符串常量池可以提高字符串的比较效率，并且在一些特定场景下可以节省内存空间。但是需要注意，过度使用字符串常量池可能会导致内存泄漏或者占用过多的内存，因为字符串常量池中的字符串对象是不可回收的。
JVM -- StringTable
weixin_58104242的博客
02-22 459
常量池最初存在于字节码文件中，在运行时被加载到运行时常量池中，其中a，b等就仅仅是常量池中的符号，还未变成Java中的字符串对象。等到执行到引用这个字符串的代码，才会变成字符串对象 。 执行 ldc #2 会把 a 符号变为“a”字符串对象 执行 ldc #3 会把 b 符号变为“b”字符串对象 创建的过程中，会先到StringTable中找，如果有就共用，没有再创建 StringTable是一个 HashTable 结构，不能扩容 public class StringTableStudy {
JVM——String Table
xiangqian0721的博客
08-08 345
JVM——String Table字符串常量池 String table又称为String pool，字符串常量池，其存在于堆中(jdk1.7之后改的)。最重要的一点，String table中存储的并不是String类型的对象，存储的而是指向String对象的索引，真实对象还是存储在堆中。 先看几道经典面试题： String s1 = "a"; //在常量池中 String s2 = "b"; //在常量池中 String s3 = "a" + "b"; //在常量池中 St
jvm-StringTable详解
itman_cx的博客
04-02 459
参考 尚硅谷：宋红康（b站视频） 一、String的基本特性 1.1 字符串特征 字符串，用""引起来表示 String s1 = “mogublog” ; // 字面量的定义方式，声明在字符串常量池 String s2 = new String(“moxi”); // new 对象的方式 声明为final的不可被继承的 实现了Serializable接口，表示支持序列化 实现了Comparable接口，表示可以比较大小 1.2 jdk里面的String存储变化 jdk8及以前，内部定义了
JVM-StringTable
weixin_43424751的博客
07-18 200
一，String的基本特性 String：字符串，使用一对" "引起来表示。 String声明为final的，不可被继承 String实现了Serializable接口：表示字符串是支持序列化的。 实现了Comparable接口：表示String可以比较大小 String在jdk8及以前内部定义了final char[] value用于存储字符串数据。jdk9时改为byte[] jdk9将String的底层实现由char[]改成了byte[] 因为char类型的数据在jvm中占用了两个字
jvm之String Table
tong_yerui的博客
08-21 136
1.String的基本特性 String：字符串，使用一对" "引起表示，String声明为final的，不可被继承，实现了Serializable接口，表示支持字符串被序列化，在jdk8及以前内部定义了final char[] value用于存储字符串数据。jdk9时改为byte[]。 String代表不可变的字符序列，简称不可变性，当字符串重新赋值时，需要重写指定内存区域赋值，不能使用有value进行赋值，当对现有的字符串进行操作时，也需要重新指定内存赋值，不能使用原有的value进行赋值。当调用S
JVM篇-StringTable
shuyoujing的博客
08-02 190
String的基本特性 String 字符串，使用一对 “” 表示 String s1=“AA”;//字面量定义 String s2=new String("AA“”); String 声明为final的不可被继承 String 实现了Serializable接口，表示是字符串是支持序列化的，实现Comparable接口表示：String可以比较大小 String在JDK8及以前内部定义了final char[] value用于存储字符串数据，jdk9改为byte[] String 代表不可变的是字
jvm之StringTable（字符串常量池）
花&败
10-05 345
1、String的基本特性 String：字符串，使用一对 “” 引起来表示 String s1 = "atguigu" ; // 字面量的定义方式 String s2 = new String("hello"); // new 对象的方式 String被声明为final的，不可被继承 String实现了Serializable接口：表示字符串是支持序列化的。实现了Comparable接口：表示String可以比较大小 String在jdk8及以前内部定义了final c
JVM 虚拟机中StringTable
qq_40990836的博客
06-14 204
String 的基本特性 String字符串，使用一对 '" 引起来表示 String s1 = “str”； // 字面量的定义方式、 String s2 = new String(“hello”); String 声明为 final的 不可以被继承 String 实现了 Serializable 接口： 表示字符串是支持序列化的，实现了Comparable 接口，表示String 可以比较大小 String 在 jdk 8 级以前内部定义了 final char[] value 用于存储字符串数
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值