java基礎知識---jdk5新特性

Jdk5.0新特性：

Collection在jdk1.5以後，有了一個父介面Iterable，這個介面的出現的將iterator方法進行抽取，提高了擴充性。

--------------------------------------------------

增強for迴圈：foreach語句，foreach簡化了迭代器。

格式：// 增強for迴圈括弧裡寫兩個參數，第一個是聲明一個變數，第二個就是需要迭代的容器

for( 元素類型 變數名 :Collection集合 & 數組 ) {

  …

}

進階for迴圈和傳統for迴圈的區別：

進階for迴圈在使用時，必須要明確被遍曆的目標。這個目標，可以是Collection集合或者數組，如果遍曆Collection集合，在遍曆過程中還需要對元素進行操作，比如刪除，需要使用迭代器。

如果遍曆數組，還需要對數組元素進行操作，建議用傳統for迴圈因為可以定義角標通過角標操作元素。如果只為遍曆擷取，可以簡化成進階for迴圈，它的出現為了簡化書寫。

 

進階for迴圈可以遍曆map集合嗎。不可以。但是可以將map轉成set後再使用foreach語句。

 

1)、作用：對儲存物件的容器進行迭代： 數組  collection  map

2)、增強for迴圈迭代數組：

String[] arr = {"a", "b", "c"};//數組的靜態定義方式，只試用於數組首次定義的時候

for(Strings : arr) {

  System.out.println(s); 

}

3)、單列集合 Collection：

Listlist = new ArrayList();

list.add("aaa");

// 增強for迴圈, 沒有使用泛型的集合能不能使用增強for迴圈迭代。能

for(Object obj : list) {

  String s = (String) obj;

  System.out.println(s);

}

4)、雙列集合 Map：

Map map= new HashMap();

map.put("a","aaa");

// 傳統方式：必須掌握這種方式

Setentrys = map.entrySet(); // 1.獲得所有的索引值對Entry對象

iter =entrys.iterator(); // 2.迭代出所有的entry

while(iter.hasNext()){

  Map.Entry entry = (Entry) iter.next();

  String key = (String) entry.getKey(); // 分別獲得key和value

  String value = (String) entry.getValue();

  System.out.println(key + "=" +value);

}

// 增強for迴圈迭代：原則上map集合是無法使用增強for迴圈來迭代的，因為增強for迴圈只能針對實現了Iterable介面的集合進行迭代；Iterable是jdk5中新定義的介面，就一個方法iterator方法，只有實現了Iterable介面的類，才能保證一定有iterator方法，java有這樣的限定是因為增強for迴圈內部還是用迭代器實現的，而實際上，我們可以通過某種方式來使用增強for迴圈。

for(Object obj : map.entrySet()) {

  Map.Entryentry = (Entry) obj;  // obj 依次表示Entry

  System.out.println(entry.getKey()+ "=" + entry.getValue());

}

5）、集合迭代注意問題：在迭代集合的過程中，不能對集合進行增刪操作（會報並發訪問異常）；可以用迭代器的方法進行操作（子類listIterator：有增刪的方法）。

6)、增強for迴圈注意問題：在使用增強for迴圈時，不能對元素進行賦值；

int[]arr = {1,2,3};

for(intnum : arr) {

  num = 0; //不能改變數組的值

}

System.out.println(arr[1]);//2

--------------------------------------------------

可變參數（...）：用到函數的參數上，當要操作的同一個類型元素個數不確定的時候，可是用這個方式，這個參數可以接受任意個數的同一類型的資料。

 

和以前接收數組不一樣的是：

以前定義數群組類型，需要先建立一個數組對象，再將這個數組對象作為參數傳遞給函數。現在，直接將數組中的元素作為參數傳遞即可。底層其實是將這些元素進行數組的封裝，而這個封裝動作，是在底層完成的，被隱藏了。所以簡化了使用者的書寫，少了調用者定義數組的動作。

如果在參數列表中使用了可變參數，可變參數必須定義在參數列表結尾(也就是必須是最後一個參數，否則編譯會失敗。)。

