Java集合框架的學習

本節內容總結來自傳智播客畢向東老師的公開課，感謝畢向東老師 ！如有錯誤之處，歡迎大家指教 ！

 

Collection集合常用方法：

  增加、刪除、大小、包含、為空、清空、迭代、並交差；

  boolean add(E o);  boolean remove(Object o);  int size();  boolean contains(Object o);  boolean isEmpty();  void clear();  Iterator<E> iterator();

  boolean addAll(Collection c);  boolean retainAll(Collection c);  boolean removeAll(Collection c);

Set集合常用的方法：

  與Collection集合擁有的方法一樣；

List集合常用的方法：

  List集合的方法中，帶索引參數（角標）的都是新增的方法；帶角標的操作都是數組原理；

  除了繼承Collection集合的方法，還有以下自己獨有的方法，都與索引（下標）有關：

  增加、刪除、修改（只能是修改，不能是插入）、查找（獲取）元素、查找元素所在位置（兩種）；

  void add(int index, E e);  E remove(int index);  E set(int index, E e);  E get(int index);  int indexOf(Object o);  int lastIndexOf(Object o);

Map集合常用的方法：

  增加、刪除、修改、查找（獲取）、大小、包含、為空、清空、迭代

  V put(K k, V v);  V remove(Object k);  put()方法也起到修改功能  V get(Object k);  int size();  boolean containsKey(Object k);

  boolean containsValue(Object v);  boolean isEmpty();  void clear();

 

為什么會有集合；

為什么會有這么多不同的集合框架；

集合與數組的區別；

集合類的關系圖；

集合中存放的是對象實體還是對象的引用（地址），並想一下內存圖；

集合中取出元素並操作的常用方法；

集合中獲取所有元素的常用方法；

Collection接口的常見兩個子接口及比較；

List接口下的常用類及比較；

List集合獨有的迭代器；

Vector特有的迭代器（枚舉）；

LinkedList中一些方法的版本迭代；

List集合中如何實現去除重復元素；

Set接口下的常用類及比較；

Set集合中，如何實現去除重復元素；

Set集合中，如何實現對元素進行排序；（應該不是只針對TreeSet集合）；

泛型；

Map集合下的常用類；

Map集合取出元素的方法；

集合框架中的工具類；

增強型for循環；

 

為什么會有集合：

  數據多了，用對象存；對象多了，用集合（和數組）存；

 

為什么會有這么多不同的集合框架（容器）：

  因為每個容器對數據的存儲方式都有不同；存儲方式就是指數據結構；

 

集合與數組的區別：

 數組的長度是固定的，集合的長度是可變的；

 數組只能存儲同一類型數據，集合能存儲不同類型數據；

 數據可以存基本類型數據，集合只能存對象；

 

集合框架的關系圖：

 

 

集合中存放的是對象實體還是對象的引用（地址）

  集合中存放的都是對象的引用（地址）；

 

集合中取出元素並操作的常用方法：

  使用迭代器：就是集合中取出元素的一種方式；

  有的接口（實現類）有專門的取出元素的方法：

  List集合中：get(index)  subList(from,to)  Iterator

 

集合中獲取所有元素的常用方法：

  for循環

  加強型for循環

  迭代器

 

Collection接口的常見兩個子接口及比較：

 List接口：

  元素是有序的，元素可以重復，因為有索引；

 Set接口：

  元素是無序的（存入和取出的順序不一定一致），元素不可以重復；

 

List接口下的常用類及比較：

ArrayList：底層的數據結構使用的是數組結構；  特點：查詢元素速度很快，但增刪稍慢；  線程不同步

LinkedList：底層的數據結構使用的是鏈表結構；  特點：增刪速度很快，但查詢稍慢；

Vector：底層的數據結構使用的是數組結構；  特點：查詢，增刪速度都很慢，被ArrayList替換了；  線程同步

java集合框架還專門提供加鎖的功能，把你不安全的給我，我給你安全的，解決線程不同步問題；

 

List集合獨有的迭代器：

  ListIterator（接口），繼承自Iterator接口；

  使用迭代器過程中，有兩種操作元素的方式：使用集合對象的方法操作元素；使用迭代器的方法操作元素；

  在迭代時，不可以用集合對象的方法操作集合中的元素，因為會發生並發修改異常；要用迭代器自己的方法操作數據；

  Iterator接口只有刪除元素的操作，而ListIterator接口有增加、刪除、修改等操作；（實例中有疑問）

 

Vector特有的迭代器（枚舉）：

  已經被Iterator替代，因為它的功能和Iterator一樣，但它的名稱和它的方法名過長，沒有Iterator好使；

 

LinkedList中一些方法的版本迭代：

JDK1.6之前：

  addFirst()、addLast()：添加元素

  getFirst()、getLast()：獲取元素，但不刪除元素；如果集合中沒有元素，會拋出NoSuchElementException

  removsFirst()、removeLast()：獲取元素，但同時元素也被刪除；如果集合中沒有元素，會拋出NoSuchElementException

