深入理解java虚拟机课程的截图-3-宋红康老师

最新推荐文章于 2022-03-22 11:45:00 发布

风暴计划

最新推荐文章于 2022-03-22 11:45:00 发布

阅读量261

点赞数 1

分类专栏： JVM+JMM 文章标签： java jvm String面试题 String底层分析 String的intern方法

本文链接：https://blog.csdn.net/cmm0401/article/details/108898188

版权

JVM+JMM 专栏收录该内容

16 篇文章 0 订阅

订阅专栏

【来自B站宋红康老师的JVM视频：https://www.bilibili.com/video/BV1BJ41177cp?p=118】

【JDK6以及之前的JDK版本，静态变量和字符串常量池存储在方法区(永久代)中。JDK7以及之后的JDK版本，静态变量和字符串常量池存储在堆中，不是元空间中。字符串常量池是运行时常量池的一部分而已。】

【官方关于JDK每个版本的改动点：http://openjdk.java.net/jeps/0】

【JDK8及以前的JDK版本，String底层是final char[ ]型数组。JDK9及以后的JDK版本，String底层是final byte[ ]数组。】

package com.atguigu.java;
import org.junit.Test;
//String的基本使用:String代表不可变的字符序列，本测试主要 体现String的不可变性
public class StringTest1 {
    @Test
    public void test1() {
        String s1 = "abc";//字面量定义的方式，"abc"存储在字符串常量池中
        String s2 = "abc";
        s1 = "hello";
        System.out.println(s1 == s2);//判断地址：(1)true  --> (2)false
        System.out.println(s1); //hello
        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
    }
}

package com.atguigu.java;
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
    }
}

//(1)测试String底层数组长度的大小对String性能的影响。。。
package com.atguigu.java;
import java.io.FileWriter;
import java.io.IOException;
//产生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;
    }
}

//(2)测试String底层数组长度的大小对String性能的影响。。。
package com.atguigu.java;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
//分别设置，做测试：-XX:StringTableSize=1009。-XX:StringTableSize=100009。
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();
                }
            }
        }
    }
}

【为什么字符串常量池从永久代移到堆中？(1)永久代默认空间比较小，如果程序中有很多字符串，则容易产生OOM: PermGen。(2)永久代垃圾回收频率很低，这样的话，不再使用的字符串就不能及时回收了，就更容易产生OOM:PermGen。】

【java语言规范：https://docs.oracle.com/javase/specs/jls/se8/html/index.html】

package com.atguigu.java1;
import org.junit.Test;
import javax.annotation.processing.SupportedSourceVersion;
import java.sql.SQLOutput;
public class StringTest4 {
    public static void main(String[] args) {
        System.out.println();//代码执行到此时，字符串常量池中共有2293个字符串
        System.out.println("1");//2294个字符串
        System.out.println("2");//2295个字符串
        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个字符串(2304-2294=10个)
        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个字符串
    }
}

【重点，面试过程中可以有进一步的交流。哈哈】

【equals()方法判断的是字符串的值是否相等。== 判断的是两个字符串引用对否相等。】

【 s.toSring() ——> 约等于 new String("ab")：new String("ab") 代表着在堆中创建了一个字符串对象。【StringBuffer线程安全。StringBuilder线程不安全。】】

package com.atguigu.java1;
import org.junit.Test;
/**
 * 字符串拼接操作
 * @author shkstart  shkstart@126.com  @create 2020  0:59
 */
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);
    }
}

【注意：通过下面的字符串拼接测试案例 test6( ) ，得出如下结论：体会执行效率的问题：通过StringBuilder.append()方式拼接字符串的效率要远高于使用String字符串直接拼接( 即：str = "a"+"b" 这样的字符串直接拼接方式)的方式。详情分析如下：

（1）创建对象数量的角度看：

A：使用StringBuilder.append()的拼接方式：自始至终只创建了一个StringBuilder对象。

