面试题——————不可变类String类

最近看到二哥的一篇文章，对于如何做好一件事情深有感触，自己阅读完也总结了下面这句话分别是：不断学习，不断思考，不断实践。基础知识有了扎实了，下面要做的就是深入。人往高处走嘛！

String类相信大家并不陌生可能天天都在使用（只要你写代码）、今天也看了一些博主的讲解对比自己与他们之间有什么理解出入和差距，所以整理了一下。正好也为面试作准备！

进入正题

01做个题热热身

 		String str = new String("abc");
        String str2 = "abc";

必备知识点:

聊一聊两种创建字符串对象的方式

• 构造器创建对象
• 双引号创建对象

构造器和双引号创建对象有啥区别？
构造器创建对象：new String(“abc”)会创建两个对象,一个在堆内存，一个在常量池,堆内存对象是常量池对象的一个拷贝副本。

注意事项：
如果常量池中存在"abc"对象就只创建一个对象(堆内存中)
如果常量池不存在"abc"对象就创建两个对象

双引号创建对象：常量池(因为new String(“abc"创建了两个对象,常量池中已有"abc”,不再创建对象)所以将"abc"的内存地址赋给str2，str2根据内存地址，指向了常量池中的"abc")

                         ------------- 实战演练-------------

牛刀小试

判断str1与str2是否相等

public class StringTest {
    public static void main(String[] args) {
 		String str1 = "abc";
        String str2 = "abc";
        System.out.println(str1==str2);//true
        System.out.println(str1.equals(str2));//true
    }
}        

顺便复习一下==与equals方法的区别？
对于 == 来说
如果比较的是基本数据变量，直接比较"值"。
如果比较的是引用类型变量，比较的是内存地址。
对于 equals 来说
如果重写了equals方法，比较的是引用变量指向对象的内容。
如果没有重写equal方法，比较的是引用变量指向对象的内存地址。
诸如String类、Date对equals方法进行了重写。

分析:
第一条打印语句 字符串属于引用类型并且str1、str2指向了同一个内存地址，所以==比较结果相等为true
第二条打印语句 存在equals方法，所以我们先考虑String类是否重写该方法。从JDK1.8文档中得知
将此字符串与指定对象进行比较。 其结果是true当且仅当该参数不是null并且是String对象，表示相同的字符序列作为该对象。
也就是说str1与str2是相同的字符序列对象，所以equals比较结果为true

图解:

1. 运行前编译 当前类编译为StringTest.class (字节码文件)，文件加载到内存的方法区
2. main方法压入栈内存
3. 常量池创建"abc"对象，产生内存地址,赋值给main方法下的str1，str1根据内存地址指向内存地址
4. 程序运行到str2 发现常量池已经存在相同的对象，就不在创建(目的为了节省内存开销)，str2也指向了内存地址
5. str1、str2都指向同一地址，所以==结果为true
6. 由于string类重写了equals方法，str1 、str2内容相等(相同的字符序列) ，所以equals结果为true

初露锋芒
判断str1与str2是否相等

public class StringTest {
    public static void main(String[] args) {
        String str = new String("abc");
        String str2 = "abc";
        System.out.println(str==str2);//false
        System.out.println(str1.equals(str2));//true
    }
}

分析:
第一条打印语句 str2引用指向常量池内存地址,str引用指向堆内存地址，所以==结果为false
第二条打印语句 string类重写了equal是方法str1与str2的内容相同(相同的字符序列)，所以equals结果为true

图解:

内存过程大致如下：

1）运行前编译，生成StringTest.class文件（字节码文件）加载到内存的方法区
2）main方法压入栈内存
3）new String(“abc”)在常量池创建对象,产生内存地址，赋值给main方法的str，str根据内存地址，指向堆内存，同时堆内存拷贝一份副本
4）双引号创建对象时发现常量池已经存在，不会再去创建，str2指向了常量池的内存地址。
5) str指向堆内存 str2指向常量池地址 所以==结果为false
6) str、str2内容相同(相同字符序列) 所以equals结果为true

