這輩子沒辦法做太多事情，是以每一件都要做到精彩絕倫！
People can't do too many things in my life,so everything will be wonderful
本資料隻進行簡單介紹說明以及相關重要問題的解答；關于類的詳細說明及使用請參考java API文檔
應用程式程式設計接口Application Programming Interface
就是jdk提供給我們的一些提高程式設計效率的java類
Object類概述：類層次結構的根類；所有類都直接或間接的繼承自該類
構造方法：public Object() 子類的構造方法預設通路的是父類的無參構造方法。
檢視API文檔和源碼：
2.1.1.1 hashCode
public int hashCode();
1，傳回該對象的哈希碼值。預設情況下，該方法會根據對象的位址值通過雜湊演算法計算出來一個整數值。
2，不同對象的，hashCode()一般不會相同；但是同一個對象的hashCode()值肯定相同。
public final Class getClass();//可以了解為：位元組碼檔案類，編譯後的class類
1，傳回此Object的運作時類；（該類的對象）
2，可以通過Class類中的一個方法，擷取對象的真實類的全名稱：
public StringgetName();//以String的形式傳回此Class對象所表示的實體（類、接口、數組類、基本類型或 void）名稱。
2.1.1.2 toString
public String toString();
1,傳回該對象的字元串表示；底層源碼：實際傳回的值是：
public String toString() {
return getClass().getName() +"@" + Integer.toHexString(hashCode());
}
Integer.toHexString(hashCode())//将一個整數轉化為16進制的字元串
2，預設情況下的資料對我們來說沒有意義，一般重寫該方法：手動重寫或自動重寫
2.1.1.3 equals
public boolean equals(Object obj);
源碼：publicboolean equals(Object obj) {
return (this ==obj);
}
1，訓示其他某個對象是否與此對象“相等”。
2，equals 方法在非空對象引用上實作相等關系： （預設情況下比較的是對象的引用是否相同，也就是比較位址值）
自反性：對于任何非空引用值 x，x.equals(x) 都應傳回 true。
對稱性：對于任何非空引用值 x 和 y，當且僅當 y.equals(x) 傳回 true 時，x.equals(y) 才應傳回 true。
傳遞性：對于任何非空引用值 x、y 和 z，如果 x.equals(y) 傳回 true，并且 y.equals(z) 傳回 true，那麼 x.equals(z) 應傳回 true。
一緻性：對于任何非空引用值 x 和 y，多次調用 x.equals(y) 始終傳回 true 或始終傳回 false，前提是對象上 equals 比較中所用的資訊沒有被修改。
對于任何非空引用值 x，x.equals(null) 都應傳回 false。
Object 類的 equals 方法實作對象上差别可能性最大的相等關系；即，對于任何非空引用值 x 和 y，當且僅當 x 和 y 引用同一個對象時，此方法才傳回 true（x == y 具有值 true）。
3，由于比較對象的引用沒有意義，一般重寫該方法：手動或自動重寫（比較類中的成員變量的值是否相同，String類重寫了Object的equals方法，比較數值是否相同）
注意：當此方法被重寫時，通常有必要重寫 hashCode 方法，以維護 hashCode 方法的正常協定，該協定聲明相等對象必須具有相等的哈希碼。
protected void finalize();
1，當垃圾回收器确定不存在對該對象的更多引用時，由對象的垃圾回收器調用此方法。子類重寫<code>finalize</code>方法，以配置系統資源或執行其他清除。
2，垃圾回收器不會馬上回收垃圾，但是我們可以建議它盡快回收垃圾（System.gc()方法）
3，主要針對堆記憶體。
protected Object clone();
1， 建立并傳回此對象的一個副本，這種克隆機制十分高效，而且二者之間完全隔離
2， 自定義實作克隆步驟：
自定義類實作Cloneable接口，這是一個标記性接口，實作這個接口的類的對象可以實作自我克隆；
自定義類中重寫Object類的clone（）方法；
重寫clone（）方法時通過super.clone()調用Object的clone()方法得到該對象的副本，并傳回副本。
3，注意：A:克隆和兩個引用指向同一個對象的差別?位址值不一樣
B:Object類clone()方法雖然簡單，易用，但僅僅是一種”淺克隆”,它隻克隆該對象所有的Field值，不會
對引用類型的Field所引用的對象進行克隆。開發中，我們也可以實作對象的”深度克隆”。
注意
直接輸出一個對象名稱，其實預設調用了該對象的toString()方法。
(1)在JDK5以後出現的用于鍵盤錄入資料的類。
(2)構造方法：
A:講解了System.in這個東西。
它其實是标準的輸入流,對應于鍵盤錄入
B:構造方法
InputStreamis = System.in;
Scanner(InputStreamis)
C:常用的格式
Scannersc = new Scanner(System.in);
(3)基本方法格式：
A:hasNextXxx()判斷是否是某種類型的
B:nextXxx() 傳回某種類型的元素
(4)要掌握的兩個方法
A:publicint nextInt()
B:publicString nextLine()
(5)需要注意的小問題
A:同一個Scanner對象，先擷取數值，再擷取字元串會出現一個小問題。
B:解決方案：
a:重新定義一個Scanner對象
b:把所有的資料都用字元串擷取，然後再進行相應的轉換
String概述及構造方法
概述：字元串是由多個字元組成的一串資料（字元序列），字元串可以看成是字元數組
構造方法：
public String();
public String(byte[] bytes)
public String(byte[] bytes,int offset,intlength)
public String(char[] value)
public String(char[] value,int offset,intcount)
public String(String original)
<code>String</code>類代表字元串。Java 程式中的所有字元串字面值（如<code>"abc"</code>）都作為此類的執行個體實作。
例：String s=”abc” ; s也是一個對象。
字元串是常量，它的值在建立之後不能更改
<a href="https://s2.51cto.com/wyfs02/M00/91/51/wKioL1j1cdjSE2kZAABTmHebFTE148.png" target="_blank"></a>
new字元串和直接複制的差別
前者建立2個對象，後者建立1個對象。
<a href="https://s5.51cto.com/wyfs02/M00/91/52/wKiom1j1ceHzXnR-AABEHWgEANY429.png" target="_blank"></a>
注意：字元串中的equals()方法重寫了Object()的方法，比較的是内容。
内容相同，引用不同。
具體成員方法參考API
概述：如果對字元串進行拼接操作，每次拼接，都會建構義一個新的String對象，既耗時，又浪費空間。而StringBuffer可以解決這個問題。
它是線程安全的可變字元序列。
排序
冒泡排序
相鄰元素兩兩比較，大的往後放，第一次完畢，最大值出現在了最大索引處
public static void bubbleSort(int[] arr) {
for(intx=0; x<arr.length-1; x++) {
for(inty=0; y<arr.length-1-x; y++) {
if(arr[y]> arr[y+1]) {
inttemp = arr[y];
arr[y]= arr[y+1];
arr[y+1]= temp;
}
}
}
}
<a href="https://s2.51cto.com/wyfs02/M01/91/52/wKiom1j1ce3hRyKPAABnAnP3Nu8269.png" target="_blank"></a>
選擇排序
從0索引開始，依次和後面元素比較，小的往前放，第一次完畢，最小值出現在了最小索引處
public static void selectSort(int[] arr) {
for(inty=x+1; y<arr.length; y++) {
if(arr[y]< arr[x]) {
inttemp = arr[x];
arr[x]= arr[y];
arr[y]= temp;
}
<a href="https://s5.51cto.com/wyfs02/M01/91/51/wKioL1j1cfjRQO2xAABnxiGFUPQ585.png" target="_blank"></a>
查找：
基本查找：數組元素無序
public static int getIndex(int[] arr,int value) {
intindex = -1;
for(intx=0; x<arr.length; x++) {
if(arr[x]== value) {
index= x;
break;
returnindex;
二分查找：數組元素有序
public static int binarySearch(int[] arr,int value) {
intmin = 0;
intmax = arr.length-1;
intmid = (min+max)/2;
while(arr[mid]!= value) {
if(arr[mid]> value) {
max= mid - 1;
}elseif(arr[mid] < value) {
min= mid + 1;
if(min> max) {
return-1;
mid= (min+max)/2;
returnmid;
<a href="https://s4.51cto.com/wyfs02/M02/91/51/wKioL1j1cgSSAdr4AABTnPJB3pA425.png" target="_blank"></a>
概述：針對數組進行操作的工具類，提供了排序、查找等功能
常用方法：
把數組轉成字元串：public static String toString(數組);
排序：public static void sort();底層是快速排序法
二分查找：public static int binarySearch(數組，key);
将基本資料類型封裝成對象的好處在于：可以在對象中定義更多的功能方法操作該資料。
常用的操作之一：用于基本資料類型與字元串之間的轉換；
為了讓基本類型的資料進行更多的操作，Java就為每種基本類型提供了對應的包裝類類型
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean
Integer成員方法：其中一部分可以進行常用的進制轉換；（2~36進制）
JDK5的新特性：
自動拆裝箱：
自動裝箱 基本類型--引用類型
自動拆箱 引用類型--基本類型
Integer x = new Integer(4);可以直接寫成
Integer x = 4;//自動裝箱。
x = x + 5;//自動拆箱。通過intValue方法。
注意：在使用時，Integer x=null;上面的代碼就會NPE異常。
是指一個用來描述或比對一系列符合某個句法規則的字元串的單個字元串。
規則字元在java.util.regexPattern類中
常見規則
A:字元
x字元 x。舉例：'a'表示字元a
\\反斜線字元。
\n新行（換行）符 ('\u000A')
\r回車符 ('\u000D')
B:字元類
[abc]a、b 或 c（簡單類）
[^abc]任何字元，除了 a、b 或 c（否定）
[a-zA-Z]a到 z 或 A到 Z，兩頭的字母包括在内（範圍）
[0-9]0到9的字元都包括
C:預定義字元類
.任何字元。我的就是.字元本身，怎麼表示呢? \.
\d數字：[0-9]
\w單詞字元：[a-zA-Z_0-9]
在正規表達式裡面組成單詞的東西必須有這些東西組成
D:邊界比對器
^行的開頭
$行的結尾
\b單詞邊界
就是不是單詞字元的地方。
舉例：helloworld?haha;xixi
E:Greedy數量詞
X?X，一次或一次也沒有
X*X，零次或多次
X+X，一次或多次
X{n}X，恰好 n 次
X{n,}X，至少 n 次
X{n,m}X，至少 n 次，但是不超過 m 次
(1)月曆類，封裝了所有的月曆字段值，通過統一的方法根據傳入不同的月曆字段可以擷取值。
(2)如何得到一個月曆對象呢?
CalendarrightNow = Calendar.getInstance();
本質傳回的是子類對象
(3)成員方法
A:根據月曆字段得到對應的值publicint get(int field)
B:根據月曆字段和一個正負數确定是添加還是減去對應月曆字段的值public void add(int field,int amount)
C:設定月曆對象的年月日publicfinal void set(int year,int month,int date)
數組既可以存儲基本資料類型，也可以存儲引用類型。它存儲引用類型的時候的數組就叫對象數組。
A:==
基本類型：比較的是值是否相同
引用類型：比較的是位址值是否相同
B:equals()
隻能比較引用類型。預設情況下，比較的是位址值是否相同。
但是，我們可以根據自己的需要重寫該方法。一般重寫該方法比較的是成員變量是否相同。
A:==和equals()
Strings1 = new String("hello");
Strings2 = new String("hello");
System.out.println(s1== s2);// false
System.out.println(s1.equals(s2));//true
Strings3 = new String("hello");
Strings4 = "hello";
System.out.println(s3== s4);// false
System.out.println(s3.equals(s4));//true
Strings5 = "hello";
String s6 ="hello";
System.out.println(s5== s6);// true
System.out.println(s5.equals(s6));//true
B:字元串的拼接
Strings1 = "hello";
Strings2 = "world";
Strings3 = "helloworld";
System.out.println(s3== s1 + s2);// false
System.out.println(s3.equals((s1+ s2)));// true
System.out.println(s3== "hello" + "world");// false 這個我們錯了，應該是true
System.out.println(s3.equals("hello"+ "world"));// true
String:不可變的字元序列；
StringBuffer:線程安全的可變字元序列；
StringBuilder：線程不安全的可變字元序列；
三者在執行速度方面的比較：StringBuilder > StringBuffer > String
對于三者使用的總結： 1.如果要操作少量的資料用 = String
2.單線程操作字元串緩沖區下操作大量資料 = StringBuilder
3.多線程操作字元串緩沖區下操作大量資料 = StringBuffer
看程式，寫結果：
Integer i1=128;
Integer i2=128;
i1=i2;//false
il.equals(i2);//true 重寫了Object的equals方法，比較的是數值是否相同。
Integer i3=127;
Integer i4=127;
i3=i4;//true
檢視Integer源碼：
public static Integer valueOf(int i) {
assert IntegerCache.high >= 127;
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
跟蹤IntegerCache
IntegerCache.low=-128
IntegerCache.high=127
private static class IntegerCache {
static final int low = -128;
static final int high;
static final Integer cache[];
static {
// high value may be configured by property
int h = 127;
String integerCacheHighPropValue =
sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
if (integerCacheHighPropValue != null) {
int i =parseInt(integerCacheHighPropValue);
i = Math.max(i, 127);
// Maximum array size isInteger.MAX_VALUE
h = Math.min(i,Integer.MAX_VALUE - (-low) -1);
}
high = h;
cache = new Integer[(high - low) + 1];
int j = low;
for(int k = 0; k < cache.length; k++)
cache[k] = new Integer(j++);
}
private IntegerCache() {}
上述代碼延伸：
assert：斷言
編寫代碼時，我們總是會做出一些假設，斷言就是用于在代碼中捕捉這些假設，可以将斷言看作是異常處理的一種進階形式。斷言表示為一些布爾表達式，程式員相信在程式中的某個特定點該表達式值為真。可以在任何時候啟用和禁用斷言驗證，是以可以在測試時啟用斷言，而在部署時禁用斷言。同樣，程式投入運作後，最終使用者在遇到問題時可以重新起用斷言。
斷言特性
前置條件斷言：代碼執行之前必須具備的特性
後置條件斷言：代碼執行之後必須具備的特性
前後不變斷言：代碼執行前後不能變化的特性
本文轉自 wyait 51CTO部落格，原文連結：http://blog.51cto.com/wyait/1916877，如需轉載請自行聯系原作者
![Java String.format方法的簡單使用[圖]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)