摘要：不相等的對象要具有不相等的哈希碼為了哈希表的操作效率，這一點很重要，但不是強制要求，最低要求是不相等的對象不能共用一個哈希碼。方法和方法協同工作，返回對象的哈希碼。這個哈希碼基于對象的身份生成，而不是對象的相等性。

本文面向

剛學完Java的新手們。這篇文章不講語法，而是一些除了語法必須了解的概念。

將要去面試的初級工程師們。查漏補缺，以免遭遇不測。

目前由于篇幅而被挪出本文的知識點：

淺析JVM之內存管理

Java多線程筆記

Java反射學習小記

簡談Java String

JVM：java 虛擬機，負責將編譯產生的字節碼轉換為特定機器代碼，實現一次編譯多處執行；

JRE：java運行時環境，包含了java虛擬機jvm，java基礎類庫。是使用java語言編寫的程序運行所需要的軟件環境；

JDK：java開發工具包，是編寫java程序所需的開發工具。JDK包含了JRE，同時還包含了編譯器javac，調試和分析工具，JavaDoc。

上圖表示了Java代碼是怎么編譯和加載的

整個流程從 Java 源碼開始，經過 javac 程序處理后得到類文件，這個文件中保存的是編譯源碼后得到的 Java 字節碼。類文件是 Java 平臺能處理的最小功能單位，也是把新代碼傳給運行中程序的唯一方式。

新的類文件通過類加載機制載入虛擬機，從而把新類型提供給解釋器執行。

所有類都直接或間接擴展 java.lang.Object 類。這個類定義了很多有用的方法，而且你可以根據需求來重寫這些方法。

toString( ) 方法的作用是返回對象的文本表示形式。連接字符串或使用 System.out.println( ) 等方法時，會自動在對象上調用這個方法。給對象提供文本表示形式，十分利于調試或記錄日志，而且精心編寫的 toString( ) 方法還能給報告生成等任務提供幫助。

Object 類中的 toString( ) 方法返回的字符串由對象所屬的類名和對象的十六進制形式哈希碼（由 hashCode( ) 方法計算得到，本章節稍后會介紹）組成。這個默認的實現方式提供了對象的類型和標識兩個基本信息，但一般并沒什么用。

== 運算符測試兩個引用是否指向同一個對象（比較兩個內存單元的內容是否一樣）。如果要測試兩個不同的對象是否相等，必須使用 equals( ) 方法。任何類都能覆蓋 equals( ) 方法，定義專用的相等比較方式。Object.equals( ) 方法直接使用 == 運算符，只有兩個對象是同一個對象時，才判定二者相等。

很多類以及自定義類的equals方法都需要重寫，是需要根據場景與需求來定制的。JDK自帶的許多類往往都是：

對比一些簡單的屬性值

再對比復雜的屬性值or對比業務上最快能區分對象的值

再對比其他的值or對比地址、長度

主要為了將那些不匹配的情況盡快排除

Java中的hashCode方法就是根據一定的規則將與對象相關的信息（比如對象的存儲地址，對象的字段等）映射成一個數值，這個數值稱作為散列值。 如果集合中已經存在一萬條數據或者更多的數據，如果采用equals方法去逐一比較，效率必然是一個問題。此時hashCode方法的作用就體現出來了，當集合要添加新的對象時，先調用這個對象的hashCode方法，得到對應的hashcode值，實際上在HashMap的具體實現中會用一個table保存已經存進去的對象的hashcode值，如果table中沒有該hashcode值，它就可以直接存進去，不用再進行任何比較了；如果存在該hashcode值，就調用它的equals方法與新元素進行比較，相同的話就不存了，不相同就散列其它的地址，所以這里存在一個沖突解決的問題，這樣一來實際調用equals方法的次數就大大降低了。

另外注意，默認的hashCode會發起native調用，如果用hashCode對兩個對象對比，會導致開銷增大。
hashcode方法的作用

