Java基礎——集合框架（二）

Set：

無序，不可重複元素

HashSet：數據結構是哈希表，線程是非同步的。
- 保證元素唯一性的原理：判斷元素的hashCode值是否相同
- 如果相同，還會繼續判斷元素的equals方法，是否爲true
TreeSet：
- 可以對Set集合中的元素進行排序
- 底層數據結構式二叉樹，
- 保證元素唯一的依據是：
- compareTo方法return 0 。
  - TreeSet排序的第一種方式：
    - 讓元素自身具備比較性
    - 元素需要實現Comparable接口，覆蓋compareTo方法
    - 這種方式也稱爲元素的自然順序，或者叫做默認順序
  - TreeSet的第二種排序方式。
    - 當元素自身不具備比較性時，或者具備的比較性不是所需要的。
    - 這時就需要讓集合自身具備比較性。
    - 在集合初始化時，就有了比較方式。


//TreeSet集合簡單的存儲以及取出演示
import java.util.*;
public class TreeSetDemo {
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static void main(String[] args) 
    {
        TreeSet ts = new TreeSet();
        ts.add("aaa");
        ts.add("cbc");
        ts.add("aac");
        ts.add("bde");

        for (Iterator it = ts.iterator();it.hasNext() ; )
        {
            sop(it.next());
        }
    }
}

運行結果爲：

發現TreeSet集合中打印出來的數據不僅無序，而且他會按照自己的規則（ASCII碼錶順序）給集合中的元素進行排序。

那麼接下來，老規矩，給集合中添加自定義對象呢？

//在TreeSet集合中添加自定義對象
import java.util.*;
class Person//定義人這個類
{
    private String name;
    private int age;
    Person(String name,int age)
    {
        this.name = name;
        this.age = age;
    }
    public String getName()
    {
        return name;
    }
    public int getAge()
    {
        return age;
    }
}
public class TreeSetDemo1 {
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static void main(String[] args) 
    {
        TreeSet ts = new TreeSet();//創建TreeSet集合對象

        ts.add(new Person("zhangsan",12));
        ts.add(new Person("lisi",28));
        ts.add(new Person("wangwu",17));
        ts.add(new Person("zhaoliu",40));

        for (Iterator it = ts.iterator(); it.hasNext(); )//用迭代器取出集合中的元素
        {
            Object obj = it.next();
            Person p = (Person)obj;
            sop("姓名= "+p.getName()+"...年齡爲..."+p.getAge());
        }
    }
}

編譯通過，，運行，，

在運行的時候，出現了異常，ClassCastException 原因是，Person can not be cast to Comparable

找到Comparable的詳細信息

發現接口中只有一個方法

上邊說了那麼一大堆，其實簡單來說就是：
TreeSet集合會給傳進來的對象進行排序，但是傳進來的Person類的對象並不具備比較性。TreeSet集合不知道用什麼方式來給對象進行排序。

那怎麼就有了比較性了呢？
實現Comparable接口。

那怎麼定義比較方法呢？
在實現Comparable接口的類中，重寫compareTo方法。
將比較規則寫在該方法中，調用方的對象比較大於參數方，則返回正整數，否則返回負整數，相同返回0.

代碼實現是這樣的。

//在TreeSet集合中添加自定義對象
import java.util.*;
class Person implements Comparable//此接口強制讓Person對象具備比較性
{
    private String name;
    private int age;
    Person(String name,int age)
    {
        this.name = name;
        this.age = age;
    }
    public String getName()
    {
        return name;
    }
    public int getAge()
    {
        return age;
    }
    public int compareTo(Object obj)
    {
        if (!(obj instanceof Person))
            throw new RuntimeException("參數格式不正確");
        Person p = (Person)obj;
        //想按照年齡排序,從小到大的順序
        //如果調用方的屬性值大於參數對象的屬性值，返回一個正整數。
        if (this.age>p.age)
            return 1;
        if(this.age==p.age)
            return 0;
        return -1;
    }
}
public class TreeSetDemo1 {
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static void main(String[] args) 
    {
        TreeSet ts = new TreeSet();//創建TreeSet集合對象

        ts.add(new Person("zhangsan",12));
        ts.add(new Person("lisi",28));
        ts.add(new Person("wangwu",17));
        ts.add(new Person("zhaoliu",40));

        for (Iterator it = ts.iterator(); it.hasNext(); )//用迭代器取出集合中的元素
        {
            Object obj = it.next();
            Person p = (Person)obj;
            sop("姓名= "+p.getName()+"...年齡爲..."+p.getAge());
        }
    }
}