为什么堆内存拷贝一份副本？
JDK API 1.6中这样解释构造方法——String(String original)的
初始化新创建的String对象，使其表示与参数相同的字符序列; 换句话说，新创建的字符串是参数字符串的副本。

兵不血刃
判断str1与str2是否相等

public class StringTest {
    public static void main(String[] args) {
        String str1 = "ab";
        String str2 = "abc";
        String str3 = st1 + "c";
        System.out.println(str2 == str3);//false
        System.out.println(str2.equals(str3));//true
    }
}

分析:
第一条打印语句 ==结果为false，无法上面的知识解决那就要借助API和反编译工具去理解
第二条打印语句 equals结果突然 不难理解因为都是相同的字符序列结果为true

疑惑的原因是str3对象是通过连接字符串(+)创建的 对于(连接字符串)+JDK1.8帮助文档也有介绍
Java语言为字符串连接运算符（+）提供特殊支持，并为其他对象转换为字符串。 字符串连接是通过StringBuilder （或StringBuffer ）类及其append方法实现的。 字符串转换是通过方法来实现toString ，由下式定义Object和继承由在Java中的所有类。

如果想要看到+是如何转化为StringBuiler操作的可以通过反编译工具jad来实现（文章最后会分享）

public class StringTest 
{

    public StringTest ()
    {
    }

    public static void main(String args[])
    {
        String s = "ab";
        String s1 = "abc";
        String s2 = (new StringBuilder()).append(s).append("c").toString();
        System.out.println(s1 == s2);
        System.out.println(s1.equals(s2));
    }
}

通过反编译工具可以发现原先 String str3 = st1 + "c"实际操作是
String s2 = (new StringBuilder()).append(s).append(“c”).toString()
这样是不是清晰了很多。
因为new StringBuilder()通过append方法创建出来的对象都存储在堆内存中，所以会产生一个内存地址0x0011，但这并不是String对象所以需要通过object类中的toString方法转化为String 对象 ，String对象也在堆内存中产生了一个内存地址0x002然后赋值给s2、s2指向了堆内存地址0x0022

图解:

内存大致过程如下:

1. 常量池创建了"ab"对象，产生内存地址赋值给str1，str1指向了"ab";
2. 常量池创建了"abc"对此昂，产生了内存地址赋值给了str2，str2指向了"abc";
3. 连接字符串会被java通过StringBuilder方法的append方法创建一个新的对象得到"abc",
   这时候内存地址0x0011表示的是一个StringBuilder对象，不是String对象。

   ---

4. 需要通过object的toString方法转化为String对象
5. String对象将内存地址0x0022赋值给str3,str3指向"abc"

锋不可当
判断str1与str2是否相等

public class StringTest {
    public static void main(String[] args) {
        String str1 = "a" + "b" + "c";
        String str2 = "abc";
        System.out.println(str1 == str2);//true
        System.out.println(str1.equals(str2));//true
    }
}        

分析:
第一条打印语句 通过反编译工具得知原先str1=“a”+“b”+“c”;反编译后 String s = “abc”;
可以得出结论:

1.连接字符串左右两边如果是字符串,直接在常量池创建
2.连接字符串左右两边如如果任意一边存在引用变量，就会通过StringBuilder或者(StringBuffer)的append方法创建对象(new出来的对象都存储在堆内存中)
所以str1、str2指向同一地址 ==结果为true

第二条打印语句 str1、str2都是相同的字符序列所以内容相同结果为true

public class StringTest
{

    public StringTest()
    {
    }

    public static void main(String args[])
    {
        String s = "abc";
        String s1 = "abc";
        System.out.println(s == s1);
        System.out.println(s.equals(s1));
    }
}