如果要擷取多個int數的和呢。可以使用將多個int數封裝到數組中，直接對數組求和即可。

---------------------------------------------------

靜態匯入：匯入了類中的所有靜態成員，簡化靜態成員的書寫。

import static java.util.Collections.*;  //匯入了Collections類中的所有靜態成員

---------------------------------------------------

枚舉：關鍵字enum

問題：對象的某個屬性的值不能是任意的，必須為固定的一組取值其中的某一個；

解決辦法：

1）、在setGrade方法中做判斷，不符合格式要求就拋出異常；

2）、直接限定使用者的選擇，通過自訂類類比枚舉的方式來限定使用者的輸入，寫一個Grade類，私人建構函式，對外提供5個靜態常量表示類的執行個體；

3)、jdk5中新定義了枚舉類型，專門用於解決此類問題；

4)、枚舉就是一個特殊的java類，可以定義屬性、方法、建構函式、實現介面、繼承類；

------------------------------------------------------------------------------

自動拆裝箱：java中資料類型分為兩種 ： 基礎資料型別 (Elementary Data Type)   引用資料類型(對象)

在 java程式中所有的資料都需要當做對象來處理，針對8種基礎資料型別 (Elementary Data Type)提供了封裝類，如下：

int --> Integer

byte --> Byte

short --> Short

long --> Long

char --> Character

double --> Double

float --> Float

boolean --> Boolean

 

jdk5以前基礎資料型別 (Elementary Data Type)和封裝類之間需要互轉：

基本---引用  Integer x = new Integer(x);

引用---基本  int num = x.intValue();

1)、Integer x =1; x = x + 1;  經曆了什麼過程。裝箱 à 拆箱 à 裝箱；

2)、為了最佳化，虛擬機器為封裝類提供了緩衝池，Integer池的大小 -128~127 一個位元組的大小；

3)、String池：Java為了最佳化字串操作 提供了一個緩衝池；

----------------------------------------------------------

泛型：jdk1.5版本以後出現的一個安全機制。表現格式：<>

好處：

1：將運行時期的問題ClassCastException問題轉換成了編譯失敗，體現在編譯時間期，程式員就可以解決問題。

2：避免了強制轉換的麻煩。

 

只要帶有<>的類或者介面，都屬於帶有型別參數的類或者介面，在使用這些類或者介面時，必須給<>中傳遞一個具體的引用資料類型。

 

泛型技術：其實應用在編譯時間期，是給編譯器使用的技術，到了運行時期，泛型就不存在了。

為什麼? 因為泛型的擦除：也就是說，編輯器檢查了泛型的類型正確後，在產生的類檔案中是沒有泛型的。

在運行時，如何知道擷取的元素類型而不用強轉呢。

泛型的補償：因為儲存的時候，類型已經確定了是同一個類型的元素，所以在運行時，只要擷取到該元素的類型，在內部進行一次轉換即可，所以使用者不用再做轉換動作了。

 

什麼時候用泛型類呢。

當類中的操作的引用資料類型不確定的時候，以前用的Object來進行擴充的，現在可以用泛型來表示。這樣可以避免強轉的麻煩，而且將運行問題轉移到的編譯時間期。

----------------------------------------------------------

泛型在程式定義上的體現：

//泛型類：將泛型定義在類上。

class Tool<Q> {

    private Q obj;

    public  void setObject(Q obj) {

        this.obj = obj;

    }

    public Q getObject() {

        return obj;

    }

}

//當方法操作的引用資料類型不確定的時候，可以將泛型定義在方法上。

    public <W> voidmethod(W w) {

        System.out.println("method:"+w);

    }

//靜態方法上的泛型：靜態方法無法訪問類上定義的泛型。如果靜態方法操作的引用資料類型不確定的時候，必須要將泛型定義在方法上。

    public static<Q> void function(Q t) {

        System.out.println("function:"+t);

    }

//泛型介面.

interface Inter<T> {

    void show(T t);

}

class InterImpl<R> implements Inter<R> {

    public void show(R r) {

        System.out.println("show:"+r);

    }

}