運行結果爲：

那麼想到當兩個人的年齡一樣的話，會不會將對象存進來呢？

//在TreeSet集合中添加自定義對象
import java.util.*;
class Person implements Comparable//此接口強制讓Person對象具備比較性
{
    private String name;
    private int age;
    Person(String name,int age)
    {
        this.name = name;
        this.age = age;
    }
    public String getName()
    {
        return name;
    }
    public int getAge()
    {
        return age;
    }
    public int compareTo(Object obj)
    {
        if (!(obj instanceof Person))
            throw new RuntimeException("參數格式不正確");
        Person p = (Person)obj;

        if (this.age>p.age)
            return 1;
        if(this.age==p.age)
            return 0;
        return -1;
    }
}
public class TreeSetDemo1 {
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static void main(String[] args) 
    {
        TreeSet ts = new TreeSet();

        ts.add(new Person("zhangsan",12));
        ts.add(new Person("lisi",28));
        ts.add(new Person("wangwu",17));
        ts.add(new Person("zhaoliu",40));
        ts.add(new Person("zhouqi",40));//兩個人年齡一樣，但是姓名不一樣

        for (Iterator it = ts.iterator(); it.hasNext(); )
        {
            Object obj = it.next();
            Person p = (Person)obj;
            sop("姓名= "+p.getName()+"...年齡爲..."+p.getAge());
        }
    }
}

運行結果：

運行結果顯示，那個年齡形同的人沒有存進來

解釋：每一個被添加進來的對象都會運行compareTo方法和已經在集合中的元素比較一次，如果返回爲0，會認爲這個對象和集合中的元素是同一個，不進行存儲。

解決方法：設置完主要條件要設置次要條件。
假如年齡相同要在判斷一次姓名是否相同，

//在TreeSet集合中添加自定義對象
import java.util.*;
class Person implements Comparable//此接口強制讓Person對象具備比較性
{
    private String name;
    private int age;
    Person(String name,int age)
    {
        this.name = name;
        this.age = age;
    }
    public String getName()
    {
        return name;
    }
    public int getAge()
    {
        return age;
    }
    public int compareTo(Object obj)
    {
        if (!(obj instanceof Person))
            throw new RuntimeException("參數格式不正確");
        Person p = (Person)obj;

        if (this.age>p.age)
            return 1;
        if(this.age==p.age)
        {
            return this.name.compareTo(p.name);
            //這裏的this.name是String類型的，String類型有自己的比較方法（自然順序）
            //因爲Sting類實現了Comparable接口，所以字符串具有比較性。
            //最後將String類比較完compareTo方法返回的值再返回去。
        }
        return -1;
    }
}
public class TreeSetDemo1 {
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static void main(String[] args) 
    {
        TreeSet ts = new TreeSet();

        ts.add(new Person("zhangsan",12));
        ts.add(new Person("lisi",28));
        ts.add(new Person("wangwu",17));
        ts.add(new Person("wangwu",17));
        ts.add(new Person("zhaoliu",40));
        ts.add(new Person("zhouqi",40));//兩個人年齡一樣，但是姓名不一樣

        for (Iterator it = ts.iterator(); it.hasNext(); )
        {
            Object obj = it.next();
            Person p = (Person)obj;
            sop("姓名= "+p.getName()+"...年齡爲..."+p.getAge());
        }
    }
}

運行結果：

實驗結果，年齡相同，姓名不同的兩個人，可以存儲進來。
年齡相同，姓名相同的人（視爲同一個人）存儲不進來。

TreeSet中的數據存儲方式圖：二叉樹

根據二叉樹的示意圖，就瞭解了TreeSet集合中數據的存儲方式，

那麼如果我想要將TreeSet集合中的對象按照存進去時候的順序取出來呢？