只要覆蓋了 equals( ) 方法，就必須覆蓋 hashCode( ) 方法。hashCode( ) 方法返回一個整數，用于哈希表數據結構。如果兩個對象經 equals( ) 方法測試是相等的，它們就要具有相同的哈希碼。不相等的對象要具有不相等的哈希碼（為了哈希表的操作效率），這一點很重要，但不是強制要求，最低要求是不相等的對象不能共用一個哈希碼。為了滿足最低要求，hashCode( ) 方法要使用稍微復雜的算法或位操作。

Object.hashCode( ) 方法和 Object.equals( ) 方法協同工作，返回對象的哈希碼。這個哈希碼基于對象的身份生成，而不是對象的相等性。（如果需要使用基于身份的哈希碼，可以通過靜態方法 System.identityHashCode( ) 獲取 Object.hashCode( ) 方法的返回值。）

hashCode和equal方法

hashCode的存在主要是用于查找的快捷性，如Hashtable，HashMap等，hashCode是用來在散列存儲結構中確定對象的存儲地址的；

如果兩個對象相同，就是適用于equals(java.lang.Object) 方法，那么這兩個對象的hashCode一定要相同；

如果對象的equals方法被重寫，那么對象的hashCode也盡量重寫，并且產生hashCode使用的對象，一定要和equals方法中使用的一致，否則就會違反上面提到的第2點；

兩個對象的hashCode相同，并不一定表示兩個對象就相同，也就是不一定適用于equals(java.lang.Object)方法，只能夠說明這兩個對象在散列存儲結構中，如Hashtable，他們"存放在同一個籃子里"。

HashCode和equal方法

如果一個類實現了 Comparable 接口，就可以比較一個實例是小于、大于還是等于另一個實例。這也表明，實現 Comparable 接口的類可以排序。

因為 compareTo( ) 方法不在 Object 類中聲明，所以由每個類自行決定實例能否排序。如果能排序就定義 compareTo( ) 方法，實現實例排序的方式。

compareTo( ) 方法返回一個 int 類型的值，這個值需要進一步說明。如果當前對象（this）小于傳入的對象，compareTo( ) 方法應該返回一個負數；如果兩個對象相等，應該返回 0；如果當前對象大于傳入的對象，應該返回一個正數。

Object 類定義了一個名為 clone( ) 的方法，這個方法的作用是返回一個對象，并把這個對象的字段設為和當前對象一樣。clone( ) 方法不常用，原因有兩個。其一，只有類實現了 java.lang.Cloneable 接口，這個方法才有用。Cloneable 接口沒有定義任何方法（是個標記接口），因此若想實現這個接口，只需在類簽名的 implements 子句中列出這個接口即可。其二，clone( ) 方法聲明為 protected，因此，如果想讓其他類復制你的對象，你的類必須實現 Cloneable 接口，并覆蓋 clone( ) 方法，而且要把 clone( ) 方法聲明為 public。

clone( ) 方法很難正確實現，而副本構造方法實現起來更容易也更安全。

一種古老的資源管理技術叫終結（finalization），開發者應該知道有這么一種技術。然而，這種技術幾乎完全廢棄了，任何情況下，大多數 Java 開發者都不應該直接使用。

只有少數應用場景適合使用終結，而且只有少數 Java 開發者會遇到這種場景。如果有任何疑問，就不要使用終結，處理資源的 try 語句往往是正確的替代品。

終結機制的作用是自動釋放不再使用的資源。垃圾回收自動釋放的是對象使用的內存資源，不過對象可能會保存其他類型的資源，例如打開的文件和網絡連接。垃圾回收程序不會為你釋放這些額外的資源，因此，終結機制的作用是讓開發者執行清理任務，例如關閉文件、中斷網絡連接、刪除臨時文件，等等。

終結機制的工作方式是這樣的：如果對象有 finalize( ) 方法（一般叫作終結方法），那么不再使用這個對象（或對象不可達）后的某個時間會調用這個方法，但要在垃圾回收程序回收分配給這個對象的空間之前調用。終結方法用于清理對象使用的資源。