干了下面这些题

		String s1 = new String("zs");
        String s2 = new String("zs");
        System.out.println(s1==s2);//false
        String s3="zs";
        String s4="zs";
        System.out.println(s3==s4);//true
        System.out.println(s3==s1);//false
        String s5="zszs";
        String s6=s3+s4;
        System.out.println(s5==s6);//false
        final String s7="zs";
        final String s8="zs";
        String s9=s7+s8;
        System.out.println(s5==s9);//true
        final String s10=s3+s4;
        System.out.println(s5==s10);//false

前面的不再过多的赘述了，重点说一下final修改的成员变量（只能在构造方法中初始化值，随后修改不了）
String s9=s7+s8;这行代码如果按照上面的理解应该是在堆内存中创建对象，但是final修饰的成员变量被拘留在了常量池中，所以连接字符串返回的对象存储在常量池中，又因为"zszs"被创建过了，所以s5和s9引用指向同一内存地址==结果为true
final String s10=s3+s4;这行代码与上面看起来相同，虽然final修饰了但是实际上通过反编译发现连接字符串依然有效了，这是因为final是在创建对象之后拘留了，所以这时候堆内存已经创建出来了对象。
所以s5指向的是常量池地址，s10指向的是堆内存地址 ==结果为false。
如果不明白可以通过jad反编译或者画图去理解

public class Test
{

    public Test()
    {
    }

    public static void main(String args[])
    {
        String s = new String("zs");
        String s1 = new String("zs");
        System.out.println(s == s1);
        String s2 = "zs";
        String s3 = "zs";
        System.out.println(s2 == s3);
        System.out.println(s2 == s);
        String s4 = "zszs";
        String s5 = (new StringBuilder()).append(s2).append(s3).toString();
        System.out.println(s4 == s5);
        String s6 = "zszs";
        System.out.println(s4 == s6);
        String s7 = (new StringBuilder()).append(s2).append(s3).toString();
        System.out.println(s4 == s7);
    }
}

02String类中一些方法

JAVA提供了String类来创建和操作字符串。在源码中可以看到,String类内部的实现也是一个字节数组，这个数组是final类型的。因此String是不可变的对象，每次对String类进行改变的时候都会生成一个新的String对象，然后将指针指向新的String对象。

 /** The value is used for character storage. */
    private final char value[];

String类中方法也证实了操作字符串不会改变自身，而是创建新的对象，诸如concat、replaceAll、replace等方法。

举个例子:

        String s = "abcd";
        s = s.concat("ef");
        System.out.println(s);

对字符串"abcd"操作将指定的字符串连接到该字符串的末尾
在源码中返回的是一个new对象，所以创建的字符串对象"abcdef"存储在堆内存中。

public String concat(String str) {
        int otherLen = str.length();
        if (otherLen == 0) {
            return this;
        }
        int len = value.length;
        char buf[] = Arrays.copyOf(value, len + otherLen);
        str.getChars(buf, len);
        return new String(buf, true);
    }

03为什么String是不可变的类？

前面做了很多铺垫，最后总结一下String是不可变类的原因。

1. 常量池的需要
   字符串常量池是 Java 堆内存中一个特殊的存储区域，当创建字符串对象时候，如果常量池存在就不会二次创建，直接引用对象，目的是为了节省内存的开销，提高运行效率。
2. hashcode需要
   因为字符串是不可变的，所以在它创建的时候，其 hashCode 就被缓存了，因此非常适合作为哈希值（比如说作为 HashMap 的键），多次调用只返回同一个值，来提高效率。
3. 线程安全
   由于不可变对象不能被更改，所以它们可以在多个线程之间自由共享。这消除了同步的需求

04分享反编译工具

反编译工具jad
链接：https://pan.baidu.com/s/1F8oUkDTTBqkl1UkomESgyA
提取码：7ns3

具体安装操作如下：
http://www.itwanger.com/java/2019/10/22/javac-jad.html