JDK1.6之后：

  offerFirst()、offerLast()：添加元素

  peekFirst()、peekLast()：獲取元素，但不刪除元素；如果集合中沒有元素，返回null

  pollFirst()、pollLast()：獲取元素，但同時元素也被刪除；如果集合中沒有元素，返回null

 

獲取所有元素並刪除的實現：

  使用迭代器；

  使用 pollFirst()、pollLast()方法：

  while( ! link.isEmpty() )

  {

      syso(link.pollFirst());

  }

 

List集合中判斷元素是否相同的問題：

  集合中有自己的判斷元素的方法，但不符合需求的話，就要程序員自己定義判斷規則；

  集合自身只能判斷對象是否相同，用equals()方法來判斷:obj1.equals(obj2)；而繼承自Object類的equals()方法是判斷對象是否相同時判斷的是對象的地址是否相同；但如果具體判斷對象的屬性值是否相同時，equals()方法就相當於判斷對象的內容而不是地址是否相同的（其實此時用的是String類中的判斷字符串內容是否相同的方法，已經重寫的繼承自Object類的equals()方法）；

  List集合中的contains()、remove()兩個方法底層都是用equals()方法來實現的；

  程序員自己通過修改繼承自Object類的equals()方法來自定義判斷規則，使自定義類具體可比較性；

 

Set集合的兩個子類：

HashSet：底層的數據結構使用的是Hash表；

TreeSet：底層數據結構是二叉樹；可以對Set集合中的元素進行排序，以自然順序進行排序；

 

HashSet是如何保證元素唯一性的：

是通過元素的兩個方法：hashCode()和equals()；

如果元素的hashCode值相同，才會調用equals()判斷是否為true；

如果元素的hashCode值不同，不會調用equals()判斷是否為true；

注意：對於判斷元素是否存在，以及元素刪除等操作，依賴的方法是元素的hashCode()和equals()方法，先使用hashCode()；ArrayList只依賴equals()方法；

所以開發中，往集合中添加元素時，一般都會覆寫hashCode()和equals()方法；

 

TreeSet集合對元素進行排序:

  TreeSet保證元素唯一性：依靠compareTo()方法返回值；

  TreeSet集合本身會對元素進行按自然順序進行排序，但在實際開發中肯定不滿足需求，需要程序員自定義排序規則；

  元素被放入TreeSet集合之前，必須是可以被排序的（告訴TreeSet集合如何排序），不然程序運行時會報錯；或者元素不具備比較性，然TreeSet集合本身實現需要的比較規則也可以；

  TreeSet集合的兩種排序方式：

    第一種：當元素不具備比較性，強制使元素具備比較性，繼承Comparable接口；

    第二種：當元素不具備比較性，或者元素具備的比較性不是所需要的，實現讓集合本身具備比較性；實現：在集合初始化時，就具有比較性，所以是對構造函數進行改造；

    注意：

      當兩種排序都存在時，以比較器（Comparator）為准；

      排序時，當主要條件相等時，必須要再判斷次要條件，直到能排除一個順序出來；

 

泛型：

  JDK1.5之后出現的泛型，解決安全問題，是一種安全機制；

  好處：

    將運行時期出現的類型轉換異常轉移到了編譯時期，方便於程序員解決問題，讓運行時期出現問題較少；

    避免了強制轉換的麻煩；

  什么時候使用泛型：

    通常在集合框架中很常見；

    只要見到<>就要定義泛型；

  其實<>就是用來接收類型的，當使用集合時，將集合中要存儲的數據類型作為參數傳遞到<>中即可；

  什么時候使用泛型類：

    當類中要操作的引用數據類型不確定的時候使用泛型類；

  早期通過定義Object來完成擴展，現在通過定義泛型來完成擴展；

  方法刪規定以泛型比類上定義泛型擴展性更好；

  當類上個方法上都定義泛型時，並不沖突，以方法上定義的泛型為准；

  泛型類上定義的泛型，在整個類中有效，如果被方法使用，那么泛型類的對象明確要操作的具體類型后，所有要操作的類型就已經固定了；為了讓不同方法可以操作不同類型，而且類型還不確定，那么可以將泛型定義在方法上；注意：靜態方法不可以訪問類上定義的泛型，所以如果靜態方法操作的引用數據類型不確定的話，可以將泛型定義在靜態方法上；

  泛型的限定：

    ? extends E：可以接收E類型或者E的子類型，上限；

    ? super E：可以接收E類型或者E的父類，下限；

 

Map集合下的常用類：

HashTable：底層的數據結構使用的是哈希表； 不可以存入null鍵null值； 該集合是線程同步的；  效率低；

HashMap：底層的數據結構使用的是哈希表； 可以存入null鍵null值； 該集合不是線程同步的；  效率高；

TreeMap：底層的數據接口使用的是二叉樹； 線程不同步； 可以用於給Map集合中的鍵進行排序；

 

將數組變成集合，不可以使用集合的增刪方法，因為數組的長度是固定的；

 