另外注意，這是一個實例方法。而在類上，沒有等效的機制。

8種基本類型對應的包裝類也是被final修飾。另外，String類和StringBuffer類也是被final修飾的。

引用類型和對象與基本類型和基本值有本質的區別。

八種基本類型由 Java 語言定義，程序員不能定義新基本類型。引用類型由用戶定義，因此有無限多個。例如，程序可以定義一個名為 Point 的類，然后使用這個新定義類型的對象存儲和處理笛卡兒坐標系中的 (x, y) 點。

基本類型表示單個值。引用類型是聚合類型（aggregate type），可以保存零個或多個基本值或對象。例如，我們假設的 Point 類可能存儲了兩個 double 類型的值，表示點的 x 和 y 坐標。char[ ] 和 Point[ ] 數組類型是聚合類型，因為它們保存一些 char 類型的基本值或 Point 對象。

基本類型需要一到八個字節的內存空間。把基本值存儲到變量中，或者傳入方法時，計算機會復制表示這個值的字節。而對象基本上需要更多的內存。創建對象時會在堆（heap）中動態分配內存，存儲這個對象；如果不再需要使用這個對象了，存儲它的內存會被自動垃圾回收。

把對象賦值給變量或傳入方法時，不會復制表示這個對象的內存，而是把這個內存的引用存儲在變量中或傳入方法。

在 Java 中，引用完全不透明，引用的表示方式由 Java 運行時的實現細節決定。如果你是 C 程序員的話，完全可以把引用看作指針或內存地址。不過要記住，Java 程序無法使用任何方式處理引用。

似乎看的有點暈？來點兒代碼吧！

下述代碼處理 int 類型基本值：

int x = 42;
int y = x;

執行這兩行代碼后，變量 y 中保存了變量 x 中所存值的一個副本。在 Java 虛擬機內部，這個 32 位整數 42 有兩個獨立的副本。

現在，想象一下把這段代碼中的基本類型換成引用類型后再運行會發生什么：

Point p = new Point(1.0, 2.0);
Point q = p;

運行這段代碼后，變量 q 中保存了一份變量 p 中所存引用的一個副本。在虛擬機中，仍然只有一個 Point 對象的副本，但是這個對象的引用有兩個副本----這一點有重要的含義。假設上面兩行代碼的后面是下述代碼：

System.out.println(p.x);  // 打印p的x坐標：1.0
q.x = 13.0;               // 現在，修改q的x坐標
System.out.println(p.x);  // 再次打印p.x，這次得到的值是13.0

因為變量 p 和 q 保存的引用指向同一個對象，所以兩個變量都可以用來修改這個對象，而且一個變量中的改動在另一個變量中可見。數組也是一種對象，所以對數組來說也會發生同樣的事，如下面的代碼所示：

// greet保存一個數組的引用
char[ ] greet = { "h","e","l","l","o" };
char[ ] cuss = greet;             // cuss保存的是同一個數組的引用
cuss[4] = "!";                   // 使用引用修改一個元素
System.out.println(greet);       // 打印“hell!”

把基本類型和引用類型的參數傳入方法時也有類似的區別。假如有下面的方法：

void changePrimitive(int x) {
    while(x > 0) {
        System.out.println(x--);
    }
}

調用這個方法時，會把實參的副本傳給形參 x。在這個方法的代碼中，x 是循環計數器，向零遞減。因為 x 是基本類型，所以這個方法有這個值的私有副本——這是完全合理的做法。

可是，如果把這個方法的參數改為引用類型，會發生什么呢？

void changeReference(Point p) {
    while(p.x > 0) {
        System.out.println(p.x--);
    }
}

調用這個方法時，傳入的是一個 Point 對象引用的私有副本，然后使用這個引用修改對應的 Point 對象。例如，有下述代碼：

Point q = new Point(3.0, 4.5); // 一個x坐標為3的點
changeReference(q);            // 打印3，2，1，而且修改了這個Point對象
System.out.println(q.x);       // 現在，q的x坐標是0！