B：而使用String字符串直接拼接的方式：会循环创建很多个StringBuilder对象和String对象，要知道，创建对象是需要花费时间的，所以这种方式总体花费的时间会比较长，同时，因为对象很多，它们占用的堆内存空间也会很多。

（2）占用堆内存大小的角度与GC花费时间的角度：

使用String字符串直接拼接的方式：内存中由于创建了多个StringBuilder对象和String对象，一方面是内存占用更大，一方面是如果进行GC的话，则需要花费更多额外的时间。

（3）使用StringBuilder.append()的拼接方式，虽然比较好，但有没有改进空间呢？

有！怎么改呢？（通过底层源代码可以发现改进目标应该是：防止char型数组逐步扩容）在实际开发中，如果基本确定了前前后后需要添加字符串的长度不高于某个限定值highLever的情况下，建议使用构造器实例化：StringBuilder sb=new StringBuilder(highLever); // 意味着底层创建了一个char型数组：new char[highLever]; 】

【char 16位2个字节。byte 8位1个字节。short 16位2个字节。int 32位4个字节。long 64位8个字节。float 32位 4个字节。double 64位8个字节。】【javaSE官方文档：https://docs.oracle.com/javase/specs/jls/se8/html/index.html】

【下面这个截图需要掌握：如何保证变量s指向的是字符串常量池中的字符串数据呢？】

【题目1 字节码：new String("ab") ：对象1(new)是在堆中，对象2("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");//生成了2个对象:一个是在堆中，一个是在字符串常量池中
        s.intern();//调用此方法之前，字符串常量池中已经存在了"1"，所以该方法在这个位置被调用其实没啥作用
        String s2 = "1";
        System.out.println(s == s2);//jdk6：false。dk7/8：false。

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

package com.atguigu.java2;
public class StringIntern1 {
    public static void main(String[] args) {
        //StringIntern.java中练习的拓展：
        String s3 = new String("1") + new String("1");//new String("11")
        //执行完上一行代码以后，字符串常量池中，是否存在"11"呢？答案：不存在！！
        String s4 = "11";//实打实的在字符串常量池中生成字符串对象"11"，然后把该对象地址赋给s4。
        String s5 = s3.intern();//这句话跑在s4这句话后面了。首先会在字符串常量池中去查找是否存在字符串对象"11"，发现存在了，所以会把"11"这个字符串对象的地址赋给s5。
        System.out.println(s3 == s4);//false
        System.out.println(s5 == s4);//true
    }
}

【掌握下面这个总结】

package com.atguigu.java2;
//字符串面试题继续
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"，于是在字符串常量池中实打实的创建一个字符串对象"ab"，并把该对象地址赋给s2。
                               //jdk8中：首先会发现在字符串常量池中并没有字符串对象"ab"，于是创建一个引用，指向堆中的new String("ab")，并将此引用返回赋给s2(注意：此引用之前已经赋给了s。字符串常量池中没有创建字符串对象"ab")
        System.out.println(s2 == "ab");//jdk6:true。jdk8:true。
        System.out.println(s == "ab");//jdk6:false。jdk8:true。
    }
}

package com.atguigu.java2;
public class StringExer2 {
    public static void main(String[] args) {
        String s1 = new String("ab");//执行完以后，会在字符串常量池中会生成"ab"
//        String s1 = new String("a") + new String("b");//执行完以后，不会在字符串常量池中会生成"ab"
        s1.intern();
        String s2 = "ab";
        System.out.println(s1 == s2);//不管是什么JDK版本：第一行是false；第二行是true。
    }
}

package com.atguigu.java2;
import java.util.Random;
/**
 * 使用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();
    }
}

package com.atguigu.java3;
/**
 * String的垃圾回收:
 * -Xms15m -Xmx15m -XX:+PrintStringTableStatistics -XX:+PrintGCDetails
 */
public class StringGCTest {
    public static void main(String[] args) {
        //j=100，或者 j=100000，分别做测试去观察
        for (int j = 0; j < 100000; j++) {
            String.valueOf(j).intern();
        }
    }
}