如果數組中的元素都是對象，那么轉成集合時，數組中的元素就直接轉成集合中的元素；

如果數組中的元素都是基本類型，那么會將該數組作為集合中的元素存在；

 

集合轉成數組時，指定類型的數組要定義成多長：當指定類型數組的長度小於集合的size時，那么該方法的內部會創建一個新的數組，長度為集合的size；當指定類型數組的長度大於集合的size時，該方法不會再創建一個新的數組，而是使用傳遞過來的數組；所以創建一個剛剛好的數組最優；

 

為什么要將集合轉成數組：

  限定對元素的操作；集合可以增刪元素，轉成數組之后，就能進行元素增刪操作了；

 

foreach：

只能獲取集合中的元素，但不能對集合進行操作；

迭代器：

除了遍歷集合元素，還可以進行remove集合中元素的操作；

如果使用ListIterator，還可以在遍歷元素時候進行增刪改查的動作；

 

for與foreach的區別：

foreach必須有被遍歷的目標；

方法的可變參數一定要定義在參數列表的最后面；

 

靜態導入：

當類重名時，需要指定具體的包名；

當方法重名時，需要制定具體的所屬對象或類；

 

一些實例：

/**
 * 迭代器的使用
 */
package collection;

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

public class IteratorDemo
{
    public static void main(String[] args)
    {
        iterator();
    }
    
    public static void iterator()
    {
        // 現在集合中添加元素
        ArrayList al = new ArrayList();
        al.add("java1");
        al.add("java2");
        al.add("java3");
        
        // 使用迭代器，可以對每一個元素進行操作
        // 通過iterator()方法獲得Iterator接口的子對象
        Iterator it = al.iterator();  
        // 判斷后面是否還有元素
        while(it.hasNext())
        {
            // 打印出后面這個元素
            System.out.println(it.next());
        }

         // 另外一種書寫方式
        // 使用這種方式，迭代器對象使用完之后就被銷毀了
        for(Iterator it2 = al.iterator(); it2.hasNext(); )
        {
            System.out.println(it2.next());
}
    }
}

 

/**
 * 功能：List集合特有的迭代器
 */
package collection;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;

public class IteratorDemo2
{
    public static void main(String[] args)
    {
        // iterator();
        listIterator();
    }
    
    public static void iterator()
    {
        ArrayList al = new ArrayList();
        al.add("java1");
        al.add("java2");
        al.add("java3");
        System.out.println(al);
        
        Iterator it = al.iterator();  
        while(it.hasNext())
        {
            Object obj = it.next();
            if(obj.equals("java2"))
            {
                // 以下寫法是錯誤的，會產生並發異常
                // 對元素操作，要么全用集合的方法，要么全用迭代器的方法
                // al.add("java4");
                
                // 將java2的引用從集合中刪掉
                // 迭代器本身只有這個刪除元素方法，比較局限
                it.remove();
            }
            
            // 還是能打印出java2，因為obj還在引用它
            System.out.println(obj);
        }
        
        // 打印不出來java2了，因為al對它的引用已經被刪掉了
        System.out.println(al);
    }
    
    public static void listIterator()
    {
        ArrayList al = new ArrayList();
        al.add("java1");
        al.add("java2");
        al.add("java3");
        System.out.println(al);
        
        ListIterator lit = al.listIterator();
        while(lit.hasNext())
        {
            Object obj = lit.next();
            if(obj.equals("java2"))
            {
                // 在java2后面添加一個java4
                lit.add("java4");
            }
            System.out.println(obj);
        }
        
        System.out.println(al);
    }
}

 

/**
 * 功能：Vector特有的迭代器，枚舉 
 */
package collection;

import java.util.Enumeration;
import java.util.Vector;

public class VectorDemo
{
    public static void main(String[] args)
    {
        Vector vt = new Vector();
        vt.add("java1");
        vt.add("java2");
        vt.add("java3");
        
        Enumeration<String> ea = vt.elements();
        while(ea.hasMoreElements())
        {
            System.out.println(ea.nextElement());
        }
    }
}

 

/**
 * 功能：集合中去除重復元素
 */
package collection;

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

public class RevDuplElement
{
    public static void main(String[] args)
    {
        ArrayList list = new ArrayList();
        list.add("one");
        list.add("one");
        list.add("two");
        list.add("two");
        list.add("three");
        list.add("three");
        
        System.out.println(test(list));
    }
    
    public static ArrayList test(ArrayList list)
    {
        ArrayList newList = new ArrayList();
        Iterator it = list.iterator();
        while(it.hasNext())
        {
            Object obj = it.next();
            if(!newList.contains(obj))
            {
                newList.add(obj);
            }
        }
        return newList;
    }
}

 

/**
 * 功能：向下轉型
 */
package collection;

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

