為什么要有 hashCode？

我們以“HashSet 如何檢查重復”為例子來說明為什么要有 hashCode？

下面這段內容摘自我的 Java 啟蒙書《Head First Java》:

當你把對象加入 HashSet 時，HashSet 會先計算對象的 hashCode 值來判斷對象加入的位置，同時也會與其他已經加入的對象的 hashCode 值作比較，如果沒有相符的 hashCode，HashSet 會假設對象沒有重復出現(xiàn)。但是如果發(fā)現(xiàn)有相同 hashCode 值的對象，這時會調用 equals() 方法來檢查 hashCode 相等的對象是否真的相同。如果兩者相同，HashSet 就不會讓其加入操作成功。如果不同的話，就會重新散列到其他位置。這樣我們就大大減少了 equals 的次數(shù)，相應就大大提高了執(zhí)行速度。

其實， hashCode() 和 equals()都是用于比較兩個對象是否相等。

那為什么 JDK 還要同時提供這兩個方法呢？

這是因為在一些容器（比如 HashMap、HashSet）中，有了 hashCode() 之后，判斷元素是否在對應容器中的效率會更高（參考添加元素進HashSet的過程）！

我們在前面也提到了添加元素進HashSet的過程，如果 HashSet 在對比的時候，同樣的 hashCode 有多個對象，它會繼續(xù)使用 equals() 來判斷是否真的相同。也就是說 hashCode 幫助我們大大縮小了查找成本。

那為什么不只提供 hashCode() 方法呢？

這是因為兩個對象的hashCode 值相等并不代表兩個對象就相等。

那為什么兩個對象有相同的 hashCode 值，它們也不一定是相等的？

因為 hashCode() 所使用的哈希算法也許剛好會讓多個對象傳回相同的哈希值。越糟糕的哈希算法越容易碰撞，但這也與數(shù)據(jù)值域分布的特性有關（所謂哈希碰撞也就是指的是不同的對象得到相同的 hashCode )。

總結下來就是 ：

• 如果兩個對象的hashCode 值相等，那這兩個對象不一定相等（哈希碰撞）。
• 如果兩個對象的hashCode 值相等并且equals()方法也返回 true，我們才認為這兩個對象相等。
• 如果兩個對象的hashCode 值不相等，我們就可以直接認為這兩個對象不相等。

相信大家看了我前面對 hashCode() 和 equals() 的介紹之后，下面這個問題已經難不倒你們了。

為什么重寫 equals() 時必須重寫 hashCode() 方法？

因為兩個相等的對象的 hashCode 值必須是相等。也就是說如果 equals 方法判斷兩個對象是相等的，那這兩個對象的 hashCode 值也要相等。

如果重寫 equals() 時沒有重寫 hashCode() 方法的話就可能會導致 equals 方法判斷是相等的兩個對象，hashCode 值卻不相等。

思考 ：重寫 equals() 時沒有重寫 hashCode() 方法的話，使用 HashMap 可能會出現(xiàn)什么問題。

總結 ：

• equals 方法判斷兩個對象是相等的，那這兩個對象的 hashCode 值也要相等。
• 兩個對象有相同的 hashCode 值，他們也不一定是相等的（哈希碰撞）。

String

String、StringBuffer、StringBuilder 的區(qū)別？

可變性

String 是不可變的（后面會詳細分析原因）。

StringBuilder 與 StringBuffer 都繼承自 AbstractStringBuilder 類，在 AbstractStringBuilder 中也是使用字符數(shù)組保存字符串，不過沒有使用 final 和 private 關鍵字修飾，最關鍵的是這個 AbstractStringBuilder 類還提供了很多修改字符串的方法比如 append 方法。

abstract class AbstractStringBuilder implements Appendable, CharSequence {
    char[] value;
    public AbstractStringBuilder append(String str) {
        if (str == null)
            return appendNull();
        int len = str.length();
        ensureCapacityInternal(count + len);
        str.getChars(0, len, value, count);
        count += len;
        return this;
    }
    //...
}

線程安全性

