Java基础底层-String类基础

爱被打了一巴掌 2022-12-22 11:17 126阅读 0赞

## 一、概念 ##

String是所有语言中最常用的一个类；是不可变的，是最终类（final），最终类不能被继承。  
**核心特点** 对String对象的任何改变都不影响到原对象，相关的任何操作都会生成新的对象

## 二、声明方式 ##

![在这里插入图片描述][20201120090249614.png_pic_center]

### 2.1 指令码分析 ###

*  [指令码查看方式][Link 1]
 *  [字节码解释 ][Link 2]

#### 2.1.1 直接赋值 ####

在编译期间，会将等号右边的abc常量放入常量池（ldc），在程序运行时，会将str1变量压栈，栈中的str1变量直接指向字符串常量池的abc项，没有经过堆内存  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0h1YW5nMTE3ODM4Nzg0OA_size_16_color_FFFFFF_t_70_pic_center]

#### 2.1.2构造方法实现实例化 ####

在编译期间，会将等号右边的abc常量放入常量池，在程序运行时，现在堆中创建一个String对象，该对象的内容指向常量池中“abc”项，然后将str2变量压栈（如图所示）  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0h1YW5nMTE3ODM4Nzg0OA_size_16_color_FFFFFF_t_70_pic_center 1]

### 2.2 图解 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0h1YW5nMTE3ODM4Nzg0OA_size_16_color_FFFFFF_t_70_pic_center 2]

## 三、String对象为什么不可变 ##

### 3.1demo代码层面 ###

*  demo代码

String str = "abc";
            String str1 = "abc";
            System.out.println("str="+str);
            System.out.println("str的地址="+System.identityHashCode(str));
            System.out.println("str1的地址="+System.identityHashCode(str1));
            System.out.println("对str值进行修改之后");
            str = str + "ABC";
            System.out.println("str="+str);
            System.out.println("str的地址="+System.identityHashCode(str));
            System.out.println("str1的地址="+System.identityHashCode(str1));
            str.replace("b","B");

*  运行结果

str=abc
    str的地址=1639705018
    str1的地址=1639705018
    对str值进行修改之后
    str=abcABC
    str的地址=1627674070
    str1的地址=1639705018

*  解释：  
    str1 从开始到最后都没有改变，指向常量池中的值一直不变；str从刚开始是“abc”，到最后的“abcABC”，虽然表面是对变量str进行了修改，但是通过运行结果可以知道，地址发生了改变。此处实际上是重新创建了一个“abcABC”的对象，让str重新指向了这个值；而原先的“abc”一直没变。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0h1YW5nMTE3ODM4Nzg0OA_size_16_color_FFFFFF_t_70_pic_center 3]

### 3.2源码层面（jdk7之后） ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0h1YW5nMTE3ODM4Nzg0OA_size_16_color_FFFFFF_t_70_pic_center 4]  
从上述代码知，在java中String类其实就是对字符数组的封装。在jdk7中，只有一个value变量，也就是value中所有的字符都属于String这个对象。在java中，数组实际上只是一个引用，它指向一个真正的数组对象，也就是如下布局（数组是对象，此处的value实际上是指向对象的一个引用而已）  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0h1YW5nMTE3ODM4Nzg0OA_size_16_color_FFFFFF_t_70_pic_center 5]  
value这个变量是private的，也没有提供对应的set方法，所以String类的外部无法修改String，也就是说String一旦初始化就不能被修改。  
此外这个变量是final的类型，也就是说在String类的内部，一旦变量初始化了，也不能被修改。所以可以认为String对象不可变。

#### replace，substring等方法解释 ####

源码中存在一些方法，调用后可以得到改变后的值（replace，replaceAll，toLowerCase等）；通过源码可以知道，这些值表面上改变了，实际上方法内部创建了一个新的String对象并把这些对象重新赋值给当前的引用。

## 四、String对象真的不可变 ##

> 由上可知，String的成员变量都是用private final修饰的，初始化后不可以改变。但是value比较特殊，它是一个引用变量，并不是真正的对象。value是final修饰的，也就是说value不能再指向其他数组对象，但我们可以改变value指向的数组中的值。  
> 使用普通的代码无法做到，因为我们不能访问到value的引用，更不能通过引用去修改数组。我们可以使用反射访问私有成员，进而改变value所指向数组的结构

*  代码demo演示