public class Convert
{
    public static void main(String[] args)
    {
        ArrayList<Person3> list = new ArrayList<Person3>();
        list.add(new Person3("zhangsan",25));
        // add()方法里面的參數對象是Object，所以上面一句涉及到向上轉型，具體如下
        // Object obj = new Person3("zhangsan",25);
         // list.add(obj);
        list.add(new Person3("lisi",26));
        list.add(new Person3("wangwu",27));
        
        // 沒有使用泛型
        Iterator it = list.iterator();
        while(it.hasNext())
        {
            // 下面這樣寫(在沒有使用泛型的情況下)是錯誤的，因為it.next()返回的對象是Object類型，不是Person3類型
            // 所以不會有getName()方法，需要向下轉型
            // System.out.println("name" + it.next().getName());
            
            // 正確操作
            Person3 person = (Person3) it.next();
            System.out.println("name:" + person.getName() + ",age:" + person.getAge());
        }
        
        // 使用泛型
        Iterator<Person3> it2 = list.iterator();
        while(it2.hasNext())
        {
            System.out.println("name:" + it2.next().getName());
            // 不能這樣寫，因為每用一次next()都是找后面一個元素，而不是使用當前元素
            // System.out.println("name:" + it2.next().getName() + ",age:" + it2.next().getAge());
        }
    }
}

class Person3
{
    private String name;
    private int age;
    
    public Person3(String name, int age)
    {
        this.name = name;
        this.age = age;
    }
    
    public String getName()
    {
        return name;
    }
    public void setName(String name)
    {
        this.name = name;
    }
    public int getAge()
    {
        return age;
    }
    public void setAge(int age)
    {
        this.age = age;
    }
    
    @Override
    public String toString()
    {
        return "Person [name=" + name + ", age=" + age + "]";
    }
    
}

 

/**
 * 功能：List集合中，重寫equals方法，自定義判斷規則
 * 通過比較，去除集合中相同的元素
 */
package collection;

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

public class EqualsTest
{
    public static void main(String[] args)
    {
        ArrayList list = new ArrayList();
        list.add(new Student4("lisi01", 25));
        list.add(new Student4("lisi01", 25));
        list.add(new Student4("lisi02", 22));
        list.add(new Student4("lisi03", 23));
        list.add(new Student4("lisi02", 22));
        list.add(new Student4("lisi03", 23));
        
        list = com(list);
        
        Iterator it = list.iterator();
        while(it.hasNext())
        {
            Student4 student = (Student4) it.next();
            System.out.println(student.getName() + "," + student.getAge());
        }
    }
    
    public static ArrayList com(ArrayList list)
    {
        ArrayList newList = new ArrayList();
        Iterator it = list.iterator();
        while(it.hasNext())
        {
            Object obj = it.next();
            // contains()底層是用equals()方法來實現的
            // 讓Studnet4的兩個對象使用equals()來比較
            // 所以要修改Studnet4的equals()方法
            if(!newList.contains(obj))
            {
                newList.add(obj);
            }
        }
        
        return newList;
    }
}

class Student4
{
    private String name;
    private int age;
    
    public Student4(String name, int age)
    {
        this.name = name;
        this.age = age;
    }
    
    // 覆蓋繼承自Object的equals()
    //  形參類型必須是Object，否則不是繼承自Object類的方法
    public boolean equals(Object obj)
    {
        // 注意：obj必須放在前面
        if(! (obj instanceof Student4))
        {
            return false;
        }
        
        Student4 student = (Student4) obj;
        if(this.name.equals(student.getName()) && this.age==student.getAge())
        {
            return true;
        }
        else
        {
            return false;
        }
        
    }

    public String getName()
    {
        return name;
    }

    public void setName(String name)
    {
        this.name = name;
    }

    public int getAge()
    {
        return age;
    }

    public void setAge(int age)
    {
        this.age = age;
    }
    
}

 

/**
 * 功能：重寫hashCode()方法
 * Set集合中比較元素首先用hashCode()判斷地址是否相等
 * 再用equals()判斷元素內容是否相等
 */
package collection;

import java.util.HashSet;
import java.util.Iterator;

public class HashCodeTest
{
    public static void main(String[] args)
    {
        HashSet set = new HashSet();
        set.add(new Student5("lisi01",21));
        set.add(new Student5("lisi02",22));
        set.add(new Student5("lisi03",23));
        set.add(new Student5("lisi02",22));
        
        set = com(set);
        
        Iterator it = set.iterator();
        while(it.hasNext())
        {
            Student5 student = (Student5) it.next();
            System.out.println(student.getName() + "," + student.getAge());
        }
    }
    
    public static HashSet com(HashSet set)
    {
        HashSet newSet = new HashSet();
        Iterator it = set.iterator();
        while(it.hasNext())
        {
            Object obj = it.next();
            if(!(newSet.contains(obj)))
            {
                newSet.add(obj);
            }
        }
        return newSet;
    }
}

class Student5
{
    private String name;
    private int age;
    
    public Student5(String name, int age)
    {
        this.name = name;
        this.age = age;
    }
    
    // 重寫hashCode()方法
    public int hashCode()
    {
        return name.hashCode() + age;
    }
    