------------------------------------------------------------

泛型中的萬用字元：可以解決當具體類型不確定的時候，這個萬用字元就是 ?  ；當操作類型時，不需要使用類型的具體功能時，只使用Object類中的功能。那麼可以用 ? 萬用字元來表未知類型。

 

泛型限定：

    上限：。extends E：可以接收E類型或者E的子類型對象。

    下限：。super E：可以接收E類型或者E的父類型對象。

 

上限什麼時候用：往集合中添加元素時，既可以添加E類型對象，又可以添加E的子類型對象。為什麼。因為取的時候，E類型既可以接收E類對象，又可以接收E的子類型對象。

 

下限什麼時候用：當從集合中擷取元素進行操作的時候，可以用當前元素的類型接收，也可以用當前元素的父類型接收。

 

泛型的細節：

1）、泛型到底代表什麼類型取決於調用者傳入的類型，如果沒傳，預設是Object類型；

2）、使用帶泛型的類建立對象時，等式兩邊指定的泛型必須一致；

    原因：編譯器檢查對象調用方法時只看變數，然而程式運行期間調用方法時就要考慮對象具體類型了；

3）、等式兩邊可以在任意一邊使用泛型，在另一邊不使用(考慮向後相容)；

ArrayList<String>al = new ArrayList<Object>();  //錯

//要保證左右兩邊的泛型具體類型一致就可以了，這樣不容易出錯。

ArrayList<?extends Object> al = new ArrayList<String>();

al.add("aa");  //錯

//因為集合具體對象中既可儲存String，也可以儲存Object的其他子類，所以添加具體的類型對象不合適，類型檢查會出現安全問題。 。extendsObject 代表Object的子類型不確定，怎麼能添加具體類型的對象呢。

public static voidmethod(ArrayList<? extends Object> al) {

al.add("abc");  //錯

  //只能對al集合中的元素調用Object類中的方法，具體子類型的方法都不能用，因為子類型不確定。

}

------------------------------------------------------------------------------------------------------------------------------------------------

Jdk5.0新特性：

Collection在jdk1.5以後，有了一個父介面Iterable，這個介面的出現的將iterator方法進行抽取，提高了擴充性。

--------------------------------------------------

增強for迴圈：foreach語句，foreach簡化了迭代器。

格式：// 增強for迴圈括弧裡寫兩個參數，第一個是聲明一個變數，第二個就是需要迭代的容器

for( 元素類型 變數名 :Collection集合 & 數組 ) {

  …

}

進階for迴圈和傳統for迴圈的區別：

進階for迴圈在使用時，必須要明確被遍曆的目標。這個目標，可以是Collection集合或者數組，如果遍曆Collection集合，在遍曆過程中還需要對元素進行操作，比如刪除，需要使用迭代器。

如果遍曆數組，還需要對數組元素進行操作，建議用傳統for迴圈因為可以定義角標通過角標操作元素。如果只為遍曆擷取，可以簡化成進階for迴圈，它的出現為了簡化書寫。

 

進階for迴圈可以遍曆map集合嗎。不可以。但是可以將map轉成set後再使用foreach語句。

 

1)、作用：對儲存物件的容器進行迭代： 數組  collection  map

2)、增強for迴圈迭代數組：

String[] arr = {"a", "b", "c"};//數組的靜態定義方式，只試用於數組首次定義的時候

for(Strings : arr) {

  System.out.println(s); 

}

3)、單列集合 Collection：

Listlist = new ArrayList();

list.add("aaa");

// 增強for迴圈, 沒有使用泛型的集合能不能使用增強for迴圈迭代。能

for(Object obj : list) {

  String s = (String) obj;

  System.out.println(s);

}

4)、雙列集合 Map：

Map map= new HashMap();

map.put("a","aaa");

// 傳統方式：必須掌握這種方式

Setentrys = map.entrySet(); // 1.獲得所有的索引值對Entry對象

iter =entrys.iterator(); // 2.迭代出所有的entry

