笔试题-String字符串创建对象的数量

待我称王封你为后i 2024-03-25 00:28 2阅读 0赞

package com.xch.test02;
    
    /**
     * 笔试题复盘
     * String字符串创建对象的数量
     * 
     * 其中，
     * 1、常量池ConstantPool对象在程序运行时就会在堆中，会带有一些启动环境的常量
     * 2、常量池中可以有多种常量，如：String、Integer、Character…
     * 3、堆中对象往往只有一份，其它均为地址引用存储，其本身也有内存地址
     * 4、本测试中仅讨论堆中内存对象，均基于常量池没有该字符串
     * 
     * 验证对象地址方法：
     * 1、没有重写toString方法的对象，可以直接输出对象根源地址
     * 2、通过debug即可看到根源对象地址，可以判断最终指向是否同一个对象
     * 3、通过==比较的是桟指向的第一个堆对象地址(堆中的对象会继续存储引用地址，其本身也有地址暴露被引用)，可以间接推理
     * 
     * @author Chenghe Xu
     * @date 2022/10/7 22:35
     */
    public class StringTest {
    
        public static void main(String[] args) {
            String str1="a"+"b"+"c";
            /**
             * 该str1语句会创建
             * 一个字符串对象"abc"到常量池
             * 
             * 原因：通过编译为.class文件时，会优化语句，如：常量折叠、清除注释…
             */
            String str11="abc";
            System.out.println(str1==str11);
            
            String str2=new String("bcd");
            /**
             * 该str2语句会创建
             * 一个字符串对象"bcd"到常量池
             * 一个对象new String("bcd")到堆内存(对象存储的是常量池中"bcd"的引用地址)
             * 
             * 原因：String的构造函数为String字符串
             */
            String str22="bcd";
            System.out.println(str2==str22);
            
            String str3=new String("cde")+"def";
            /**
             * 该str3语句会创建
             * 一个字符串对象"cde"到常量池
             * 一个字符串对象"def"到常量池
             * 一个对象new String("cde")到堆内存(对象存储的是常量池中"cde"的引用地址)
             * 一个对象new String("cde")+"def"到堆内存(对象存储的是new String("cde")的引用地址+常量池中"def"的引用地址)
             */
            String str33="cdedef";
            System.out.println(str3==str33);
            
            String s4="efg",s44="fgh";
            String str4=s4+s44;
            /**
             * 该str4语句会创建
             * 一个字符串对象"efg"到常量池
             * 一个字符串对象"fgh"到常量池
             * 一个对象s4+s44到堆内存(对象存储的是常量池中"efg"的引用地址+常量池中"fgh"的引用地址)
             */
            String str44="efgfgh";
            System.out.println(str4==str44);
    
            String s5="ghi";
            String str5= s5+"hij";
            /**
             * 该str5语句会创建
             * 一个字符串对象"hij"到常量池
             * 一个对象s5+"hij"到堆内存(对象存储的是常量池中"ghi"的引用地址+常量池中"hij"的引用地址)
             */
            String str55="ghihij";
            System.out.println(str5==str55);
            
            String s6="hijk";
            String str6=s6.substring(1)+"jkl";
            /**
             * 该str6语句会创建
             * 一个字符串对象"jkl"到常量池
             * 一个对象new byte[3]到堆内存(对象存储的是数组值)
             * 一个对象new String(new byte[]{105,106,107})到堆内存(对象存储的是new byte[]{105,106,107}的引用地址)
             * 一个对象new String(new byte[]{105,106,107})+"jkl"到堆内存(对象存储的是new String(new byte[]{105,106,107})的引用地址+常量池中"jkl"的引用地址)
             * 
             * 原因：s6.substring(1)执行的底层代码有多个new语句
             */
            String str66="ijkjkl";
            System.out.println(str6==str66);
    
            int[] arr1={123,123,123};
            /**
             * 该arr1语句会创建
             * 一个数组对象new int[]{123,123,123}到堆内存(对象存储的是数组值)
             */
            int[] arr11={123,123,123};
            System.out.println(arr1==arr11);
            
            int[] arr2=new int[]{123,123,123,123};
            /**
             * 该arr2语句会创建
             * 一个数组对象new int[]{123,123,123}到堆内存(对象存储的是数组值)
             */
            int[] arr22=new int[]{123,123,123};
            System.out.println(arr2==arr22);
            
            Integer[] arr3={123,123,123};
            /**
             * 该arr3语句会创建
             * 一个整型对象123到常量池
             * 一个数组对象new Integer[]{123,123,123}到堆内存(对象存储的是常量池中123的引用地址)
             */
            Integer[] arr33={123,123,123};
            System.out.println(arr3==arr33);
            
        }
    
    }