2. 程式人生 > 實用技巧 >Java集合之泛型類和泛型介面

Java集合之泛型類和泛型介面

阿新 • • 發佈：2020-09-01

目錄

1. 為什麼要有泛型

1.1 不使用泛型的問題

當不使用泛型時，集合中是可以存放任意型別物件的，只要把物件儲存集合後，那麼他們都會被提升為Object型別。當我們在取出每一個物件，並且進行相應的操作，需要進行型別轉換。

觀察下面程式碼：

public static void main(String[] args) {
    Collection coll = new ArrayList();
    coll.add("abc");
    coll.add("def");
    coll.add(5);//由於集合沒有做任何限定，任何型別都可以存放
    Iterator it = coll.iterator();
    while(it.hasNext()){
        //需要列印每個字串的長度,就要把迭代出來的物件轉成String型別
        String str = (String) it.next();
        System.out.println(str.length());
    }
}

程式在執行時發生了問題 java.lang.ClassCastException。為什麼會發生型別轉換異常呢？
由於集合沒有使用泛型，什麼型別的元素都可以儲存，導致取出時強轉引發執行時 ClassCastException。怎麼來解決這個問題呢？
Collection雖然可以儲存各種型別物件，但一般只儲存同一型別物件，例如都是字串物件。因此在JDK5之後，新增了泛型(Generic)語法，讓你在設計API時可以指定類或方法支援泛型，這樣我們使用API的時候也變得更為簡潔，並得到了編譯時期的語法檢查。

1.2 泛型概念

泛型：引數化型別，也就是說要操作的資料一開始不確定是什麼型別，在使用的時候，才能確定是什麼型別，把要操作的資料型別指定為一個引數，在使用時傳入具體的型別，實現程式碼的模板化。

//比如ArrayList集合(含有泛型)，部分原始碼如下(可以理解為模板)
public class ArrayList<E> {
    public E get(int index) {...}
    public E set(int index, E element) {...}
    public boolean add(E e) {...}
    public E remove(int index) {...}
}

//建立ArrayList集合物件指定型別為String時
List<String> list1 = new ArrayList<>();
//模板程式碼相當於變成如下形式
public class ArrayList<String> {
    public String get(int index) {...}
    public String set(int index, String element) {...}
    public boolean add(String e) {...}
    public String remove(int index) {...}
}
//所以使用list1集合物件，呼叫以上四個方法時，所有E的位置都變為了String


//建立ArrayList集合物件指定型別為Integer時
List<Integer> list2 = new ArrayList<>();
//模板程式碼相當於變成如下形式
public class ArrayList<Person> {
    public Integer get(int index) {...}
    public Integer set(int index, Integer element) {...}
    public boolean add(Integer e) {...}
    public Integer remove(int index) {...}
}
//所以使用list2集合物件，呼叫以上四個方法時，所有E的位置都變為了Integer

jdk1.7之後，泛型的簡化操作：ArrayList flist = new ArrayList<>(); 可省略右側中的資料型別。

1.3 使用泛型的好處

  • 將執行時期的ClassCastException，提前到編譯時期變成了編譯失敗

  • 避免了型別強轉的麻煩。

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class GenericDemo {
    public static void main(String[] args) {
        show02();
    }

    /**
     * 建立集合物件，使用泛型
     * 好處:
     *     1.想使用元素特有的方法，避免了型別轉換的麻煩
     *     2.把執行時異常，提升到編譯時期
     * 弊端:
     *     一旦確定資料型別，就只能儲存該型別資料
     */
    private static void show02() {
        Collection<String> list = new ArrayList<>();
        list.add("abc");
        list.add("def");
        // list.add(5);//當集合明確型別後，存放型別不一致就會編譯報錯
        // 集合已經明確具體存放的元素型別，那麼在使用迭代器的時候，迭代器也同樣會知道具體遍歷元素型別
        Iterator<String> it = list.iterator();
        while(it.hasNext()){
            String str = it.next();
            //當使用Iterator<String>控制元素型別後，就不需要強轉了。獲取到的元素直接就是String型別
            System.out.println(str.length());
        }
    }

    /**
     * 建立集合物件，不使用泛型
     * 好處:
     *     集合的型別預設為Object型別，可以儲存任意的物件
     * 弊端:
     *     不安全，
     *     不能使用元素特有的方法
     */
    private static void show01() {
        ArrayList list = new ArrayList();
        list.add("abc");
        list.add(1);
        //使用迭代器遍歷集合
        Iterator it = list.iterator();
        while(it.hasNext()){
            //取出集合中元素，Object型別
            Object obj = it.next();
            System.out.println(obj);

            /*
               想使用字串特有的方法length
               不能使用，需要向下轉型
               Object obj = "abc";多型
             */
            String s = (String)obj;
            System.out.println(s.length());
        }

    }
}