while(iter.hasNext()){

  Map.Entry entry = (Entry) iter.next();

  String key = (String) entry.getKey(); // 分別獲得key和value

  String value = (String) entry.getValue();

  System.out.println(key + "=" +value);

}

// 增強for迴圈迭代：原則上map集合是無法使用增強for迴圈來迭代的，因為增強for迴圈只能針對實現了Iterable介面的集合進行迭代；Iterable是jdk5中新定義的介面，就一個方法iterator方法，只有實現了Iterable介面的類，才能保證一定有iterator方法，java有這樣的限定是因為增強for迴圈內部還是用迭代器實現的，而實際上，我們可以通過某種方式來使用增強for迴圈。

for(Object obj : map.entrySet()) {

  Map.Entryentry = (Entry) obj;  // obj 依次表示Entry

  System.out.println(entry.getKey()+ "=" + entry.getValue());

}

5）、集合迭代注意問題：在迭代集合的過程中，不能對集合進行增刪操作（會報並發訪問異常）；可以用迭代器的方法進行操作（子類listIterator：有增刪的方法）。

6)、增強for迴圈注意問題：在使用增強for迴圈時，不能對元素進行賦值；

int[]arr = {1,2,3};

for(intnum : arr) {

  num = 0; //不能改變數組的值

}

System.out.println(arr[1]);//2

--------------------------------------------------

可變參數（...）：用到函數的參數上，當要操作的同一個類型元素個數不確定的時候，可是用這個方式，這個參數可以接受任意個數的同一類型的資料。

 

和以前接收數組不一樣的是：

以前定義數群組類型，需要先建立一個數組對象，再將這個數組對象作為參數傳遞給函數。現在，直接將數組中的元素作為參數傳遞即可。底層其實是將這些元素進行數組的封裝，而這個封裝動作，是在底層完成的，被隱藏了。所以簡化了使用者的書寫，少了調用者定義數組的動作。

如果在參數列表中使用了可變參數，可變參數必須定義在參數列表結尾(也就是必須是最後一個參數，否則編譯會失敗。)。

如果要擷取多個int數的和呢。可以使用將多個int數封裝到數組中，直接對數組求和即可。

---------------------------------------------------

靜態匯入：匯入了類中的所有靜態成員，簡化靜態成員的書寫。

import static java.util.Collections.*;  //匯入了Collections類中的所有靜態成員

---------------------------------------------------

枚舉：關鍵字enum

問題：對象的某個屬性的值不能是任意的，必須為固定的一組取值其中的某一個；

解決辦法：

1）、在setGrade方法中做判斷，不符合格式要求就拋出異常；

2）、直接限定使用者的選擇，通過自訂類類比枚舉的方式來限定使用者的輸入，寫一個Grade類，私人建構函式，對外提供5個靜態常量表示類的執行個體；

3)、jdk5中新定義了枚舉類型，專門用於解決此類問題；

4)、枚舉就是一個特殊的java類，可以定義屬性、方法、建構函式、實現介面、繼承類；

------------------------------------------------------------------------------

自動拆裝箱：java中資料類型分為兩種 ： 基礎資料型別 (Elementary Data Type)   引用資料類型(對象)

在 java程式中所有的資料都需要當做對象來處理，針對8種基礎資料型別 (Elementary Data Type)提供了封裝類，如下：

int --> Integer

byte --> Byte

short --> Short

long --> Long

char --> Character

double --> Double

float --> Float

boolean --> Boolean

 

jdk5以前基礎資料型別 (Elementary Data Type)和封裝類之間需要互轉：

基本---引用  Integer x = new Integer(x);

引用---基本  int num = x.intValue();

1)、Integer x =1; x = x + 1;  經曆了什麼過程。裝箱 à 拆箱 à 裝箱；

2)、為了最佳化，虛擬機器為封裝類提供了緩衝池，Integer池的大小 -128~127 一個位元組的大小；

3)、String池：Java為了最佳化字串操作 提供了一個緩衝池；

----------------------------------------------------------

泛型：jdk1.5版本以後出現的一個安全機制。表現格式：<>

好處：