    // 重寫equals()方法
    public boolean equals(Object obj)
    {
        if(! (obj instanceof Student5))
        {
            return false;
        }
        
        Student5 student = (Student5) obj;
        if(this.name.equals(student.getName()) && this.age == student.getAge())
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    
    public String getName()
    {
        return name;
    }
    public void setName(String name)
    {
        this.name = name;
    }
    public int getAge()
    {
        return age;
    }
    public void setAge(int age)
    {
        this.age = age;
    }
    
}

 

/**
 * 功能：Comparable接口的使用
 */
package collection;

import java.util.Iterator;
import java.util.TreeSet;

public class TreeSetDemo
{
    public static void main(String[] args)
    {
        treeSetDemo();
    }
    
    public static void treeSetDemo()
    {
        TreeSet ts = new TreeSet();
        ts.add(new Student("t1",11));
        // 如果Student類沒有實現Comparable接口，多添加下面一條數據就拋異常
        // 因為這個類中的數據沒有可比較性
        ts.add(new Student("t2",12));
        ts.add(new Student("t3",13));
        
        Iterator it = ts.iterator();
        while(it.hasNext())
        {
            Student stu = (Student)it.next();
            System.out.println("name:" + stu.getName() + ",age:" + stu.getAge());
        }
        
    }
    
}

// 該接口強制讓學生具備比較性
class Student implements Comparable
{
    private String name;
    private int age;
    
    public Student(String name, int age)
    {
        this.name = name;
        this.age = age;
    }
    
    @Override
    public int compareTo(Object obj)
    {
        if(!(obj instanceof Student))
        {
            throw new RuntimeException("不是Student類");
        }
        
        Student stu = (Student)obj;
        
        if(this.age > stu.age)
            return 1;  // 只要返回正數即可
        if(this.age == stu.age)
        {
            // String類型本身也實現了Comparable接口
            return this.name.compareTo(stu.name);
        }
            
        return -1;  // 只要返回負數即可
    }

    public String getName()
    {
        return name;
    }
    
    public void setName(String name)
    {
        this.name = name;
    }
    
    public int getAge()
    {
        return age;
    }

    public void setAge(int age)
    {
        this.age = age;
    }
}

 

/**
 * 功能：Comparator的使用
 */
package collection;

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;

public class TreeSetDemo2
{
    public static void main(String[] args)
    {
        treeSerDemo2();
    }
    
    public static void treeSerDemo2()
    {
        TreeSet ts = new TreeSet(new MyComparator());
        ts.add(new Student2("t1",11));
        // 如果Student類沒有實現Comparator接口，多添加下面一條數據就拋異常
        // 因為這個類中的數據沒有可比較性
        ts.add(new Student2("t2",12));
        ts.add(new Student2("t3",13));
        
        Iterator it = ts.iterator();
        while(it.hasNext())
        {
            Student2 stu = (Student2)it.next();
            System.out.println("name:" + stu.getName() + ",age:" + stu.getAge());
        }
    }
}

class MyComparator implements Comparator
{

    @Override
    public int compare(Object o1, Object o2)
    {
       if(!(o1 instanceof Student2) || !(o2 instanceof Student2))
        {
            try
            {
                throw new Exception("傳入的比較對象不是要求的比較對象");
            } catch (Exception e)
            {
                e.printStackTrace();
            }
}

        Student2 stu1 = (Student2)o1;
        Student2 stu2 = (Student2)o2;
        
        int num = stu1.getName().compareTo(stu2.getName());
        if(num == 0)
        {
            // int型比較方法一
            // 封裝成Interger對象進行比較
            // return new Integer(stu1.getAge()).compareTo(new Integer(stu2.getAge()));
            
            // int型比較方法二
            if(stu1.getAge() > stu2.getAge())
                return 1;
            if(stu1.getAge() == stu2.getAge())
                return 0;
            return -1;
        }
        
        return num;
    }
    
}

class Student2
{
    private String name;
    private int age;
    
    public Student2(String name, int age)
    {
        this.name = name;
        this.age = age;
    }
    
    public String getName()
    {
        return name;
    }
    public void setName(String name)
    {
        this.name = name;
    }
    public int getAge()
    {
        return age;
    }
    public void setAge(int age)
    {
        this.age = age;
    }
}

 

/**
 * 功能：比較字符串長度是否相等
 */
package collection;

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;

public class TreeSetDemo3
{
    public static void main(String[] args)
    {
        TreeSet ts = new TreeSet(new MyStrComparator());
        ts.add("asd");
        ts.add("wer");
         ts.add("qaz");
        ts.add("qwerty");
        ts.add("df");
        
        Iterator it = ts.iterator();
        while(it.hasNext())
        {
            System.out.println(it.next());
        }
    }
}

class MyStrComparator implements Comparator
{
    @Override
    public int compare(Object o1, Object o2)
    {
        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;
    }
    
}

 

/**
 * 功能：匿名內部類的使用
 */
package collection;

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;

public class TreeSetDemo4
{
    public static void main(String[] args)
    {
        TreeSet ts = new TreeSet(new Comparator(){
            @Override
            public int compare(Object o1, Object o2)
            {
                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;
            }});
        
        ts.add("asd");
        ts.add("wer");
        ts.add("qwerty");
        ts.add("df");
        
        Iterator it = ts.iterator();
        while(it.hasNext())
        {
            System.out.println(it.next());
        }
    }
}

 

/**
 * 功能：泛型的使用
 */
package collection;

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

public class GenericDemo
{
    public static void main(String[] args)
    {
        genericDemo2();
    }
    