String 中的對象是不可變的，也就可以理解為常量，線程安全。AbstractStringBuilder 是 StringBuilder 與 StringBuffer 的公共父類，定義了一些字符串的基本操作，如 expandCapacity、append、insert、indexOf 等公共方法。StringBuffer 對方法加了同步鎖或者對調用的方法加了同步鎖，所以是線程安全的。StringBuilder 并沒有對方法進行加同步鎖，所以是非線程安全的。

性能

每次對 String 類型進行改變的時候，都會生成一個新的 String 對象，然后將指針指向新的 String 對象。StringBuffer 每次都會對 StringBuffer 對象本身進行操作，而不是生成新的對象并改變對象引用。相同情況下使用 StringBuilder 相比使用 StringBuffer 僅能獲得 10%~15% 左右的性能提升，但卻要冒多線程不安全的風險。

對于三者使用的總結：

1. 操作少量的數(shù)據(jù): 適用 String
2. 單線程操作字符串緩沖區(qū)下操作大量數(shù)據(jù): 適用 StringBuilder
3. 多線程操作字符串緩沖區(qū)下操作大量數(shù)據(jù): 適用 StringBuffer

String 為什么是不可變的?

String 類中使用 final 關鍵字修飾字符數(shù)組來保存字符串，所以String 對象是不可變的。

public final class String implements java.io.Serializable, Comparable<String>, CharSequence {
    private final char value[];
    //...
}

?? 修正 ： 我們知道被 final 關鍵字修飾的類不能被繼承，修飾的方法不能被重寫，修飾的變量是基本數(shù)據(jù)類型則值不能改變，修飾的變量是引用類型則不能再指向其他對象。因此，final 關鍵字修飾的數(shù)組保存字符串并不是 String 不可變的根本原因，因為這個數(shù)組保存的字符串是可變的（final 修飾引用類型變量的情況）。

String 真正不可變有下面幾點原因：

1. 保存字符串的數(shù)組被 final 修飾且為私有的，并且String 類沒有提供/暴露修改這個字符串的方法。
2. String 類被 final 修飾導致其不能被繼承，進而避免了子類破壞 String 不可變。

在 Java 9 之后，String 、StringBuilder 與 StringBuffer 的實現(xiàn)改用 byte 數(shù)組存儲字符串。

public final class String implements java.io.Serializable,Comparable<String>, CharSequence {
    // @Stable 注解表示變量最多被修改一次，稱為“穩(wěn)定的”。
    @Stable
    private final byte[] value;
}

abstract class AbstractStringBuilder implements Appendable, CharSequence {
    byte[] value;

}

Java 9 為何要將 String 的底層實現(xiàn)由 char[] 改成了 byte[] ?

新版的 String 其實支持兩個編碼方案： Latin-1 和 UTF-16。如果字符串中包含的漢字沒有超過 Latin-1 可表示范圍內的字符，那就會使用 Latin-1 作為編碼方案。Latin-1 編碼方案下，byte 占一個字節(jié)(8 位)，char 占用 2 個字節(jié)（16），byte 相較 char 節(jié)省一半的內存空間。

JDK 官方就說了絕大部分字符串對象只包含 Latin-1 可表示的字符。

image.png

如果字符串中包含的漢字超過 Latin-1 可表示范圍內的字符，byte 和 char 所占用的空間是一樣的。

這是官方的介紹：https://openjdk.java.net/jeps/254 。

字符串拼接用“+” 還是 StringBuilder?

Java 語言本身并不支持運算符重載，“+”和“+=”是專門為 String 類重載過的運算符，也是 Java 中僅有的兩個重載過的元素符。

String str1 = "he";
String str2 = "llo";
String str3 = "world";
String str4 = str1 + str2 + str3;

對象引用和“+”的字符串拼接方式，實際上是通過 StringBuilder 調用 append() 方法實現(xiàn)的，拼接完成之后調用 toString() 得到一個 String 對象 。

image.png

