慕課網 Java 入門第三季學習筆記

第一章異常與異常處理

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類可以將日期轉換爲指定格式的文本，也可以將文本轉換爲日期。

使用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”爲預定義字符串。

使用 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 接口

linyk3

發佈了34 篇原創文章 · 獲贊 25 · 訪問量 4萬+

私信關注

慕課網 Java 入門 第三季 學習筆記

第一章 異常與異常處理