    // 沒有使用泛型
    public static void genericDemo()
    {
        ArrayList al = new ArrayList();
        al.add("qwe");
        // 上面添加的字符串，下面添加的是int，迭代時肯定會報類型轉換異常
        al.add(4);
        
        Iterator it = al.iterator();
        while(it.hasNext())
        {
            // 需要類型轉換
            // 此處在運行時會報類型轉換異常
            // 在編譯時不會報異常
            String s = (String)it.next();
            System.out.println(s + ":" + s.length());
        }
    }
    
    // JDK1.5之后使用泛型
    // 解決安全問題
    public static void genericDemo2()
    {
        // 指定只添加String類型數據
        ArrayList<String> al = new ArrayList<String>();
        al.add("qwe");
        // 編譯時下面這條語句就報錯了
        // al.add(4);
        
        // 迭代器也通過泛型指定類型
        // 后續就不需要進行內外部轉換了
        Iterator<String> it = al.iterator();
        while(it.hasNext())
        {
            String s = it.next();
            System.out.println(s + ":" + s.length());
        }
    }
}

 

/**
 * 功能：定義泛型類
 */
package collection;

public class GenericClass
{
    public static void main(String[] args)
    {
        Tool tool = new Tool();
        tool.setObject(new Teacher());
        // 沒用泛型之前，需要進行強轉
        Teacher teacher = (Teacher) tool.getObject();
        System.out.println(teacher);
        
        Util<Doctor> util = new Util<Doctor>();
        util.setObject(new Doctor());
        // 使用泛型之后，不需要進行強轉
        Doctor doctor = util.getObject();
        System.out.println(doctor);
    }
}

// 沒用泛型之前
class Tool
{
    private Object object;

    public Object getObject()
    {
        return object;
    }

    public void setObject(Object object)
    {
        this.object = object;
    }
    
}

// 用了泛型之后
class Util<Q>
{
    private Q object;
    
    public void setObject(Q q)
    {
        this.object = q;
    }
    public Q getObject()
    {
        return object;
    }
    
}

class Teacher
{
    
}

class Doctor
{
    
}

 

/**
 * 功能：將泛型定義在方法上
 */
package collection;

public class GenericDemo2
{
    public static void main(String[] args)
    {
        Utils ut = new Utils();
        // 可以打印字符串
        ut.show("qwe");
        // 可以打印int類型
        ut.show(12);
    }
}

class Utils
{
    public <T> void show(T t)
    {
        System.out.println("show:" + t);
    }
    
    public <Q> void print(Q q)
    {
        System.out.println("print:" + q);
    }
}

 

/**
 * 功能：類和方法上都定義泛型
 */
package collection;

public class GenericDemo3
{
    public static void main(String[] args)
    {
        Tools<String> tl = new Tools<String>();
        // 只能打印String類型
        tl.show("qwer");
        // 打印其他類型報錯
        // tl.show(123);
        
        // 可以打印String類型
        tl.print("qwe");
        // 也可以打印其他類型
        tl.print(123);
        
        Tools.display("qwe");
        Tools.display(123);
    }
}

class Tools<T>
{
    // 這個方法的類型是跟着對象（類型T）走的
    public void show(T t)
    {
        System.out.println("show:" + t);
    }
    
    // 這個方法的類型是跟着Q走的
    public <Q> void print(Q q)
    {
        System.out.println("print:" + q);
    }
    
    // 泛型定義在返回值的前面，修飾符的后面
    public static <W> void display(W w)
    {
        System.out.println("display:" + w);
    }
}

 

/**
 * 功能：接口上定義泛型
 */
package collection;

public class GenericDemo4
{
    public static void main(String[] args)
    {
        InterImpl ii = new InterImpl();
        ii.show("qwe");
        
        InterImpl2<String> ii2 = new InterImpl2<String>();
        ii2.show("asd");
        
        InterImpl2<Integer> ii3 = new InterImpl2<Integer>();
        ii3.show(123);
    }
}

interface Inter<T>
{
    public void show(T t);
}

class InterImpl implements Inter<String>
{
    @Override
    public void show(String t)
    {
        System.out.println("show:" + t);
    }
}

class InterImpl2<T> implements Inter<T>
{
    @Override
    public void show(T t)
    {
        System.out.println("show:" + t);
    }
}

 

/**
 * 功能：泛型的高級特性
 */
package collection;

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

public class GenericDemo5
{
    public static void main(String[] args)
    {
        ArrayList<String> al1 = new ArrayList<String>();
        al1.add("qwe");
        al1.add("asd");
        al1.add("zxc");
        
        ArrayList<Integer> al2 = new ArrayList<Integer>();
        al2.add(123);
        al2.add(456);
        al2.add(789);
        
        demo(al1);
        demo(al2);
        
        demo2(al1);
        demo2(al2);
    }
    