不過，在循環(huán)內使用“+”進行字符串的拼接的話，存在比較明顯的缺陷：編譯器不會創(chuàng)建單個 StringBuilder 以復用，會導致創(chuàng)建過多的 StringBuilder 對象。

String[] arr = {"he", "llo", "world"};
String s = "";
for (int i = 0; i < arr.length; i++) {
    s += arr[i];
}
System.out.println(s);

StringBuilder 對象是在循環(huán)內部被創(chuàng)建的，這意味著每循環(huán)一次就會創(chuàng)建一個 StringBuilder 對象。

image.png

如果直接使用 StringBuilder 對象進行字符串拼接的話，就不會存在這個問題了。

String#equals() 和 Object#equals() 有何區(qū)別？

String 中的 equals 方法是被重寫過的，比較的是 String 字符串的值是否相等。 Object 的 equals 方法是比較的對象的內存地址。

字符串常量池的作用了解嗎？

字符串常量池 是 JVM 為了提升性能和減少內存消耗針對字符串（String 類）專門開辟的一塊區(qū)域，主要目的是為了避免字符串的重復創(chuàng)建。

// 在堆中創(chuàng)建字符串對象”ab“
// 將字符串對象”ab“的引用保存在字符串常量池中
String aa = "ab";
// 直接返回字符串常量池中字符串對象”ab“的引用
String bb = "ab";
System.out.println(aa==bb);// true

String s1 = new String("abc");這句話創(chuàng)建了幾個字符串對象？

會創(chuàng)建 1 或 2 個字符串。

1、如果字符串常量池中不存在字符串對象“abc”的引用，那么會在堆中創(chuàng)建 2 個字符串對象“abc”。

示例代碼（JDK 1.8）：

String s1 = new String("abc");

對應的字節(jié)碼：

image.png

ldc 命令用于判斷字符串常量池中是否保存了對應的字符串對象的引用，如果保存了的話直接返回，如果沒有保存的話，會在堆中創(chuàng)建對應的字符串對象并將該字符串對象的引用保存到字符串常量池中。

2、如果字符串常量池中已存在字符串對象“abc”的引用，則只會在堆中創(chuàng)建 1 個字符串對象“abc”。

示例代碼（JDK 1.8）：

// 字符串常量池中已存在字符串對象“abc”的引用
String s1 = "abc";
// 下面這段代碼只會在堆中創(chuàng)建 1 個字符串對象“abc”
String s2 = new String("abc");

對應的字節(jié)碼：

image.png

這里就不對上面的字節(jié)碼進行詳細注釋了，7 這個位置的 ldc 命令不會在堆中創(chuàng)建新的字符串對象“abc”，這是因為 0 這個位置已經執(zhí)行了一次 ldc 命令，已經在堆中創(chuàng)建過一次字符串對象“abc”了。7 這個位置執(zhí)行 ldc 命令會直接返回字符串常量池中字符串對象“abc”對應的引用。

intern 方法有什么作用?

String.intern() 是一個 native（本地）方法，其作用是將指定的字符串對象的引用保存在字符串常量池中，可以簡單分為兩種情況：

• 如果字符串常量池中保存了對應的字符串對象的引用，就直接返回該引用。
• 如果字符串常量池中沒有保存了對應的字符串對象的引用，那就在常量池中創(chuàng)建一個指向該字符串對象的引用并返回。

示例代碼（JDK 1.8） :

// 在堆中創(chuàng)建字符串對象”Java“
// 將字符串對象”Java“的引用保存在字符串常量池中
String s1 = "Java";
// 直接返回字符串常量池中字符串對象”Java“對應的引用
String s2 = s1.intern();
// 會在堆中在單獨創(chuàng)建一個字符串對象
String s3 = new String("Java");
// 直接返回字符串常量池中字符串對象”Java“對應的引用
String s4 = s3.intern();
// s1 和 s2 指向的是堆中的同一個對象
System.out.println(s1 == s2); // true
// s3 和 s4 指向的是堆中不同的對象
System.out.println(s3 == s4); // false
// s1 和 s4 指向的是堆中不同的對象
System.out.println(s1 == s4); //true