只要將複寫compareTo方法的內容中只寫一句：return 1，
進來一個元素，元素判斷時調用compareTo方法，一看返回值爲1 ，放在右邊
以此類推……….
最後存進去的順序就和元素存進去的先後順序一樣的了。

那麼如果我想要將TreeSet集合中的對象反向的取出來呢？

只要將複寫compareTo方法的內容中只寫一句：return -1，
進來一個元素，元素判斷時調用compareTo方法，一看返回值爲-1 ，放在左邊
以此類推……….
最後存進去的順序就是倒着的，取出來的順序就和存進去的順序相反了。

自定義比較器

像以上自定義對象存入TreeSet集合中，使用的是給對象強制加了比較性。
但是在實際開發中，已經定義好的Person類的排序方式（先判斷年齡，再判斷姓名）不是我們想要的。
我們想要的是：先按照姓名排序（主要條件），然後按照年齡排序（次要條件）
但是之前已經給了的Person類的代碼不能動（因爲我們知道，修改代碼是災難啊）
解決辦法就是在集合自身上定義一個比較器：不管你自己的排序方式是什麼樣的，要進我的集合中，按照我的排序方式來。

如何自定義比較器呢？

自定義類實現Comparator接口，
覆蓋裏邊的int compare(Object o1,Object o2)方法
同樣是以return 0 來判斷元素是否相同。

示例代碼如下：

/*
當對象所具備的比較性不是我們想要的時候
我們需要給集合定義自己的比較器
只要將定義好的比較器作爲參數傳給TreeSet的構造函數就好了
*/

//需求：自定義集合的比較器，讓對象按照集合的比較器進行比較並存儲
//而不按照對象的比較方式
import java.util.*;
//這裏定義Person類實現了接口，讓Person對象具備比較性
class Person implements Comparable
{
    private String name;
    private int age;
    Person(String name,int age)
    {
        this.name = name;
        this.age = age;
    }
    public String getName()
    {
        return name;
    }
    public int getAge()
    {
        return age;
    }
    public int compareTo(Object obj)
    {
        if (!(obj instanceof Person))
            throw new RuntimeException("對象不正確");
        Person p = (Person)obj;
        if (this.age>p.age)
            return 1;
        if (this.age==p.age)
        {
            return this.name.compareTo(p.name);
        }
        return -1;
    }
}
//定義比較器
class MyCompare implements Comparator
{
    public int compare(Object o1,Object o2)//形參必須是Obj的，如果不是就不算複寫接口中的方法。
    {
        if ((!(o1 instanceof Person)) || (!(o1 instanceof Person)))//如果傳入的參數不是Person類的，拋出運行時異常
        {
            throw new RuntimeException("傳入的對象不正確");
        }
        //通過if條件了，就執行強轉
        Person p1 = (Person)o1;
        Person p2 = (Person)o2;
        //如果姓名相同，，再比較年齡
        if ((p1.getName().compareTo(p2.getName()))==0)
        {
            //Integer類中有自己重寫過的compareTo方法，這裏直接借過來使用
            return new Integer(p1.getAge()).compareTo(new Integer(p2.getAge()));
        }
        //如果姓名不相同，直接返回字符串之間的自然順序比較的結果值
        return p1.getName().compareTo(p2.getName());
    }
}
public class TreeSetDemo2 {
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static void main(String[] args) 
    {
        TreeSet ts = new TreeSet(new MyCompare());

        ts.add(new Person("java08",34));
        ts.add(new Person("java04",24));
        ts.add(new Person("java09",43));
        ts.add(new Person("java43",12));
        ts.add(new Person("java43",25));
        ts.add(new Person("java01",39));
        ts.add(new Person("java05",39));
        //ts.add("java05");//這裏拋出運行時異常

        for (Iterator it = ts.iterator();it.hasNext() ; )
        {
            Person p = (Person)it.next();
            sop(p.getName()+"......"+p.getAge());
        }
    }
}

運行結果：正常

運行結果顯示：對象按照姓名順序排序，姓名相同的話，按照年齡排序。
而且，當第一種比較方式（對象類實現Comparable接口）和第二種比較方式（自定義比較器實現Compatator接口）共存的時候，使用的是第二種比較方式。

一個TreeSet集合的小練習：