    // 不清楚是什么類型時候，可以用？代替
    public static void demo(ArrayList<?> al)
    {
        Iterator<?> it = al.iterator();
        while(it.hasNext())
        {
            System.out.println("al:" + it.next());
            // 以下使用length()是錯誤的
            // 因為不知道是什么類型，所以不能使用某一具體類型的特有方法
            // System.out.println(it.next().length());
        }
    }
    
    // 也可以換成T，但T代表了某一個具體類型
    // 操作方面有一點變化
    public static <T> void demo2(ArrayList<T> al)
    {
        Iterator<T> it = al.iterator();
        while(it.hasNext())
        {
            System.out.println("al:" + it.next());
            // 使用了某一具體類型之后
            // 可以用這個具體類型來接收迭代出來的元素，並進行其他具體操作
            // T t = it.next();
            // System.out.println("al:" + t);
        }
    }
}

 

/**
 * 功能：泛型的高級特性2
 */
package collection;

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

public class GenericDemo6
{
    public static void main(String[] args)
    {
        ArrayList<Person> al = new ArrayList<Person>();
        al.add(new Person("qwe"));
        al.add(new Person("asd"));
        al.add(new Person("zxc"));
        
        ArrayList<Worker> al2 = new ArrayList<Worker>();
        al2.add(new Worker("qwe"));
        al2.add(new Worker("asd"));
        al2.add(new Worker("zxc"));
        
        ArrayList<Student6> al3 = new ArrayList<Student6>();
        al3.add(new Student6("qwe"));
        al3.add(new Student6("asd"));
        al3.add(new Student6("zxc"));
        
        // 正確
        demo(al);
        // 錯誤，以下兩種情況都是不允許的，左右不匹配
        // ArrayList<Person> al2 = new ArrayList<Student>();
        // ArrayList<Student> al2 = new ArrayList<Person>();
        // demo(al2);
        
        demo3(al2);
        demo3(al);
        // Student6類不是Person類的子類，所以下面寫法錯誤
        // demo3(al3);
        
        demo4(al);
        demo4(al2);
        // Student6類不是Worker類的父類，所以下面寫法錯誤
        // demo4(al3);
    }
    
    public static void demo(ArrayList<Person> al)
    {
        Iterator<Person> it = al.iterator();
        while(it.hasNext())
        {
            Person p = it.next();
            System.out.println("name:" + p.getName());
        }
    }
    
    // 打印出所有類型
    public static void demo2(ArrayList<?> al)
    {
        Iterator<?> it = al.iterator();
        while(it.hasNext())
        {
            System.out.println(it.next());
        }
    }
    
    // 打印出指定的范圍：泛型限定
    // 只打印Person和它的子類
    public static void demo3(ArrayList<? extends Person> al)
    {
        Iterator<? extends Person> it = al.iterator();
        while(it.hasNext())
        {
            System.out.println(it.next().getName());
        }
    }
    
    public static void demo4(ArrayList<? super Worker> al)
    {
        Iterator<? super Worker> it = al.iterator();
        while(it.hasNext())
        {
            System.out.println(it.next());
        }
    }
}

class Person
{
    private String name;
    
    public Person(String name)
    {
        this.name = name;
    }
    
    public String getName()
    {
        return name;
    }
    
    public void setName(String name)
    {
        this.name = name;
    }
}

class Worker extends Person
{
    public Worker(String name)
    {
        super(name);
    }
}

class Student6
{
    private String name;
    public Student6(String name)
    {
        this.name = name;
    }
    public String getName()
    {
        return name;
    }
    public void setName(String name)
    {
        this.name = name;
    }
}

 

/**
 * 功能：泛型的高級應用3
 */
package collection;

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;

public class GenericDemo7
{
    public static void main(String[] args)
    {
        // 使用Studnet3類的構造器
        // TreeSet<Student3> tr = new TreeSet<Student3>(new StuComparator());
        // 使用通用的比較器（父類的比較器）
        TreeSet<Student3> tr = new TreeSet<Student3>(new MyComparator2());
        tr.add(new Student3("stu4"));
        tr.add(new Student3("stu2"));
        tr.add(new Student3("stu3"));
        
        Iterator<Student3> it = tr.iterator();
        while(it.hasNext())
        {
            System.out.println("tr:" + it.next().getName());
        }
        
        // 使用Worker2類的構造器
        // TreeSet<Worker2> tr2 = new TreeSet<Worker2>(new WorComparator());
        // 使用通用的比較器（父類的比較器）
        TreeSet<Worker2> tr2 = new TreeSet<Worker2>(new MyComparator2());
        tr2.add(new Worker2("wor1"));
        tr2.add(new Worker2("wor5"));
        tr2.add(new Worker2("wor3"));
        
        Iterator<Worker2> it2 = tr2.iterator();
        while(it2.hasNext())
        {
            System.out.println("tr:" + it2.next().getName());
        }
    }
}

// Student3類的比較器，分開寫很麻煩
class StuComparator implements Comparator<Student3>
{
    @Override
    public int compare(Student3 o1, Student3 o2)
    {
        return o1.getName().compareTo(o2.getName());
    }
}

// Worker2類的比較器，分開寫很麻煩
class WorComparator implements Comparator<Worker2>
{
    @Override
    public int compare(Worker2 o1, Worker2 o2)
    {
        return o1.getName().compareTo(o2.getName());
    }
}

// Comparator<? super E>
class MyComparator2 implements Comparator<Person2>
{
    @Override
    public int compare(Person2 o1, Person2 o2)
    {
        return o1.getName().compareTo(o2.getName());
    }
}

class Person2
{
    private String name;
    