2. 泛型類

2.1 定義格式：

//其中型別引數，一般用一個大寫字母表示，比如: T,E,K,V
//如果要定義多個泛型，多個型別引數之間用逗號,隔開，例如：public class HashMap<K,V> {...}
許可權修飾符 class 類名<型別形參> {  }

例如，API中的ArrayList集合：

泛型在定義的時候不具體，使用的時候才變得具體。在使用的時候確定泛型的具體資料型別。

public class ArrayList<E>{ 
    public boolean add(E e){ }

    public E get(int index){ }
   	....
}

2.2 使用泛型： 即什麼時候確定泛型。

在建立物件的時候指定型別

例如，ArrayList<String> list = new ArrayList<>();

此時，變數E的值就是String型別，那麼我們的型別就可以理解為：

class ArrayList<String>{ 
     public boolean add(String e){ }

     public String get(int index){  }
     ...
}

再例如，ArrayList<Integer> list = new ArrayList<>();

此時，變數E的值就是Integer型別，那麼我們的型別就可以理解為：

class ArrayList<Integer> { 
     public boolean add(Integer e) { }

     public Integer get(int index) {  }
     ...
}

在類、介面上宣告的泛型，在本類、本介面中即代表某種資料型別，可以作為非靜態成員變數的型別、非靜態方法的形參型別、非靜態方法的返回值型別、區域性變數的型別等，但不能用於靜態成員上。

自定義泛型類：

public class MyGenericClass<T> {
    // 沒有T型別，在這裡代表 未知的一種資料型別 未來傳遞什麼就是什麼型別
    private T t; // 用於成員變數的資料型別

    public MyGenericClass() {
    }

    public MyGenericClass(T t) { // 用於方法的形參的資料型別
        this.t = t;
    }

    public T getT() { // 用於方法的形參的資料型別
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }
    
    public void test() { // 用於區域性變數的資料型別
        T t;
    }
}

使用:

public class GenericClassDemo {
    public static void main(String[] args) {
        // 建立一個泛型為String的類
        MyGenericClass<String> gc1 = new MyGenericClass<>();
        // 呼叫setT
        gc1.setT("abc");
        // 呼叫getT
        String str = gc1.getT();
        System.out.println(str);
        //建立一個泛型為Integer的類
        MyGenericClass<Integer> gc2 = new MyGenericClass<>();
        gc2.setT(123);
        Integer num = gc2.getT();
        System.out.println(num);
    }
}

注意：

型別實參必須是一個類型別，不能用基本資料型別填充，但可以使用包裝類。

繼承中的使用：

父類：

public class MyGenericFuClass<T> {
    public void print(T t) {
        System.out.println(t);
    }
}
  • 定義子類繼承泛型父類的同時指定泛型的型別
public class MyGenericZiClassA extends MyGenericFuClass<Integer> {
    @Override
    public void print(Integer num) {
        System.out.println(num);
    }
}

public static void main(String[] args) {
    // MyGenericZiClassA類已經沒有泛型了
    MyGenericZiClassA gzA = new MyGenericZiClassA();
    gzA.print(100);
}
  • 定義子類繼承泛型父類，若不指定的父類泛型型別，子類也必須宣告為泛型類，建立物件時指定泛型的型別
public class MyGenericZiClassB<T> extends MyGenericFuClass<T> {
    @Override
    public void print(T t) {
        System.out.println(t);
    }
}

public static void main(String[] args) {
    //建立物件指定泛型型別為String
    MyGenericZiClassB<String> gzB = new MyGenericZiClassB<>();
    gzB.print("abc");
    //gzB.print(100);//錯誤，只能傳遞String型別的引數
    
    //建立物件指定泛型型別為Integer
    MyGenericZiClassB<Integer> gzB2 = new MyGenericZiClassB<>();
    gzB2.print(100);
}