//需求：TreeSet 中存放字符串對象，要求按照字符長度排序
import java.util.*;
class MyCompare implements Comparator
{
    public int compare(Object o1,Object o2)
    {
        //對象進來先進行判斷
        if ((!(o1 instanceof String)) || (!(o1 instanceof String)))
            throw new RuntimeException("對象不是字符串的對象");
        //再進行強轉
        String s1 = (String)o1;
        String s2 = (String)o2;
        //再進行判斷（長度）
        int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));
        //如果長隊相等，再進行自然排序
        if (num==0)
        {
            return s1.compareTo(s2);
        }
        //如果長度不相等，直接返回判斷長度返回的值
        return num;
    }
}
public class TreeSetTest {
    public static void main(String[] args) 
    {
        TreeSet ts = new TreeSet(new MyCompare());

        ts.add("abfdfdc");
        ts.add("abcd");
        ts.add("abcdf");
        ts.add("aaaaa");
        ts.add("c");
        ts.add("cfd");

        for (Iterator it = ts.iterator();it.hasNext() ; )
        {
            System.out.println((String)it.next());
        }
    }
}

運行結果爲：

運行結果，如果字符串的長度不相等，按照字符串的長度排序
如果字符串的長度相等，按照字符串的自然順序排序。

記住，compare方法和compareTo方法，返回的都是大於0，小於0，等於0的整數，不是簡單的1,0，-1。

泛型

jdk1.5版本以後出現的新特徵，用於解決安全問題，是一個類型安全機制。

看一個小程序來了解泛型:

//需求：想打印一下存在集合中的字符串對象的長度。
import java.util.*;
public class GenericDemo {
    public static void main(String[] args) 
    {
        ArrayList al = new ArrayList();

        al.add("dsfd");
        al.add("cvv");
        al.add("eref");
        al.add("dfdsd");

        for (Iterator it =al.iterator();it.hasNext() ; )
        {
            String s = (String)it.next();
            System.out.println(s.length());
        }
    }
}

運行結果：

如果我在這個集合中一不小心存儲了一個Integer類型的值呢？

//需求：想打印一下存在集合中的字符串對象的長度。
import java.util.*;
public class GenericDemo {
    public static void main(String[] args) 
    {
        ArrayList al = new ArrayList();

        al.add("dsfd");
        al.add("cvv");
        al.add("eref");
        al.add("dfdsd");
        al.add(new Integer(4));//添加一個Integer類型的對象

        for (Iterator it =al.iterator();it.hasNext() ; )
        {
            String s = (String)it.next();
            System.out.println(s.length());
        }
    }
}

運行結果顯示:

由運行結果可以看到：編譯可以通過，但是運行時出了問題，拋出了ClassCastException
Integer類型的對象不能被轉換成String類型的。

這種編譯時不出現問題，運行時出現問題的程序很危險，
爲了讓該程序在編譯的時候，有什麼問題都會顯示出來，也就是爲了提高安全性，
在定義集合的時候給他加上一個標識，明確只有什麼類型的對象纔可以存入到集合中來，
只要是添加了不符合規則的類型對象進來，編譯時期就報錯

怎麼添加標識呢？

這就用到了泛型，給TreeSet集合明確要存的對象類型

代碼示例：

//需求：想打印一下存在集合中的字符串對象的長度。
import java.util.*;
public class GenericDemo {
    public static void main(String[] args) 
    {
        //泛型標識，用<>將集合中要存的對象類型寫進來，集合中只可以存這種類型的對象
        //如果存進來其他類型的對象，就會報錯
        ArrayList<String> al = new ArrayList<String>();

        al.add("dsfd");
        al.add("cvv");
        al.add("eref");
        al.add("dfdsd");
        al.add(new Integer(4));//添加一個Integer類型的對象


        //既然存的時候要限定類型，取得時候也要限定類型
        //因爲Iterator接口接收到的是Object對象，
        for (Iterator<String> it =al.iterator();it.hasNext() ; )
        {
            //既然在迭代器上已經限定了要存進來的對象，所以取對象的時候就不用進行對象的向下強轉了。
            String s = it.next();
            System.out.println(s.length());
        }
    }
}

編譯結果：

發現，加上泛型之後，往集合中添加其他類型的對象的時候，在編譯時期就出現了錯誤，可以讓程序員發現並進行修改。提高了安全性。

