第一章 異常與異常處理

1.1 異常簡介

有異於常態，和正常的情況不一樣，有錯誤出現
阻止當前的方法或作用域

異常的始祖： Throwable

Throwable

• Error 程式錯誤導致崩潰

  虛擬機器錯誤
  執行緒死鎖

• Exception 編碼、環境、使用者操作出現問題

  RunTimeException 非檢查異常（JVM 自動捕獲丟擲）

  NullPointerException
  ArrayIndexOutOfBoundsException
  ClassCastException
  ArithmeticException

  檢查異常 (手工處理)

  IOException
  SQLException
  others…

1.2 使用try-catch-finally 處理異常

注意處理多個異常時的順序，先子類，後父類

try-catch 處理異常後，需要用finally 來執行善後工作，例如關閉檔案，斷開網路或資料庫連線

1.3 Java中的異常丟擲

throw ： 將產生的異常丟擲（動作）
throws： 宣告將要丟擲何種異常 （宣告）

public void 方法名(引數列表) throws 異常列表  {
    //呼叫會丟擲異常的方法；
 

    //或者是直接使用 throw new Exception(); 來丟擲異常 
}

例如，建立一個方法divide，其中當除數為0時會丟擲異常

public void divide(int a, int b) throws Exception {
    if(b == 0) {
        throw new Exception("兩數相除，除數不能為0！");
    } else {
        System.out.println("兩數相除，結果為：" + a/b);
    }

呼叫1： 可以捕獲並處理該異常：

public void compute() {
    /**
     * 省略其他程式碼
     * */
 

     try {
         divide(5,0);
     } catch (Exception e) {
         System.out.println(e.getMessage());
     }
}

呼叫2： 不能處理異常，將其丟擲至上級呼叫，讓上級來處理

public void compute() throws Exception {
    /*
     * 省略其他程式碼
     * /
    divide(5,0);
}

Java 標準類異常

自定義異常

class 自定義異常類 extends 異常型別 {

}

可繼承於Java 類庫中意思相近的異常型別，或是直接繼承於所有異常的基類：Exception類。

簡單的自定義一個異常：

package com.imooc.test;
public class DrunkException extends Exception {
    // 由於下面已經定義一個有參的建構函式，所以系統不會為我們自動生成一個無參的建構函式
    //但我們一般需要無參的建構函式，所以自己新增一個
public DruckException() {

}

//定義一個帶字串的構造器
public DrunckException(String message) {
    //呼叫基類的構造方法即可
    super(message);
}

Java 中的異常鏈

ChainTest類：

package com.imooc.test
public class ChainTest {
    /**
     * test1(): 丟擲“喝大了”異常
     * test2(): 呼叫test1(), 捕獲“喝大了”異常。
     * 並且把test2() 包裝成執行時異常，繼續丟擲
     * main方法中，呼叫test2() 方法，嘗試捕獲test2()方法丟擲的異常
     * /
    public static void main(String[] args){
        //建立ChainTest 的一個例項
        ChianTest ct = new ChainTest();
        try {
             ct.test();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    //丟擲新的異常，所以在test1 後面宣告要丟擲異常
    //沒新增throws DrunkException 會報錯
    public void test1() throws DrunkException {
        //呼叫含參構造器
        throw new DrunkException("喝車別開酒");
    }

    public void test2() {
        try {
            //沒有try-catch 處理時會報錯，因為test1()會丟擲異常
            test1();
        } catch (DrunkException e) {
            RunTimeException newExc = 
                        new RunTimeException("司機一滴酒，親人淚兩行~~");
            newExc.initCause(e);
            throw newExc;
        }
    }
}

執行結果：

另外一種更加簡便的異常鏈使用方法，只需更改test2()方法

public void test2() {
        try {
            //沒有try-catch 處理時會報錯，因為test1()會丟擲異常
            test1();
        } catch (DrunkException e) {
            //直接把捕獲到的異常e 傳遞進去
            RunTimeException newExc =
               new RunTimeException(e);
            //newExc.initCause(e);
            throw newExc;
        }
    }

執行後結果：

Java 異常經驗總結

• 處理執行時異常，採用邏輯去合理規避，同時輔助try-catch處理
• 在多重catch塊後，可以加一個catch（Exception）來處理可能會被遺漏的異常
• 對於不確定的程式碼，也可以加上try-catch，處理潛在的異常
• 儘量去處理異常，切記只是簡單的呼叫printStackTrace() 去列印輸出
• 具體如何處理異常，要根據不同的業務需求和異常型別去決定
• 儘量新增finally語句塊去釋放佔用的資源

第二章 認識Java中的字串

什麼是Java中的字串

在Java中，字串被作為String 型別的物件處理
String 類位於 java.lang 包中。 預設情況下，該包被自動匯入所有的程式。
建立String物件的方法

//建立一個字串物件imooc，名為s1  
String s1 = "imooc";   
//建立一個空字串物件，名為s2  
String s2 = new String();   
//建立一個字串物件imooc，名為s3  
String s3 = new String("imooc");

2.2 Java中字串的不變性

String物件建立後不能被修改，是不可變的；
所謂的修改其實是建立了新的物件，所指向的記憶體空間不同。

String s1 = "imooc";
String s2 = "imooc";
String s3 = new String("imooc");
String s4 = new String("imooc");
//多次出現的字元常量，Java編譯程式只建立一個，所以返回true
System.out.println(s1 == s2);
//s1 和 s3 是不同的物件，返回false
System.out.println(s1 == s3);
//s3和s4是不同的物件，返回false
System.out.println(s3 == s4);
//字串s1被修改，指向新的記憶體空間
s1 = "Welcome to " + s1;
//輸出 Welcome to immoc
System.out.println(s1);

解析：
1、String s1 = “imooc”聲明瞭一個字串物件，s1存放了到字串物件的引用。如圖：

然後通過 s1 = “Welcome to ” + s1;
改變了字串s1，其實質是建立了新的字串物件，變數s1指向了新建立的字串物件，如下圖

2、一旦一個字串在記憶體中建立，則這個字元將不可改變。
想要建立一個可以改變內容的字串，可以使用StringBuilder 和 StringBuffer類。
3、 每次new一個字串就是產生一個新的物件，即使兩個字串的內容相同，使用”==“比較時結果為false。但是利用比較內容的方法equals()才返回true。

2.3 Java中String類的常用方法

String 類提供了許多用來處理字串的方法：
- 獲取字串長度
- 對字串進行擷取
- 將字串轉換為大寫或小寫
- 字串分割等

String 類常用方法：

友情提示：
1. 字串 str 中字元的索引從0開始，範圍為 0 到 str.length()-1
2. 使用 indexOf 進行字元或字串查詢時，如果匹配返回位置索引；如果沒有匹配結果，返回 -1
3. 使用 substring(beginIndex , endIndex) 進行字串擷取時，包括 beginIndex 位置的字元，不包括 endIndex 位置的字元
4. ==: 判斷兩個字串在記憶體中首地址是否相同，即判斷是否是同一個字串物件
equals(): 比較儲存在兩個字串物件中的內容是否一致

Ps: 位元組是計算機儲存資訊的基本單位，1 個位元組等於 8 位， gbk 編碼中 1 個漢字字元儲存需要 2 個位元組，1 個英文字元儲存需要 1 個位元組。所以我們看到上面的程式執行結果中，每個漢字對應兩個位元組值，如“學”對應 “-47 -89” ，而英文字母 “J” 對應 “74” 。同時，我們還發現漢字對應的位元組值為負數，原因在於每個位元組是 8 位，最大值不能超過 127，而漢字轉換為位元組後超過 127，如果超過就會溢位，以負數的形式顯示

認識 Java 中的 StringBuilder 類

在Java中，除了可以使用 String 類來儲存字串，還可以使用 StringBuilder 類或 StringBuffer 類儲存字串

String 類具有是不可變性

String str = "hello";
//輸出 hello world
System.out.println(str + " world");
//輸出 hello
System.out.println(str);

從執行結果中我們可以看到，程式執行時會額外建立一個物件，儲存 “helloworld”。當頻繁操作字串時，就會額外產生很多臨時變數。使用 StringBuilder 或 StringBuffer 就可以避免這個問題。
StringBuilder 和StringBuffer ，它們基本相似，不同之處，
StringBuffer 是執行緒安全的，
StringBuilder 則沒有實現執行緒安全功能，所以效能略高。
因此一般情況下，如果需要建立一個內容可變的字串物件，應優先考慮使用 StringBuilder 類。

StringBuilder 類常用方法：

示例1：

執行結果：
字串長度： 14
插入前： hello imooc520
插入後： hello imooc!520

示例2：

第三章 Java 中必須瞭解的常用類

Java中的包裝類

相信各位小夥伴們對基本資料型別都非常熟悉，例如 int、float、double、boolean、char 等。基本資料型別是不具備物件的特性的，比如基本型別不能呼叫方法、功能簡單。。。，為了讓基本資料型別也具備物件的特性， Java 為每個基本資料型別都提供了一個包裝類，這樣我們就可以像操作物件那樣來操作基本資料型別。

基本型別和包裝類之間的對應關係：

基本型別	對應的包裝類
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

包裝類主要提供了兩大類方法

• 將本型別和其他基本型別進行轉換的方法
• 將字串和本型別及包裝類互相轉換的方法

Integer 包裝類的構造方法：

Integer包裝類的常用方法：

Java中基本型別和包裝類之間的轉換

以 Integer 為例（其他幾個包裝類的操作雷同哦）：
基本型別和包裝類之間經常需要互相轉換，JDK 1.5 引入了自動裝箱和拆箱的機制。使得包裝類和基本型別之間的轉換就更加輕鬆便利了。
裝箱： 基本型別 ==> 包裝類

int i = 10; //定義一個int基本型別
Integer x = new Integer(i); //手動裝箱
Integer y = i; //自動裝箱

拆箱： 包裝類==> 基本型別的值

Integer j = new Integer(8); //定義一個Integer包裝類物件，值為8
int m = j.intValue(); //手動拆箱為int型別
int n = j; // 自動拆箱為int型別

Java 中基本型別和字串之間的轉換

在程式開發中，我們經常需要在基本型別和字串之間進行轉換。
- 基本型別 ==> 字串 有三種方法：
1. 使用包裝類的 toString() 方法
2. 使用String類的 valueOf() 方法
3. 用一個空字串加上基本型別，得到的就是基本型別資料對應的字串

// 將基本型別轉換為 字串
int c = 10;
String str1 = Integer.toString(c); 
String str2 = String.valueOf(c);
String str3 = c + "";

• 字串 ==> 基本型別 有兩種方法
  
  1. 呼叫包裝類的parseXxx 靜態方法
  2. 呼叫包裝類的valueOf() 方法轉換為基本型別的包裝類，會自動裝箱

//將字串轉換為基本型別
String str = "8";
int d = Integer.parseInt(str);
int e = Integer.valueO(str);

PS：其他基本型別與字串的相互轉化這裡不再一一列出，方法都類似

使用Date 和SimpleDateFormat類表示時間

在程式開發中，經常需要處理日期和時間的相關資料 ，這時我們就可以使用java.util包中的Date類。

Date 類的最主要作用就是獲取當前時間：

Date d = new Date(); //使用預設的構造方法建立Date物件
System.out.println(d); //輸出Date物件

使用Date類的預設無參構造方法建立的物件就代表當前時間。
輸出結果為：
Mon Aug 10 09：22：30 CST 2015
//CST China Standard Time

當我們要把時間按照一定格式顯示時，就要使用java.text包中的SimpleDateFormat類了。

SimpleDateFormat類可以將日期轉換為指定格式的文字，也可以將文字轉換為日期。

1. 使用format()方法將日期轉換為指定格式的文字

//建立Date物件，表示當前時間
Date d = new Date();
//建立SimpleDateFormat物件，確定目標格式
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//呼叫format方法，格式化時間，轉換為指定格式字串
String today = sdf.format(d);
// 輸出轉換後的字串，結果是： 2015-08-10 17:17:17
System.out.println(today);

程式碼中的“yyyy-MM-dd HH:mm:ss”為預定義字串。

1. 使用 parse()方法將文字轉換為日期

//建立日期格式字串
String day = "2015年08月10日 17:17:17"
//建立SimpleDateFormat物件，指定字串的日期格式
SimpleDateFormat df = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss")；
//呼叫 parse() 方法，將字串轉換為日期
Date date df.parse(day);
// 輸出轉換後的時間:  Mon Aug 10 09：22：30 CST 2015
System.out.println(date);

Calendar 類的應用

Date類最主要的作用就是獲取當前時間，同時這個類裡面也具有設定時間以及一些其他功能，但是由於本身設計的問題，這些方法受到眾多批評，不建議使用。
推薦使用Calendar類進行時間和日期的處理。
java.util.Calendar 是一個抽象類，可以通過呼叫getInstance() 靜態方法 獲取一個Calendar物件，此物件已由當前日期時間初始化，即預設代表當前時間。

Calendar c = Calendar.getInstance();

獲取Calendar 年月日以及時間資訊的方法：

Calendar c = Calendar.getInstance();
int year = c.get(Calendar.YEAR);
int month = c.get(Calendar.MONTH) + 1;  //0表示1月
int day = c.get(Calendar.DAY_OF_MONTH);
int hour = c.get(Calendar.HOUR_OF_DAY);
int minute = c.get(Calendar.MINUTE);
int second = c.get(Calendar.SECOND);

Calendar 類提供了getTime() 方法，用來獲取Date物件，完成Calendar 和 Date的轉換。
Calendar 類還可以通過getTimeInMillis() 方法 獲取此Calendar 的時間值，一毫秒為單位。

Calendar c = Calendar.getInstance();
Date date = c.getTime();  //將calendar 物件轉換為Date 物件
Long time = c.getTimeInMillis(); 獲取當前毫秒數
System.out.println(date)；
System.out.print(time);

執行結果：
Wed Jun 11 11:26:59 CST 2014
1402457219381

使用Math類操作資料

Math 類位於 java.lang包中，包含用於執行基本數學運算的方法。
Math類的所有方法都是靜態方法，所以使用該類的方法時，可以直接使用
類名.方法名 來直接呼叫。

常用方法：

返回值	方法名	解釋
long	round()	返回四捨五入後的整數
double	floor()	返回小於引數的最大整數
double	ceil()	返回大於引數的最小整數
double	random()	返回[0，1)之間的隨機浮點數

示例：

double a = 12.81;
int b =  (int) a;  //去掉小數部分： 12
long c = Math.round(a); //13
double d = Math.floor(a); // 12.0
double e = Math.ceil(a); // 13.0
double x = Math.random(a); //0.42585849456602687
int y = (int)(Math.random(a) * 99); //45

第四章 Java 中的集合框架

4.1 Java中的集合框架概述

集合概述： Java 中的集合類，是一種工具類。就像是容器，儲存任意數量的具有共同屬性的物件。

集合的作用
- 在類的內部，對資料進行組織；
- 簡單而快速的搜尋大量的條目；
- 有的集合介面，提供了一系列排列有序的元素，並且可以在序列中間快速的插入或刪除有關元素；
- 有的集合介面，提供了對映關係，可以通過關鍵字（key）去快速查詢到對應的唯一物件，而這個關鍵字可以是任意型別的。

為什麼選擇集合而不選擇陣列：
1. 陣列的長度固定，集合長度可變；
2. 陣列只能通過下標訪問元素，型別是固定的； 而 有的集合可以通過任意型別查詢所對映的具體物件。

Java 集合框架體系結構：
- Collection (直接儲存物件)
- List 序列 ：有序，可重複
- ArrayList 陣列序列 //常用
- LinkedList 連結串列
- Queue 佇列 ： 有序，可重複
- LinkedList 連結串列
- Set 集 ： 無序，不可重複
- HashSet 雜湊集 //常用
- Map （內部對映 Entry < Key,Value>）
-
-HashMap 雜湊表 //常用

4.2 Collection 介面、子介面以及實現類

Collection 介面

• 是List、Queue和Set介面的父介面
• 定義了可用於操作List，Queue和Set 的方法 —增刪改查

List介面及其實現類ArrayList

• List是元素有序並且可以重複的集合，被稱為序列；
• List可以精確的控制每個元素的插入位置，或刪除某個位置的元素；
• ArrayList 陣列序列，是List的一個重要實現類；
• ArrayList 底層是由陣列實現的。

注意：
- 物件存入集合都會忽略其原有的型別，都變成Object型別。從集合中取出物件時需要型別轉換。

集合遍歷

List ： get 方法，forEach，Iterator
Set ： forEach，Iterator

Set不能用get(), 因為Set為無序的
每次遍歷Set集合得到的順序不相同。

ForEach

Iterator

get() 方法

List中set（index，Object） 方法

List中刪除方法

泛型

在集合可以儲存任意型別的物件（物件的引用）。
- 把某個物件放入集合是，會直接忽略其型別，直接當做Object型別。

泛型規定了某個集合只能儲存特定型別及其子型別的元素。
- 會在編譯期間進行型別檢查
- 可以直接按指定型別獲取集合中的物件
- 儲存除指定型別及其子型別外的物件，程式會報錯。

泛型集合中的限定型別不能是基本型別，但可以通過使用它們的包裝類限定允許存入的基本型別。
int –> Integer
long –> Long
boolean –> Boolean

Set 介面及其實現類 HashSet

• Set 是元素無序，並且不可重複的，稱為集
• HashSet
• Set 中沒有 set() 方法來修改某個元素
  Set中新增物件，無論新增多少次，最終只會保留該物件第一次新增的那一個引用。
  Set中可以新增null 物件

Map和HashMap

Map 介面提供了一種對映關係，其中的元素是以鍵值對（key-value）的形式儲存的，能夠根據key快速找到value。
- Map中的鍵值對以Entry型別的物件例項形式存在。
- key不能重複，value可以重複
- 每個鍵最多隻能對映到一個值。
- Map提供了分別返回key值集合，value值集合以及Entry集合的方法，可以用來遍歷
- Map支援泛型 Map<K,V>

HashMap
- HashMap 是Map的一個重要實現類，也是最常用的一個，基於雜湊表實現
- HashMap中的Entry 物件時無序排列的，遍歷時得到的順序不一樣。
- Key值和value值都可以為null，但是一個 HashMap 最多隻能有一個null的key值。

Arrays 工具類

包含運算元組的各種靜態方法

Collections 工具類

java.util.Collections
提供靜態方法操作集合的物件，也是Java集合框架的成員
最常用的是Collections.sort() 方法

Comparable & Comparator

Comparable 介面 — 可比較的 – 預設的比較規則

• 實現該介面表示：這個類的例項可以比較大小，可以進行自然排序
• 定義了預設的比較規則
• 其實現類需要實現compareTo() 方法 public int comparaTo(T t) { }
• compareTo() 方法返回正數表示大於，返回負數表示小於，返回0表示等於。

Comparator 介面 — 比較工具介面 – 臨時的比較規則

• 用於實現臨時比較規則，而不是預設比較規則
• 其實現類需要實現compare() 方法 public int compare(T t1, T t2) { }
• Comparator 和 Comparable 都是Java集合框架的成員。
• 可以將Comparator 傳遞給 sort方法。

Java 集合框架

• Collection介面
• Collections 工具類
• Map 介面
• Compatator 介面
• Comparable 介面