3. 泛型介面

3.1 定義格式：

許可權修飾符 interface 介面名<型別形參> {...}

例如，

public interface MyGenericInterface<T> {
    //抽象方法
    public abstract void show(T t);
}

3.2 使用方式：

1、定義實現類的同時指定泛型介面上的的具體資料型別

public class MyGenericInterfaceImplA implements MyGenericInterface<String> {
    @Override
    public void show(String s) {
        System.out.println(s);
    }
}

public class MyGenericInterfaceDemo1 {
    public static void main(String[] args) {
        MyGenericInterfaceImplA mi = new MyGenericInterfaceImplA();
        // 已指定String型別，只能傳字串
        mi.show("abc");
    }
}

2、定義實現類時，若不指定介面上的泛型的具體資料型別，實現類也必須指定為泛型類，建立物件時，確定泛型的型別

public class MyGenericInterfaceImplB<T> implements MyGenericInterface<T> {
    @Override
    public void show(T t) {
        System.out.println(t);
    }
}

public class MyGenericInterfaceDemo2 {
    public static void main(String[] args) {
        //建立物件指定泛型型別為String
        MyGenericInterfaceImplB<String> mi = new MyGenericInterfaceImplB<>();
        mi.show("abc");

        //建立物件指定泛型型別為Integer
        MyGenericInterfaceImplB<Integer> mi2 = new MyGenericInterfaceImplB<>();
        mi2.show(100);
    }
}

4. 泛型類、泛型介面小結：

  • 語法格式：

    • 在建立泛型類、泛型介面的物件時，為泛型形參指定具體型別

    • 在繼承泛型類或實現泛型介面時，為泛型形參指定具體型別

  • 異常類不能是泛型的

  • 不能使用new E[]。但是可以：E[] array = (E[])new Object[size]; E[] array = (E[])new Object[]{...};等

  • 父類有泛型，子類可以選擇保留泛型也可以選擇指定泛型型別：

    • 子類不保留父類的泛型：按需傳參
      • 沒有型別 擦除
      • 具體型別
    • 子類保留父類的泛型：泛型子類
      • 全部保留
      • 部分保留
    • 結論：子類除了指定或保留父類的泛型，還可以增加自己的泛型（可類推到介面繼承、介面實現）
class Father<T1, T2> {
}
// 子類不保留父類的泛型
// 1)沒有型別 擦除
class Son1 extends Father {// 等價於class Son extends Father<Object,Object>{
}
// 2)具體型別
class Son2 extends Father<Integer, String> {
}
// 子類保留父類的泛型
// 1)全部保留
class Son3<T1, T2> extends Father<T1, T2> {
}
// 2)部分保留
class Son4<T2> extends Father<Integer, T2> {
}

增加自己的泛型：

class Father<T1, T2> {
}
// 子類不保留父類的泛型
// 1)沒有型別 擦除
class Son<A, B> extends Father{//等價於class Son extends Father<Object, Object>{
}
// 2)具體型別
class Son2<A, B> extends Father<Integer, String> {
}
// 子類保留父類的泛型
// 1)全部保留
class Son3<T1, T2, A, B> extends Father<T1, T2> {
}
// 2)部分保留
class Son4<T2, A, B> extends Father<Integer, T2> {
}

相關推薦

Java集合之泛型類和泛型介面

目錄1. 為什麼要有泛型1.1 不使用泛型的問題1.2 泛型概念1.3 使用泛型的好處2. 泛型類2.1 定義格式：2.2 使用泛型： 即什麼時候確定泛型。3. 泛型介面3.1 定義格式：3.2 使用方式：4. 泛型類、泛型介面小結：

泛型類和泛型介面的學習

技術標籤：java 目錄 概念泛型類泛型介面 概念 泛型的本質是引數化型別，也就是說所操作的資料型別被指定為一個引數。這種引數型別可以用在類、介面和方法的建立中，分別稱為泛型類、泛型介面、泛型方法。

java基礎之3-01繼承和多型 Person p = new Teacher()；

技術標籤：java基礎第二部java 繼承和多型 java的三大特徵：封裝，繼承，多型 繼承： Person–父類 Teacher–子類 Student–子類

Java--集合之泛型