我們重新將代碼修改（將添加Integer對象的那一行代碼註釋），使代碼編譯能夠通過，並且運行。

運行結果：

發現，編譯正常通過，而且不再會提示：使用了未經檢查的不安全操作了。

泛型的好處：

1，將運行時出現問題ClassCastException轉移到了編譯時期。
方便程序員解決問題，讓運行時期問題減少，安全。
2，避免了強制轉換的麻煩。

泛型格式：通過<>來定義要操作的引用數據類型。

在使用java中提供的對象時，什麼時候寫泛型呢？

通常在集合框架中很常見，
只要見到<>就要定義泛型
其實<>就是用來接收類型的。
當使用集合時，將集合中要存儲的數據類型作爲參數傳遞到<>中即可。

一個泛型在集合中比較器裏邊的應用：

/*
泛型在集合比較器中的應用
*/

//需求：在集合中存入字符串對象，要求按照長度從長到短排序，用泛型類加強安全措施
import java.util.*;

class MyCompare implements Comparator<String>//Comparator接口也要定義泛型類
{
    public int compare(String s1,String s2)//接口標識了泛型類，這裏就不用再進行強轉，進來的元素都是String類型的
    {
        //按照長度從長到短的順序，只要將先後傳進來的對象的比較順序進行調換就可以了。

        int num = new Integer(s2.length()).compareTo(new Integer(s1.length()));
        if (num==0)
            return s2.compareTo(s1);
        return num;
    }
}
public class GenericDemo2 {
    public static void main(String[] args) 
    {
        TreeSet<String> ts = new TreeSet<String>(new MyCompare());

        ts.add("gfdgd");
        ts.add("aaa");
        ts.add("dcf");
        ts.add("fdsfewwef");
        ts.add("cv");

        for (Iterator<String> it  = ts.iterator();it.hasNext() ; )
        {
            String s = it.next();
            System.out.println(s);
        }
    }
}

運行結果爲：

運行結果顯示，按照字符串從長到短的順序進行排列的。

練習二：自定義具有泛型限制的工具類
前後作爲對比：
沒有泛型的時候是這樣的：

/*
定義一個工具類，能夠調用被創建出來的對象，
*/
import java.util.*;

class Person
{

}
class UtilClass//創建一個工具類
{
    private Person p;
    public void set(Person p)//set方法創建一個Person對象
    {
        this.p = p;
    }
    public Person get()//get方法返回一個Person對象
    {
        return p;
    }
}
public class GenericDemo3 {
    public static void main(String[] args) 
    {
        UtilClass u = new UtilClass();
        u.set(new Person());
        Person p = (Person)u.get();

    }
}

這樣的代碼，可以執行也可以運行，
但是不止一個類需要有這樣的工具，當其他類調用這樣的工具的時候，
還要重新創建該工具類，設置參數類，這樣的話不能提高代碼的複用性，也降低了該工具程序的擴展性。
於是，我們將代碼變成了這樣：

/*
定義一個工具類，能夠調用被創建出來的對象，使用泛型，讓該方法可以被多個類調用
*/
import java.util.*;

class Person
{

}
class Student
{
}
class UtilClass
{
    private Object obj;
    public void setObject(Object obj)
    {
        this.obj = obj;
    }
    public Object getObject()
    {
        return obj;
    }
}
public class GenericDemo3 {
    public static void main(String[] args) 
    {
        UtilClass u = new UtilClass();
        u.setObject(new Person());//在這裏Person類會被提升爲Object類

        //這裏要將提升到Object類型的對象進行強制向下轉型
        Person p = (Person)u.getObject();

    }
}

這樣也可以，但是，當我在主函數中的setObject方法中new了一個Student對象，

u.setObject(new Student());

編譯也能通過（因爲setObject方法接收的參數是Object類型的）
但是運行時出了問題，

運行結果如圖所示，編譯能通過，但是運行時拋出來類型轉換異常，因爲到強制向下轉型的時候不能將原本Student類型的對象轉換成Person對象。
這種編譯可以通過，但是運行出問題的方式是不可取的。

這種辦法行不通，但是怎麼樣纔可以提高代碼的複用性，而且還能提高程序的擴展性呢？