調用 changeReference( ) 方法時，傳入的是變量 q 中所存引用的副本。現在，變量 q 和方法的形參 p 保存的引用指向同一個對象。這個方法可以使用它的引用修改對象的內容。但是要注意，這個方法不能修改變量 q 的內容。也就是說，這個方法可以隨意修改引用的 Point 對象，但不能改變變量 q 引用這個對象這一事實。

那么在用運算符：==時，也會有差別。

相等運算符（==）比較基本值時，只測試兩個值是否一樣（即每一位的值都完全相同）。而 == 比較引用類型時，比較的是引用而不是真正的對象。也就是說，== 測試兩個引用是否指向同一個對象，而不測試兩個對象的內容是否相同。

在 JDK1.2 后，Java 對引用概念擴充，分為強引用、軟引用、弱引用、虛引用。強度漸弱。

在開始了解前，最好先稍微了解一下Java Memory Model。我的這篇文章中簡單的講了一下JMM

就是值在程序代碼之中普遍存在的，類似 Object obj = new Object() 這類的引用，只要強引用還在，垃圾收集器永遠不會回收掉被引用的對象。

它關聯著的對象，在系統將要發生內存溢出異常之前，將會把這些對象列進回收范圍內進行第二次回收。提供 SoftReference 類來實現軟引用。

強度比軟引用更弱一些，被弱引用關聯的對象只能生存到下一次垃圾收集發生之前。提供 WeakReference 類來實現軟引用。

一個對象是否有虛引用的存在，完全不會對其生存時間構成影響，也無法通過虛引用來去的一個對象實例。為一個對象設置虛引用關聯的唯一目的就是能在這個對象被收集器回收時收到一個系統通知。提供 PhantomReference 類來實現軟引用。

Java 7之基礎 - 強引用、弱引用、軟引用、虛引用

Java垃圾回收機制與引用類型

數組類型不是類，但數組實例是對象。這意味著，數組從 java.lang.Object 類繼承了方法。數組實現了 Cloneable 接口，而且覆蓋了 clone( ) 方法，確保數組始終能被復制，而且 clone( ) 方法從不拋出 CloneNotSupportedException 異常。數組還實現了 Serializable 接口，所以只要數組中元素的類型能被序列化，數組就能被序列化。而且，所有數組都有一個名為 length 的字段，這個字段的修飾符是 public final int，表示數組中元素的數量。

因為數組擴展自 Object 類，而且實現了 Cloneable 和 Serializable 接口，所以任何數組類型都能放大轉換成這三種類型中的任何一種。而且，特定的數組類型還能放大轉換成其他數組類型。如果數組中的元素類型是引用類型 T，而且 T 能指定給類型 S，那么數組類型 T[ ] 就能指定給數組類型 S[ ]。注意，基本類型的數組不能放大轉換。例如，下述代碼展示了合法的數組放大轉換：

String[ ] arrayOfStrings;      // 創建字符串數組
int[ ][ ] arrayOfArraysOfInt;   // 創建int二維數組
Object[ ] oa = arrayOfStrings;// String可以指定給Object，因此String[ ]可以指定給Object[ ]
Comparable[ ] ca = arrayOfStrings;// String實現了Comparable接口,因此String[ ]可以視作Comparable[ ]
Object[ ] oa2 = arrayOfArraysOfInt;// int[ ]是Object類的對象，因此int[ ][ ]可以指定給Object[ ]
// 所有數組都是可以復制和序列化的對象
Object o = arrayOfStrings;
Cloneable c = arrayOfArraysOfInt;
Serializable s = arrayOfArraysOfInt[0];

因為數組類型可以放大轉換成另一種數組類型，所以編譯時和運行時數組的類型并不總是一樣。這種放大轉換叫作"數組協變"（array covariance）。

所以在某種意義上，集合框架比數組好用：

Object [] objectArray = new Long[1];
objectArray[0] = "I dont fit in"; //Throws ArrayStoreException

List