String 類型的變量和常量做“+”運算時發(fā)生了什么？

先來看字符串不加 final 關鍵字拼接的情況（JDK1.8）：

String str1 = "str";
String str2 = "ing";
String str3 = "str" + "ing";
String str4 = str1 + str2;
String str5 = "string";
System.out.println(str3 == str4);//false
System.out.println(str3 == str5);//true
System.out.println(str4 == str5);//false

注意 ：比較 String 字符串的值是否相等，可以使用 equals() 方法。 String 中的 equals 方法是被重寫過的。 Object 的 equals 方法是比較的對象的內存地址，而 String 的 equals 方法比較的是字符串的值是否相等。如果你使用 == 比較兩個字符串是否相等的話，IDEA 還是提示你使用 equals() 方法替換。

image.png

對于編譯期可以確定值的字符串，也就是常量字符串 ，jvm 會將其存入字符串常量池。并且，字符串常量拼接得到的字符串常量在編譯階段就已經被存放字符串常量池，這個得益于編譯器的優(yōu)化。

在編譯過程中，Javac 編譯器（下文中統(tǒng)稱為編譯器）會進行一個叫做 常量折疊(Constant Folding) 的代碼優(yōu)化?！渡钊肜斫?Java 虛擬機》中是也有介紹到：

image.png

常量折疊會把常量表達式的值求出來作為常量嵌在最終生成的代碼中，這是 Javac 編譯器會對源代碼做的極少量優(yōu)化措施之一(代碼優(yōu)化幾乎都在即時編譯器中進行)。

對于 String str3 = "str" + "ing"; 編譯器會給你優(yōu)化成 String str3 = "string"; 。

并不是所有的常量都會進行折疊，只有編譯器在程序編譯期就可以確定值的常量才可以：

• 基本數(shù)據(jù)類型( byte、boolean、short、char、int、float、long、double)以及字符串常量。
• final 修飾的基本數(shù)據(jù)類型和字符串變量
• 字符串通過 “+”拼接得到的字符串、基本數(shù)據(jù)類型之間算數(shù)運算（加減乘除）、基本數(shù)據(jù)類型的位運算（<<、>>、>>> ）

引用的值在程序編譯期是無法確定的，編譯器無法對其進行優(yōu)化。

對象引用和“+”的字符串拼接方式，實際上是通過 StringBuilder 調用 append() 方法實現(xiàn)的，拼接完成之后調用 toString() 得到一個 String 對象 。

String str4 = new StringBuilder().append(str1).append(str2).toString();

我們在平時寫代碼的時候，盡量避免多個字符串對象拼接，因為這樣會重新創(chuàng)建對象。如果需要改變字符串的話，可以使用 StringBuilder 或者 StringBuffer。

不過，字符串使用 final 關鍵字聲明之后，可以讓編譯器當做常量來處理。

示例代碼：

final String str1 = "str";
final String str2 = "ing";
// 下面兩個表達式其實是等價的
String c = "str" + "ing";// 常量池中的對象
String d = str1 + str2; // 常量池中的對象
System.out.println(c == d);// true

被 final 關鍵字修改之后的 String 會被編譯器當做常量來處理，編譯器在程序編譯期就可以確定它的值，其效果就相當于訪問常量。

如果 ，編譯器在運行時才能知道其確切值的話，就無法對其優(yōu)化。

示例代碼（str2 在運行時才能確定其值）：

final String str1 = "str";
final String str2 = getStr();
String c = "str" + "ing";// 常量池中的對象
String d = str1 + str2; // 在堆上創(chuàng)建的新的對象
System.out.println(c == d);// false
public static String getStr() {
      return "ing";
}

在此我向大家推薦一個架構學習交流圈。交流學習微信：539413949（里面有大量的面試題及答案）里面會分享一些資深架構師錄制的視頻錄像：有Spring，MyBatis，Netty源碼分析，高并發(fā)、高性能、分布式、微服務架構的原理，JVM性能優(yōu)化、分布式架構等這些成為架構師必備的知識體系。還能領取免費的學習資源，目前受益良多