這就用到了自定義泛型工具類

/*
定義一個工具類，能夠調用被創建出來的對象，使用泛型，讓該方法可以被多個類調用
*/
import java.util.*;

class Person
{

}
class Student
{
}
class UtilClass<T>//這裏標識一個類型形式參數
{
    private T t;//裏邊的類型，變量全是參數值
    public void setObject(T t)
    {
        this.t = t;
    }
    public T getObject()
    {
        return t;
    }
}
public class GenericDemo3 {
    public static void main(String[] args) 
    {
        //在定義工具類的時候就要加泛型以約束
        UtilClass<Person> u = new UtilClass<Person>();

        //這裏new對象作爲參數
        u.setObject(new Person());

        //在這裏就不用進行強轉了。
        Person p = u.getObject();

    }
}

運行結果正常，

如果我們在倒數第二行new錯了對象

u.setObject(new Student());

在編譯時期就會報錯，提醒程序員修改代碼，這樣提高了安全性。

將泛型定義在方法上

在以上的示例中，我們將泛型定義在類上，泛型在全類中有效。

看以下代碼：

/*演示將泛型添加在方法上*/

class Demo<T>
{
    public void show(T t)
    {
        System.out.println("show.."+t);
    }
    public void print(T t)
    {
        System.out.println("print.."+t);
    }
}
public class GenericDemo4 {
    public static void main(String[] args) 
    {
        Demo<String> d = new Demo<String>();
        d.show("hahah");
        d.print("hehe");


        Demo<Integer> d1 = new Demo<Integer>();
        d1.show(new Integer(7));
        d1.print(4);//這裏會自動裝箱操作
    }
}

運行結果：

但是想要只new一個對象，然後用着一個對象打印多個類型的數據呢？
這就用到了泛型方法：

/*演示將泛型添加在方法上*/

class Demo
{
    public<T> void show(T t)//在返回值類型前邊添加類型參數
    {
        System.out.println("show.."+t);
    }
    public<T> void print(T t)
    {
        System.out.println("print.."+t);
    }
}
public class GenericDemo4 {
    public static void main(String[] args) 
    {
        Demo d = new Demo();
        d.show("haha");
        d.show(new Integer(7));
        d.show(9);
    }
}

運行結果：

泛型類定義的泛型，在整個類中有效，如果被方法調用
那麼泛型類的對象明確要操作的具體類型後，所有要操作的類型就已經固定了。
爲了讓不同的方法可以操作不同類型，而且類型還不確定
那麼可以將泛型定義在方法上
特殊之處：
- 靜態方法不可以訪問類上定義的泛型
- 如果靜態方法操作的應用數據類型不確定，可以將泛型定義在方法上。

爲什麼靜態方法不可以訪問類上定義的泛型呢？

看下面的代碼：

/*演示將泛型添加在靜態方法上*/

class Demo<T>
{
    public<T> void show(T t)//該方法直接用的是類中的泛型，只能操作類上的泛型定義的數據
    {
        System.out.println("show.."+t);
    }
    public<Q> void print(Q q)//該方法用的是自己方法上的泛型，可以存在，可以操作多種類型的數據
    {
        System.out.println("print.."+q);
    }
    /*
    這個編譯會失敗，因爲靜態方法優先於對象存在，而方法中的泛型參數T，要等到new了對象纔可以確定。
    public static void method(T t)
    {
        System.out.println("method.."+t);

    }
    */

    //那麼靜態方法上的泛型應該怎麼定義呢？
    //泛型寫在修飾符後邊，返回值類型前邊

    public static<W> void method(W w)
    {
        System.out.println("method.."+w);
    }
}
public class GenericDemo4 {
    public static void main(String[] args) 
    {
        Demo.method("hahahahahah");
        Demo.method(new Integer(7));
    }
}

運行結果：

泛型定義在接口上

//泛型定義在接口上

/*

這是第一種方法，當類實現了接口之後，明確自己要對什麼樣的數據進行操作
interface Inter<T>
{
    public void show(T t);
}
class IntImpl implements Inter<String>//在實現的接口上寫上類參數
{
    public void show(String t)
    {
        System.out.println(t);
    }
}
public class GrnericDemo5 {
    public static void main(String[] args) 
    {
        IntImpl i = new IntImpl();//new對象的時候就不用寫泛型了，因爲接口已經確定了泛性

        i.show("nihao");
    }
}
*/