public static void main(String[] args) throws Exception { 
    
            //创建字符串"Hello World"， 并赋给引用s
            String s = "Hello World";
    
            System.out.println("s = " + s); //Hello World
            System.out.println("修改前的str的内存地址" + System.identityHashCode(s));
    
            //获取String类中的value字段
            Field valueFieldOfString = String.class.getDeclaredField("value");
    
            //改变value属性的访问权限
            valueFieldOfString.setAccessible(true);
    
            //获取s对象上的value属性的值
            char[] value = (char[]) valueFieldOfString.get(s);
    
            //改变value所引用的数组中的第5个字符
            value[5] = '_';
    
            System.out.println("s = " + s);  //Hello_World
            System.out.println("修改前的str的内存地址" + System.identityHashCode(s));
    
        }

*  运行结果

s = Hello World
    修改前的str的内存地址1639705018
    s = Hello_World
    修改前的str的内存地址1639705018

*  结论：  
    通过反射是可以实现修改String值的同时而不改变String的地址，实现真正意义上的修改

## 五 、常量池和堆（intern） ##

> 常量池和堆的区别如上的声明方式  
> 字符串常量池： 属于堆内存中的一部分，是存放字符串常量的地方  
> 堆内存： 创建对象的操作都会经过堆内存，堆中的对象都会指向字符串常量池中的值；  
> 区别：实际上使用赋值和构造方法实现实例化两个操作都是指向常量池中的值，但是构造的变量是指向堆中的对象，堆中的对象在指向常量池中的值。  
> intern方法：主要的作用是先在常量池中找是否有对应的常量，如果有则返回该常量的地址，如果没有则创建新的常量值然后返回该常量的地址；即通过intern方法获取的变量所指向的地址就是常量池中的地址

*  demo代码演示

/** * str5 在编译后会直接去常量池中str3的值和地址 * str4 和str6 都是 在堆中创建一个新的对象 * @param args */
        public static void main(String[] args) { 
                String str1 = "a";
                String str2 = "b";
                String str3 = "ab";
                String str4 = str1 + str2;
                String str5 = "a"+"b";
                String str6 = new String("ab");
    
                System.out.println(str3==str5);
                System.out.println(str3==str4);
                System.out.println(str5==str4);
    
                System.out.println(str3==str6);
                System.out.println(str4==str6);
    
                /** * intern 引用常量池中与value相等的常量地址，没有则新增value到常量池中然后引用该地址 */
                System.out.println(str4.intern() == str5);
                System.out.println(str6.intern() == str3);
        }

*  运行结果  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0h1YW5nMTE3ODM4Nzg0OA_size_16_color_FFFFFF_t_70_pic_center 6]

## 六、String，StringBuffer，StringBuilder ##

### 区别（源码和demo解释三种区别） ###

#### 1. 字符修改 ####

> String是不可变字符序列（修改String类时，会新增String对象）；StringBuffer和StringBuilder进行修改时不会产生新的对象

注：String代码解释略  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0h1YW5nMTE3ODM4Nzg0OA_size_16_color_FFFFFF_t_70_pic_center 7]  
StringBuffer和StringBuilder都继承了AbstractStringBuilder，他们存储字符的字符数组来自父类的value，这个value并不是final类，可以被修改；对StringBuffer和StringBuilder进行修改可以使用append的方法，在原有的字符序列后面加上新增的字符值（父类AbstractStringBuilder中的方法可以看出这样的操作）；所以也就解释了为什么StringBuffer和StringBuilder为什么是可变字符序列  
![父类AbstractStringBuilder中的append方法实现][AbstractStringBuilder_append]

#### 2. 线程安全 ####

> String由于不可变，所以是线程安全；  
> String和StringBuffer类中每个方法都用synchronized修饰所以是线程安全的；  
> StringBuilder并不是线程安全的

*  解释： String不可变，无论是多线程还是单线程都是安全的；StringBuffer每个方法都加了synchronized，无论多线程还是单线程都是安全的；StringBuilder是可变字符序列，没有加上同步锁；是线程不安全的。

##### 3. 执行效率 #####

> String由于每次修改都会创建新的对象，所以在操作大量数据时效率最慢  
> StringBuffer由于每个方法都加了synchronized修饰，所以每次执行都需要等待锁释放，效率居中  
> StringBuilder效率最快

*  demo代码演示如下