1：將運行時期的問題ClassCastException問題轉換成了編譯失敗，體現在編譯時間期，程式員就可以解決問題。

2：避免了強制轉換的麻煩。

 

只要帶有<>的類或者介面，都屬於帶有型別參數的類或者介面，在使用這些類或者介面時，必須給<>中傳遞一個具體的引用資料類型。

 

泛型技術：其實應用在編譯時間期，是給編譯器使用的技術，到了運行時期，泛型就不存在了。

為什麼? 因為泛型的擦除：也就是說，編輯器檢查了泛型的類型正確後，在產生的類檔案中是沒有泛型的。

在運行時，如何知道擷取的元素類型而不用強轉呢。

泛型的補償：因為儲存的時候，類型已經確定了是同一個類型的元素，所以在運行時，只要擷取到該元素的類型，在內部進行一次轉換即可，所以使用者不用再做轉換動作了。

 

什麼時候用泛型類呢。

當類中的操作的引用資料類型不確定的時候，以前用的Object來進行擴充的，現在可以用泛型來表示。這樣可以避免強轉的麻煩，而且將運行問題轉移到的編譯時間期。

----------------------------------------------------------

泛型在程式定義上的體現：

//泛型類：將泛型定義在類上。

class Tool<Q> {

    private Q obj;

    public  void setObject(Q obj) {

        this.obj = obj;

    }

    public Q getObject() {

        return obj;

    }

}

//當方法操作的引用資料類型不確定的時候，可以將泛型定義在方法上。

    public <W> voidmethod(W w) {

        System.out.println("method:"+w);

    }

//靜態方法上的泛型：靜態方法無法訪問類上定義的泛型。如果靜態方法操作的引用資料類型不確定的時候，必須要將泛型定義在方法上。

    public static<Q> void function(Q t) {

        System.out.println("function:"+t);

    }

//泛型介面.

interface Inter<T> {

    void show(T t);

}

class InterImpl<R> implements Inter<R> {

    public void show(R r) {

        System.out.println("show:"+r);

    }

}

------------------------------------------------------------

泛型中的萬用字元：可以解決當具體類型不確定的時候，這個萬用字元就是 ?  ；當操作類型時，不需要使用類型的具體功能時，只使用Object類中的功能。那麼可以用 ? 萬用字元來表未知類型。

 

泛型限定：

    上限：。extends E：可以接收E類型或者E的子類型對象。

    下限：。super E：可以接收E類型或者E的父類型對象。

 

上限什麼時候用：往集合中添加元素時，既可以添加E類型對象，又可以添加E的子類型對象。為什麼。因為取的時候，E類型既可以接收E類對象，又可以接收E的子類型對象。

 

下限什麼時候用：當從集合中擷取元素進行操作的時候，可以用當前元素的類型接收，也可以用當前元素的父類型接收。

 

泛型的細節：

1）、泛型到底代表什麼類型取決於調用者傳入的類型，如果沒傳，預設是Object類型；

2）、使用帶泛型的類建立對象時，等式兩邊指定的泛型必須一致；

    原因：編譯器檢查對象調用方法時只看變數，然而程式運行期間調用方法時就要考慮對象具體類型了；

3）、等式兩邊可以在任意一邊使用泛型，在另一邊不使用(考慮向後相容)；

ArrayList<String>al = new ArrayList<Object>();  //錯

//要保證左右兩邊的泛型具體類型一致就可以了，這樣不容易出錯。

ArrayList<?extends Object> al = new ArrayList<String>();

al.add("aa");  //錯

//因為集合具體對象中既可儲存String，也可以儲存Object的其他子類，所以添加具體的類型對象不合適，類型檢查會出現安全問題。 。extendsObject 代表Object的子類型不確定，怎麼能添加具體類型的對象呢。

public static voidmethod(ArrayList<? extends Object> al) {

al.add("abc");  //錯

  //只能對al集合中的元素調用Object類中的方法，具體子類型的方法都不能用，因為子類型不確定。

}

------------------------------------------------------------------------------------------------------------------------------------------------