    public Person2(String name)
    {
        this.name = name;
    }

    public String getName()
    {
        return name;
    }

    public void setName(String name)
    {
        this.name = name;
    }
    
}

class Student3 extends Person2
{
    // private String name;
    public Student3(String name)
    {
        super(name);
    }
}

class Worker2 extends Person2
{
    public Worker2(String name)
    {
        super(name);
    }
}

 

/**
 * 功能：獲取Map集合數據的兩種方式
 */
package collection;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class MapDemo
{
    public static void main(String[] args)
    {
        keySet();
        entrySet();
    }
    
    // 方法一：通過keySet()來獲取
    public static void keySet()
    {
        HashMap<String,String> map = new HashMap<String,String>();
        map.put("01", "zhangsan");
        map.put("05", "lisi");
        map.put("03", "wangwu");
        
        Set<String> keySet = map.keySet();
        
        Iterator<String> it = keySet.iterator();
        while(it.hasNext())
        {
            String key = it.next();
            String value = map.get(key);
            System.out.println("key:" + key + ",value:" + value);
        }
    }
    
    // 方法二：通過entrySet()來獲取
    public static void entrySet()
    {
        HashMap<String,String> map = new HashMap<String,String>();
        map.put("01", "zhangsan");
        map.put("05", "lisi");
        map.put("03", "wangwu");
        
        Set<Map.Entry<String, String>> entrySet = map.entrySet();
        Iterator<Map.Entry<String, String>> it = entrySet.iterator();
        while(it.hasNext())
        {
            Map.Entry<String, String> me = it.next();
            String key = me.getKey();
            String value = me.getValue();
            System.out.println("key:" + key + ",value:" + value);
        }
    }
}

 

/**
 * 功能：HashMap集合的擴展
 */
package collection;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;

public class MapDemo2
{
    public static void main(String[] args)
    {
        HashMap<String,String> yure = new HashMap<String,String>();
        yure.put("01", "zhangsan");
        yure.put("02", "lisi");
        
        HashMap<String,String> jiuye = new HashMap<String,String>();
        jiuye.put("03", "wangwu");
        jiuye.put("04", "zhaoliu");
        
        HashMap<String,HashMap<String,String>> czbk = new HashMap<String,HashMap<String,String>>();
        czbk.put("yure", yure);
        czbk.put("jiuye", jiuye);
        
        Set<String> map = czbk.keySet();
        Iterator<String> it = map.iterator();
        while(it.hasNext())
        {
            String key = it.next();
            HashMap<String,String> values = czbk.get(key);
            System.out.println("key:" + key + "values:" + values);
            getStuInfo(values);
        }
        
        // getStuInfo(jiuye);
    }
    
    public static void getStuInfo(HashMap<String,String> room)
    {
        Set<String> map = room.keySet();
        Iterator<String> it = map.iterator();
        while(it.hasNext())
        {
            String key = it.next();
            String value = room.get(key);
            System.out.println("id:" + key + ",value:" + value);
        }
    }
}

 

/**
 * 功能：JDK1.5新特性，可變參數
 */
package collection;

public class CollectionDemo
{
    public static void main(String[] args)
    {
        syso(1,2,3,4,5);
        syso(3,4);
    }
    
    public static void syso(int... arr)
    {
        for(int i=0;i<arr.length;i++)
        {
            System.out.println(i);
        }
    }
}

 

/**
 * 功能：JDK1.5新特性，靜態導入
 */
package collection;

import java.util.Arrays;

// 實現靜態導入，導入的是Arrays這個類中的所有靜態成員
import static java.util.Arrays.*;

public class CollectionDemo2
{
    public static void main(String[] args)
    {
        int[] arr = {6,2,8};
        // 原來是這樣寫的
        // int index = Arrays.binarySearch(arr, 2);
        // 現在可以這樣寫
        int index = binarySearch(arr, 2);
        
        System.out.println(index);
        
    }
}