一、泛型定義 Java泛型是 JDK1.5中引入的一個新特性，其本質是引數化型別，把型別作為引數傳遞

Java集合遍歷實現方法及泛型通配

集合定義 集合，集合是java中提供的一種容器，可以用來儲存多個數據。 特點：陣列的長度是固定的。集合的長度是可變的。集合中儲存的元素必須是引用型別資料‘

JAVA高階複習-泛型類、泛型方法的使用情景舉例

public class Student<T> { private T studentT; //靜態方法中不能使用泛型 //public static void show(T studentT) {

JavaSE——List集合的三個子類、泛型

技術標籤：javase類新手教程java程式語言資料結構 List的三個子類 List的三個子類的特點

Java反射之二：例項化物件、介面與父類、修飾符和屬性

這次是之二：例項化物件、介面與父類、修飾符和屬性。 例項化物件 之前我們講解過建立物件的方式,有new 、克隆、反序列化，再加一種，根據Class物件，使用newInstance() 或者構造器例項化物件。呼叫以下api即可

JAVA集合之List 和 Set

目錄1. List概述2. List介面常用方法3. List介面的實現類3.1 ArrayList3.2 LinkedList3.3 ArrayList 和 LinkedList 的選擇4. Set概述5. Set介面的實現類5.1 HashSet5.2 HashSet集合儲存資料的結構（雜湊表）5.3 Hash

泛型結構使用大全（泛型類、泛型介面）

1、泛型類可能有多個引數，此時應將多個引數一起放到尖括號內，比如：<E1,E2,E3>

泛型、泛型類、泛型方法、泛型擦除

技術標籤：Java基礎系列 （1）是什麼？ 一種允許我們在不確定引數型別時候使用的型別。例如我不知道A方法應該會傳String還是int，我就用個泛型先佔坑。

Java特性之列舉、註解和Lambda表示式

導語： Java語言自誕生起，經歷了兩次較大的革新：第一次是在2004年，Java5引入了列舉型別、註解和泛型；第二次是在2014年，Java8引入了lambda表示式。本文就重點介紹一下列舉、註解和lambda表示式。

面試半年！三面阿里，四面螞蟻金服，居然倒在了一個Java集合之Map上？

Map介面 Map與Collection並列存在。用於儲存具有對映關係的資料:key-valueMap中的key和value都可以是任何引用型別的資料Map中的key用set來存放，不允許重複，即同一個Map物件所對應的類，須重寫 hashCode()和 equals

類和多型

類 對於傳統的 JavaScript 程式我們會使用函式和基於原型的繼承來建立可重用的元件，但對於熟悉使用面向物件方式的程式設計師使用這些語法就有些棘手，因為他們用的是基於類的繼承並且物件是由類構建出來的。 從 EC

java筆記之設計模式 1、建立型模式：工廠方法

工廠方法的目的是使建立的物件和使用的物件是分離的，並且客戶端總是引用抽象工廠和抽象產品：

Java基礎11 Java集合之ArrayList原始碼解析

  從上篇Java集合的初步認識文章中，我們瞭解到 Collection 是Java集合的一大鼻祖，Collection 介面中定義了集合類的基本操作方法。在瞭解ArrayList之前，我們先來看看它的祖先Collection。

Educoder -Java面向物件 - 封裝、繼承和多型各關卡題目總結

第1關：什麼是封裝，如何使用封裝 　　1、程式設計要求： 　　根據提示，在右側編輯器Begin-End處補充程式碼：

JAVA集合之 Map

目錄1. Map概述2. Map介面中的常用方法3. Map介面的常用實現類3.1 HashMap3.2 LinkedHashMap4. Map介面的遍歷4.1 遍歷鍵找值方式4.2 遍歷鍵值對的方式4.2.1 鍵值對Entry物件4.2.2 遍歷步驟

Java集合之ConcurrentHashMap解析

　　上一篇介紹了HashMap的資料結構：陣列+單鏈表（jdk 1.8，當連結串列長度達到8後，連結串列將會被轉換為紅黑樹結構）。日常開發中我們經常使用，隨著業務規模、場景的不斷複雜發展，多執行緒開發越來越多的進入到

java第五天---String類和Date類

本章節講解常用類：String類和Date類 一、String類 　　1、什麼是String類？ 　　　　String類是用來建立字串型別的，是引用資料型別。