/** * 功能： 比较string，stringBuffer和stringBuilder在拼接字符串时所花费的时间 * 结果： StringBuilder < StringBuffer < String （StringBuffer和String是线程安全的） * 结论： 单线程环境下，可以使用StringBuilder，因为单线程可以保证线程安全，且StringBuilder使用时速度快 * 多线程环境下，使用StringBuffer，因为StringBuffer是线程安全的，相对String来说也速度快 * @param args */
       public static void main(String[] args) { 
           long a=new Date().getTime();
           String cc="";
           int n=100000;
           for (int i = 0; i < n; i++) { 
               cc+="."+i;
           }
           System.out.println("String使用的时间"+(System.currentTimeMillis()-a)/1000.0+"s");
           long s1=System.currentTimeMillis();
           StringBuilder sb=new StringBuilder();
           for (int i = 0; i < n; i++) { 
               sb.append("."+i);
           }
           System.out.println("StringBuilder使用的时间"+(System.currentTimeMillis()-s1)/1000.0+"s");
           long s2=System.currentTimeMillis();
           StringBuffer sbf=new StringBuffer();
           for (int i = 0; i < n; i++) { 
               sbf.append("."+i);
           }
           System.out.println("StringBuffer使用的时间"+(System.currentTimeMillis()-s2)/1000.0+"s");
       }

demo结果（将n变量调大，可以看到StringBuffer和StringBuilder的区别）![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0h1YW5nMTE3ODM4Nzg0OA_size_16_color_FFFFFF_t_70_pic_center 8]

### 结论 ###

> String : 不可变字符串序列；线程安全；效率低；适用于少量的字符串操作的情况  
> StringBuffer：可变字符串序列；线程安全；效率中等；适用多线程下在字符串缓冲区进行大量操作的情况  
> StringBuilder：可变字符串序列；线程不安全；效率快；适用单线程下载字符串缓冲区进行大量操作的情况

### 拓展 ###

针对执行效率来说，在某些特别的情况下，String对象的字符串拼接是被JVM解释成了StringBuffer对象的拼接，所以这些时候String对象的速度并不会比StringBuffer对象慢

long s =System.currentTimeMillis();
            String str1 = "abcdef" + "abcdefg" + "hijklm" + "opq" + "rst" + "uvw" + "xy" + "z";
            System.out.println((System.currentTimeMillis()-s));
            long s1 =System.currentTimeMillis();
            StringBuffer sb = new StringBuffer("abcdef").append("abcdefg").append("hijklm").append("opq").append("rst").append("uvw").append("xy").append("z");
            System.out.println((System.currentTimeMillis()-s1));

单单从运行结果看，是看不出什么的，因为耗时太小基本等于0；但是可以从指令码看出区别  
首先String这一块，使用上述代码中直接赋值的方法，在编译期间Java直接将整的一串字符串拼接起来，并不会生成一堆的String对象；所以通过指令码可知；String在编译期间就已经完成了拼接，最终花费了从常量池中获取的时间；而StringBuffer每次拼接都需要花费一定的时间，都需要从ldc常量池中获取。总体来说String的操作效率比StringBuffer快的多很多。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0h1YW5nMTE3ODM4Nzg0OA_size_16_color_FFFFFF_t_70_pic_center 9]

[20201120090249614.png_pic_center]: /images/20221120/190f564518914f1389549469d17aa342.png
[Link 1]: https://www.cnblogs.com/vincentYw/p/12015171.html
[Link 2]: https://www.cnblogs.com/lsy131479/p/11201241.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0h1YW5nMTE3ODM4Nzg0OA_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/30c18bc69baa48ffb42139c137739989.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0h1YW5nMTE3ODM4Nzg0OA_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221120/9d7f652fd4a743fda15e1e7ac7ba2e5a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0h1YW5nMTE3ODM4Nzg0OA_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221120/b03c97c1774a48d99065e242fddc4d3a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0h1YW5nMTE3ODM4Nzg0OA_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221120/93527dfc7d5349268c3df15b1c246c51.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0h1YW5nMTE3ODM4Nzg0OA_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221120/eac125fe2abe4f2a98da5b1328800ed1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0h1YW5nMTE3ODM4Nzg0OA_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20221120/bd46e9d16f574cfda9ddc17d4596bfa1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0h1YW5nMTE3ODM4Nzg0OA_size_16_color_FFFFFF_t_70_pic_center 6]: /images/20221120/0d58269839a744c1af17d63ba77686d8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0h1YW5nMTE3ODM4Nzg0OA_size_16_color_FFFFFF_t_70_pic_center 7]: /images/20221120/e48eafe55b4b454fa993af886a0a9a74.png
[AbstractStringBuilder_append]: /images/20221120/9928c7f156474173a2102c956b042054.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0h1YW5nMTE3ODM4Nzg0OA_size_16_color_FFFFFF_t_70_pic_center 8]: /images/20221120/0299ccc6ff0242459b10fb2ef1f6df12.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0h1YW5nMTE3ODM4Nzg0OA_size_16_color_FFFFFF_t_70_pic_center 9]: /images/20221120/ae49b9f5c0814030ab911568c07c64a2.png