//第二種方法，類實現了接口，但是要用什麼泛型還不確定
interface Inter<T>
{
    public void show(T t);
}
class IntImpl<T> implements Inter<T>//類也和接口用一樣的泛型
{
    public void show(T t)
    {
        System.out.println(t);
    }
}
public class GrnericDemo5 {
    public static void main(String[] args) 
    {

        IntImpl<String> i = new IntImpl<String>();//new對象的時候需要寫泛型了，因爲接口還沒有確定泛性

        i.show("nihao");

        IntImpl<Integer> j = new IntImpl<Integer>();

        j.show(4);
    }
}

運行結果：

泛型限定

//泛型限定

//要用一個迭代器取出同一種集合中（ArrayList），兩個集合（al,al1）的元素，兩個集合的對象類型不一樣(Ingeter,String)。
import java.util.*;
public class GenericDemo6 {
    public static void main(String[] args) 
    {
        ArrayList<String> al = new ArrayList<String>();

        al.add("abc1");
        al.add("abc2");
        al.add("abc3");


        ArrayList<Integer> al1 = new ArrayList<Integer>();

        al1.add(3);
        al1.add(5);
        al1.add(6);

        printColl(al);
        printColl(al1);
    }
    public static <T>void printColl(ArrayList<T> al)//靜態泛型限定，記得在返回值前邊加泛型限定
    {
        for (Iterator<T> it = al.iterator();it.hasNext() ; )
        {
            T t = it.next();
            System.out.println(t);
        }
    }
    /*
    printColl方法也可以這樣寫

    public static void printColl(ArrayList<?> al)//不確定什麼類型的限定，所以用一個?（佔位符）
    {
        for (Iterator<?> it = al.iterator();it.hasNext() ; )
        {
            System.out.println(it.next());
        }
    }
    */
}

運行結果爲：

？通配符：也可以理解爲佔位符
泛型的限定：
？extends E ：可以接收E類型或者E的子類型。上限
？ super E ：可以接收E類型或者E的父類型，下限

通過代碼鞏固一下：

//泛型限定

//需求：有Person類和Student類
//Student類繼承了Person類
//將兩個對象分別裝進兩個集合中，
//用一個方法將兩個集合中的元素全取出來。
import java.util.*;
class Person
{
    private String name;
    Person(String name)
    {
        this.name = name;
    }
    public String getName()
    {
        return name;
    }
}
class Student extends Person
{
    Student(String name)
    {
        super(name);
    }

}
public class GenericDemo6{
    public static void main(String[] args)
    {
        ArrayList<Student> al = new ArrayList<Student>();
        al.add(new Student("lisi01"));
        al.add(new Student("lisi02"));
        al.add(new Student("lisi03"));


        ArrayList<Person> al1 = new ArrayList<Person>();//原則，必須前後一致
        al1.add(new Person("lisi--01"));
        al1.add(new Person("lisi--02"));
        al1.add(new Person("lisi--03"));


        printColl(al);
        printColl(al1);
    }
    public static void printColl(ArrayList<? extends Person> al)//泛型限定爲Person類他的子類。
    //也就是說，在這個打印集合元素的方法中，該方法只接收Person和他的子類對象
    {
        for (Iterator<? extends Person> it = al.iterator(); it.hasNext(); )//泛型限定必須上下一致
        {
            System.out.println(it.next().getName());
        }
    }
}

運行結果爲：

在開發中，還是上限用的比較多一些，
下限使用起來的話，父類會一直延伸到Object類中，而Object類中的方法不是很多，所以總會報出來沒有哪個哪個方法。建議使用上限（個人看法）

不管是上限還是下限，都要保證需要進來的元素是泛型類的子類，出於多態的原因，父類可以將子類接收進來。

Java基礎——集合框架（二）

Set：

泛型

Java基礎——集合框架（二）

Java基礎——String類、StringBuffer、Integer

Java基礎——包

線程之間通信、停止線程、守護線程

Java基礎——異常及處理方法

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結