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:底層的數據結構使用的是哈希表; 不可以存入nullnull值; 該集合是線程同步的;  效率低;

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

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

 

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

 

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

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

 

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

 

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

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

 

foreach

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

迭代器:

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

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

 

forforeach的區別:

foreach必須有被遍歷的目標;

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

 

靜態導入:

當類重名時,需要指定具體的包名;

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

 

一些實例:

 1 /**
 2  * 迭代器的使用
 3  */
 4 package collection;
 5 
 6 import java.util.ArrayList;
 7 import java.util.Iterator;
 8 
 9 public class IteratorDemo
10 {
11     public static void main(String[] args)
12     {
13         iterator();
14     }
15     
16     public static void iterator()
17     {
18         // 現在集合中添加元素
19         ArrayList al = new ArrayList();
20         al.add("java1");
21         al.add("java2");
22         al.add("java3");
23         
24         // 使用迭代器,可以對每一個元素進行操作
25         // 通過iterator()方法獲得Iterator接口的子對象
26         Iterator it = al.iterator();  
27         // 判斷后面是否還有元素
28         while(it.hasNext())
29         {
30             // 打印出后面這個元素
31             System.out.println(it.next());
32         }
33 
34          // 另外一種書寫方式
35         // 使用這種方式,迭代器對象使用完之后就被銷毀了
36         for(Iterator it2 = al.iterator(); it2.hasNext(); )
37         {
38             System.out.println(it2.next());
39 }
40     }
41 }

 

 1 /**
 2  * 功能:List集合特有的迭代器
 3  */
 4 package collection;
 5 
 6 import java.util.ArrayList;
 7 import java.util.Iterator;
 8 import java.util.ListIterator;
 9 
10 public class IteratorDemo2
11 {
12     public static void main(String[] args)
13     {
14         // iterator();
15         listIterator();
16     }
17     
18     public static void iterator()
19     {
20         ArrayList al = new ArrayList();
21         al.add("java1");
22         al.add("java2");
23         al.add("java3");
24         System.out.println(al);
25         
26         Iterator it = al.iterator();  
27         while(it.hasNext())
28         {
29             Object obj = it.next();
30             if(obj.equals("java2"))
31             {
32                 // 以下寫法是錯誤的,會產生並發異常
33                 // 對元素操作,要么全用集合的方法,要么全用迭代器的方法
34                 // al.add("java4");
35                 
36                 // 將java2的引用從集合中刪掉
37                 // 迭代器本身只有這個刪除元素方法,比較局限
38                 it.remove();
39             }
40             
41             // 還是能打印出java2,因為obj還在引用它
42             System.out.println(obj);
43         }
44         
45         // 打印不出來java2了,因為al對它的引用已經被刪掉了
46         System.out.println(al);
47     }
48     
49     public static void listIterator()
50     {
51         ArrayList al = new ArrayList();
52         al.add("java1");
53         al.add("java2");
54         al.add("java3");
55         System.out.println(al);
56         
57         ListIterator lit = al.listIterator();
58         while(lit.hasNext())
59         {
60             Object obj = lit.next();
61             if(obj.equals("java2"))
62             {
63                 // 在java2后面添加一個java4
64                 lit.add("java4");
65             }
66             System.out.println(obj);
67         }
68         
69         System.out.println(al);
70     }
71 }

 

 1 /**
 2  * 功能:Vector特有的迭代器,枚舉 
 3  */
 4 package collection;
 5 
 6 import java.util.Enumeration;
 7 import java.util.Vector;
 8 
 9 public class VectorDemo
10 {
11     public static void main(String[] args)
12     {
13         Vector vt = new Vector();
14         vt.add("java1");
15         vt.add("java2");
16         vt.add("java3");
17         
18         Enumeration<String> ea = vt.elements();
19         while(ea.hasMoreElements())
20         {
21             System.out.println(ea.nextElement());
22         }
23     }
24 }

 

 1 /**
 2  * 功能:集合中去除重復元素
 3  */
 4 package collection;
 5 
 6 import java.util.ArrayList;
 7 import java.util.Iterator;
 8 
 9 public class RevDuplElement
10 {
11     public static void main(String[] args)
12     {
13         ArrayList list = new ArrayList();
14         list.add("one");
15         list.add("one");
16         list.add("two");
17         list.add("two");
18         list.add("three");
19         list.add("three");
20         
21         System.out.println(test(list));
22     }
23     
24     public static ArrayList test(ArrayList list)
25     {
26         ArrayList newList = new ArrayList();
27         Iterator it = list.iterator();
28         while(it.hasNext())
29         {
30             Object obj = it.next();
31             if(!newList.contains(obj))
32             {
33                 newList.add(obj);
34             }
35         }
36         return newList;
37     }
38 }

 

 1 /**
 2  * 功能:向下轉型
 3  */
 4 package collection;
 5 
 6 import java.util.ArrayList;
 7 import java.util.Iterator;
 8 
 9 public class Convert
10 {
11     public static void main(String[] args)
12     {
13         ArrayList<Person3> list = new ArrayList<Person3>();
14         list.add(new Person3("zhangsan",25));
15         // add()方法里面的參數對象是Object,所以上面一句涉及到向上轉型,具體如下
16         // Object obj = new Person3("zhangsan",25);
17          // list.add(obj);
18         list.add(new Person3("lisi",26));
19         list.add(new Person3("wangwu",27));
20         
21         // 沒有使用泛型
22         Iterator it = list.iterator();
23         while(it.hasNext())
24         {
25             // 下面這樣寫(在沒有使用泛型的情況下)是錯誤的,因為it.next()返回的對象是Object類型,不是Person3類型
26             // 所以不會有getName()方法,需要向下轉型
27             // System.out.println("name" + it.next().getName());
28             
29             // 正確操作
30             Person3 person = (Person3) it.next();
31             System.out.println("name:" + person.getName() + ",age:" + person.getAge());
32         }
33         
34         // 使用泛型
35         Iterator<Person3> it2 = list.iterator();
36         while(it2.hasNext())
37         {
38             System.out.println("name:" + it2.next().getName());
39             // 不能這樣寫,因為每用一次next()都是找后面一個元素,而不是使用當前元素
40             // System.out.println("name:" + it2.next().getName() + ",age:" + it2.next().getAge());
41         }
42     }
43 }
44 
45 class Person3
46 {
47     private String name;
48     private int age;
49     
50     public Person3(String name, int age)
51     {
52         this.name = name;
53         this.age = age;
54     }
55     
56     public String getName()
57     {
58         return name;
59     }
60     public void setName(String name)
61     {
62         this.name = name;
63     }
64     public int getAge()
65     {
66         return age;
67     }
68     public void setAge(int age)
69     {
70         this.age = age;
71     }
72     
73     @Override
74     public String toString()
75     {
76         return "Person [name=" + name + ", age=" + age + "]";
77     }
78     
79 }

 

  1 /**
  2  * 功能:List集合中,重寫equals方法,自定義判斷規則
  3  * 通過比較,去除集合中相同的元素
  4  */
  5 package collection;
  6 
  7 import java.util.ArrayList;
  8 import java.util.Iterator;
  9 
 10 public class EqualsTest
 11 {
 12     public static void main(String[] args)
 13     {
 14         ArrayList list = new ArrayList();
 15         list.add(new Student4("lisi01", 25));
 16         list.add(new Student4("lisi01", 25));
 17         list.add(new Student4("lisi02", 22));
 18         list.add(new Student4("lisi03", 23));
 19         list.add(new Student4("lisi02", 22));
 20         list.add(new Student4("lisi03", 23));
 21         
 22         list = com(list);
 23         
 24         Iterator it = list.iterator();
 25         while(it.hasNext())
 26         {
 27             Student4 student = (Student4) it.next();
 28             System.out.println(student.getName() + "," + student.getAge());
 29         }
 30     }
 31     
 32     public static ArrayList com(ArrayList list)
 33     {
 34         ArrayList newList = new ArrayList();
 35         Iterator it = list.iterator();
 36         while(it.hasNext())
 37         {
 38             Object obj = it.next();
 39             // contains()底層是用equals()方法來實現的
 40             // 讓Studnet4的兩個對象使用equals()來比較
 41             // 所以要修改Studnet4的equals()方法
 42             if(!newList.contains(obj))
 43             {
 44                 newList.add(obj);
 45             }
 46         }
 47         
 48         return newList;
 49     }
 50 }
 51 
 52 class Student4
 53 {
 54     private String name;
 55     private int age;
 56     
 57     public Student4(String name, int age)
 58     {
 59         this.name = name;
 60         this.age = age;
 61     }
 62     
 63     // 覆蓋繼承自Object的equals()
 64     //  形參類型必須是Object,否則不是繼承自Object類的方法
 65     public boolean equals(Object obj)
 66     {
 67         // 注意:obj必須放在前面
 68         if(! (obj instanceof Student4))
 69         {
 70             return false;
 71         }
 72         
 73         Student4 student = (Student4) obj;
 74         if(this.name.equals(student.getName()) && this.age==student.getAge())
 75         {
 76             return true;
 77         }
 78         else
 79         {
 80             return false;
 81         }
 82         
 83     }
 84 
 85     public String getName()
 86     {
 87         return name;
 88     }
 89 
 90     public void setName(String name)
 91     {
 92         this.name = name;
 93     }
 94 
 95     public int getAge()
 96     {
 97         return age;
 98     }
 99 
100     public void setAge(int age)
101     {
102         this.age = age;
103     }
104     
105 }

 

  1 /**
  2  * 功能:重寫hashCode()方法
  3  * Set集合中比較元素首先用hashCode()判斷地址是否相等
  4  * 再用equals()判斷元素內容是否相等
  5  */
  6 package collection;
  7 
  8 import java.util.HashSet;
  9 import java.util.Iterator;
 10 
 11 public class HashCodeTest
 12 {
 13     public static void main(String[] args)
 14     {
 15         HashSet set = new HashSet();
 16         set.add(new Student5("lisi01",21));
 17         set.add(new Student5("lisi02",22));
 18         set.add(new Student5("lisi03",23));
 19         set.add(new Student5("lisi02",22));
 20         
 21         set = com(set);
 22         
 23         Iterator it = set.iterator();
 24         while(it.hasNext())
 25         {
 26             Student5 student = (Student5) it.next();
 27             System.out.println(student.getName() + "," + student.getAge());
 28         }
 29     }
 30     
 31     public static HashSet com(HashSet set)
 32     {
 33         HashSet newSet = new HashSet();
 34         Iterator it = set.iterator();
 35         while(it.hasNext())
 36         {
 37             Object obj = it.next();
 38             if(!(newSet.contains(obj)))
 39             {
 40                 newSet.add(obj);
 41             }
 42         }
 43         return newSet;
 44     }
 45 }
 46 
 47 class Student5
 48 {
 49     private String name;
 50     private int age;
 51     
 52     public Student5(String name, int age)
 53     {
 54         this.name = name;
 55         this.age = age;
 56     }
 57     
 58     // 重寫hashCode()方法
 59     public int hashCode()
 60     {
 61         return name.hashCode() + age;
 62     }
 63     
 64     // 重寫equals()方法
 65     public boolean equals(Object obj)
 66     {
 67         if(! (obj instanceof Student5))
 68         {
 69             return false;
 70         }
 71         
 72         Student5 student = (Student5) obj;
 73         if(this.name.equals(student.getName()) && this.age == student.getAge())
 74         {
 75             return true;
 76         }
 77         else
 78         {
 79             return false;
 80         }
 81     }
 82     
 83     public String getName()
 84     {
 85         return name;
 86     }
 87     public void setName(String name)
 88     {
 89         this.name = name;
 90     }
 91     public int getAge()
 92     {
 93         return age;
 94     }
 95     public void setAge(int age)
 96     {
 97         this.age = age;
 98     }
 99     
100 }

 

 1 /**
 2  * 功能:Comparable接口的使用
 3  */
 4 package collection;
 5 
 6 import java.util.Iterator;
 7 import java.util.TreeSet;
 8 
 9 public class TreeSetDemo
10 {
11     public static void main(String[] args)
12     {
13         treeSetDemo();
14     }
15     
16     public static void treeSetDemo()
17     {
18         TreeSet ts = new TreeSet();
19         ts.add(new Student("t1",11));
20         // 如果Student類沒有實現Comparable接口,多添加下面一條數據就拋異常
21         // 因為這個類中的數據沒有可比較性
22         ts.add(new Student("t2",12));
23         ts.add(new Student("t3",13));
24         
25         Iterator it = ts.iterator();
26         while(it.hasNext())
27         {
28             Student stu = (Student)it.next();
29             System.out.println("name:" + stu.getName() + ",age:" + stu.getAge());
30         }
31         
32     }
33     
34 }
35 
36 // 該接口強制讓學生具備比較性
37 class Student implements Comparable
38 {
39     private String name;
40     private int age;
41     
42     public Student(String name, int age)
43     {
44         this.name = name;
45         this.age = age;
46     }
47     
48     @Override
49     public int compareTo(Object obj)
50     {
51         if(!(obj instanceof Student))
52         {
53             throw new RuntimeException("不是Student類");
54         }
55         
56         Student stu = (Student)obj;
57         
58         if(this.age > stu.age)
59             return 1;  // 只要返回正數即可
60         if(this.age == stu.age)
61         {
62             // String類型本身也實現了Comparable接口
63             return this.name.compareTo(stu.name);
64         }
65             
66         return -1;  // 只要返回負數即可
67     }
68 
69     public String getName()
70     {
71         return name;
72     }
73     
74     public void setName(String name)
75     {
76         this.name = name;
77     }
78     
79     public int getAge()
80     {
81         return age;
82     }
83 
84     public void setAge(int age)
85     {
86         this.age = age;
87     }
88 }

 

  1 /**
  2  * 功能:Comparator的使用
  3  */
  4 package collection;
  5 
  6 import java.util.Comparator;
  7 import java.util.Iterator;
  8 import java.util.TreeSet;
  9 
 10 public class TreeSetDemo2
 11 {
 12     public static void main(String[] args)
 13     {
 14         treeSerDemo2();
 15     }
 16     
 17     public static void treeSerDemo2()
 18     {
 19         TreeSet ts = new TreeSet(new MyComparator());
 20         ts.add(new Student2("t1",11));
 21         // 如果Student類沒有實現Comparator接口,多添加下面一條數據就拋異常
 22         // 因為這個類中的數據沒有可比較性
 23         ts.add(new Student2("t2",12));
 24         ts.add(new Student2("t3",13));
 25         
 26         Iterator it = ts.iterator();
 27         while(it.hasNext())
 28         {
 29             Student2 stu = (Student2)it.next();
 30             System.out.println("name:" + stu.getName() + ",age:" + stu.getAge());
 31         }
 32     }
 33 }
 34 
 35 class MyComparator implements Comparator
 36 {
 37 
 38     @Override
 39     public int compare(Object o1, Object o2)
 40     {
 41        if(!(o1 instanceof Student2) || !(o2 instanceof Student2))
 42         {
 43             try
 44             {
 45                 throw new Exception("傳入的比較對象不是要求的比較對象");
 46             } catch (Exception e)
 47             {
 48                 e.printStackTrace();
 49             }
 50 }
 51 
 52         Student2 stu1 = (Student2)o1;
 53         Student2 stu2 = (Student2)o2;
 54         
 55         int num = stu1.getName().compareTo(stu2.getName());
 56         if(num == 0)
 57         {
 58             // int型比較方法一
 59             // 封裝成Interger對象進行比較
 60             // return new Integer(stu1.getAge()).compareTo(new Integer(stu2.getAge()));
 61             
 62             // int型比較方法二
 63             if(stu1.getAge() > stu2.getAge())
 64                 return 1;
 65             if(stu1.getAge() == stu2.getAge())
 66                 return 0;
 67             return -1;
 68         }
 69         
 70         return num;
 71     }
 72     
 73 }
 74 
 75 class Student2
 76 {
 77     private String name;
 78     private int age;
 79     
 80     public Student2(String name, int age)
 81     {
 82         this.name = name;
 83         this.age = age;
 84     }
 85     
 86     public String getName()
 87     {
 88         return name;
 89     }
 90     public void setName(String name)
 91     {
 92         this.name = name;
 93     }
 94     public int getAge()
 95     {
 96         return age;
 97     }
 98     public void setAge(int age)
 99     {
100         this.age = age;
101     }
102 }

 

 1 /**
 2  * 功能:比較字符串長度是否相等
 3  */
 4 package collection;
 5 
 6 import java.util.Comparator;
 7 import java.util.Iterator;
 8 import java.util.TreeSet;
 9 
10 public class TreeSetDemo3
11 {
12     public static void main(String[] args)
13     {
14         TreeSet ts = new TreeSet(new MyStrComparator());
15         ts.add("asd");
16         ts.add("wer");
17          ts.add("qaz");
18         ts.add("qwerty");
19         ts.add("df");
20         
21         Iterator it = ts.iterator();
22         while(it.hasNext())
23         {
24             System.out.println(it.next());
25         }
26     }
27 }
28 
29 class MyStrComparator implements Comparator
30 {
31     @Override
32     public int compare(Object o1, Object o2)
33     {
34         String s1 = (String)o1;
35         String s2 = (String)o2;
36         
37         int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));
38         if(num == 0)
39         {
40             return s1.compareTo(s2);
41         }
42         return num;
43     }
44     
45 }

 

 1 /**
 2  * 功能:匿名內部類的使用
 3  */
 4 package collection;
 5 
 6 import java.util.Comparator;
 7 import java.util.Iterator;
 8 import java.util.TreeSet;
 9 
10 public class TreeSetDemo4
11 {
12     public static void main(String[] args)
13     {
14         TreeSet ts = new TreeSet(new Comparator(){
15             @Override
16             public int compare(Object o1, Object o2)
17             {
18                 String s1 = (String)o1;
19                 String s2 = (String)o2;
20                 
21                 int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));
22                 if(num == 0)
23                 {
24                     return s1.compareTo(s2);
25                 }
26                 return num;
27             }});
28         
29         ts.add("asd");
30         ts.add("wer");
31         ts.add("qwerty");
32         ts.add("df");
33         
34         Iterator it = ts.iterator();
35         while(it.hasNext())
36         {
37             System.out.println(it.next());
38         }
39     }
40 }

 

 1 /**
 2  * 功能:泛型的使用
 3  */
 4 package collection;
 5 
 6 import java.util.ArrayList;
 7 import java.util.Iterator;
 8 
 9 public class GenericDemo
10 {
11     public static void main(String[] args)
12     {
13         genericDemo2();
14     }
15     
16     // 沒有使用泛型
17     public static void genericDemo()
18     {
19         ArrayList al = new ArrayList();
20         al.add("qwe");
21         // 上面添加的字符串,下面添加的是int,迭代時肯定會報類型轉換異常
22         al.add(4);
23         
24         Iterator it = al.iterator();
25         while(it.hasNext())
26         {
27             // 需要類型轉換
28             // 此處在運行時會報類型轉換異常
29             // 在編譯時不會報異常
30             String s = (String)it.next();
31             System.out.println(s + ":" + s.length());
32         }
33     }
34     
35     // JDK1.5之后使用泛型
36     // 解決安全問題
37     public static void genericDemo2()
38     {
39         // 指定只添加String類型數據
40         ArrayList<String> al = new ArrayList<String>();
41         al.add("qwe");
42         // 編譯時下面這條語句就報錯了
43         // al.add(4);
44         
45         // 迭代器也通過泛型指定類型
46         // 后續就不需要進行內外部轉換了
47         Iterator<String> it = al.iterator();
48         while(it.hasNext())
49         {
50             String s = it.next();
51             System.out.println(s + ":" + s.length());
52         }
53     }
54 }

 

 1 /**
 2  * 功能:定義泛型類
 3  */
 4 package collection;
 5 
 6 public class GenericClass
 7 {
 8     public static void main(String[] args)
 9     {
10         Tool tool = new Tool();
11         tool.setObject(new Teacher());
12         // 沒用泛型之前,需要進行強轉
13         Teacher teacher = (Teacher) tool.getObject();
14         System.out.println(teacher);
15         
16         Util<Doctor> util = new Util<Doctor>();
17         util.setObject(new Doctor());
18         // 使用泛型之后,不需要進行強轉
19         Doctor doctor = util.getObject();
20         System.out.println(doctor);
21     }
22 }
23 
24 // 沒用泛型之前
25 class Tool
26 {
27     private Object object;
28 
29     public Object getObject()
30     {
31         return object;
32     }
33 
34     public void setObject(Object object)
35     {
36         this.object = object;
37     }
38     
39 }
40 
41 // 用了泛型之后
42 class Util<Q>
43 {
44     private Q object;
45     
46     public void setObject(Q q)
47     {
48         this.object = q;
49     }
50     public Q getObject()
51     {
52         return object;
53     }
54     
55 }
56 
57 class Teacher
58 {
59     
60 }
61 
62 class Doctor
63 {
64     
65 }

 

 1 /**
 2  * 功能:將泛型定義在方法上
 3  */
 4 package collection;
 5 
 6 public class GenericDemo2
 7 {
 8     public static void main(String[] args)
 9     {
10         Utils ut = new Utils();
11         // 可以打印字符串
12         ut.show("qwe");
13         // 可以打印int類型
14         ut.show(12);
15     }
16 }
17 
18 class Utils
19 {
20     public <T> void show(T t)
21     {
22         System.out.println("show:" + t);
23     }
24     
25     public <Q> void print(Q q)
26     {
27         System.out.println("print:" + q);
28     }
29 }

 

 1 /**
 2  * 功能:類和方法上都定義泛型
 3  */
 4 package collection;
 5 
 6 public class GenericDemo3
 7 {
 8     public static void main(String[] args)
 9     {
10         Tools<String> tl = new Tools<String>();
11         // 只能打印String類型
12         tl.show("qwer");
13         // 打印其他類型報錯
14         // tl.show(123);
15         
16         // 可以打印String類型
17         tl.print("qwe");
18         // 也可以打印其他類型
19         tl.print(123);
20         
21         Tools.display("qwe");
22         Tools.display(123);
23     }
24 }
25 
26 class Tools<T>
27 {
28     // 這個方法的類型是跟着對象(類型T)走的
29     public void show(T t)
30     {
31         System.out.println("show:" + t);
32     }
33     
34     // 這個方法的類型是跟着Q走的
35     public <Q> void print(Q q)
36     {
37         System.out.println("print:" + q);
38     }
39     
40     // 泛型定義在返回值的前面,修飾符的后面
41     public static <W> void display(W w)
42     {
43         System.out.println("display:" + w);
44     }
45 }

 

 1 /**
 2  * 功能:接口上定義泛型
 3  */
 4 package collection;
 5 
 6 public class GenericDemo4
 7 {
 8     public static void main(String[] args)
 9     {
10         InterImpl ii = new InterImpl();
11         ii.show("qwe");
12         
13         InterImpl2<String> ii2 = new InterImpl2<String>();
14         ii2.show("asd");
15         
16         InterImpl2<Integer> ii3 = new InterImpl2<Integer>();
17         ii3.show(123);
18     }
19 }
20 
21 interface Inter<T>
22 {
23     public void show(T t);
24 }
25 
26 class InterImpl implements Inter<String>
27 {
28     @Override
29     public void show(String t)
30     {
31         System.out.println("show:" + t);
32     }
33 }
34 
35 class InterImpl2<T> implements Inter<T>
36 {
37     @Override
38     public void show(T t)
39     {
40         System.out.println("show:" + t);
41     }
42 }

 

 1 /**
 2  * 功能:泛型的高級特性
 3  */
 4 package collection;
 5 
 6 import java.util.ArrayList;
 7 import java.util.Iterator;
 8 
 9 public class GenericDemo5
10 {
11     public static void main(String[] args)
12     {
13         ArrayList<String> al1 = new ArrayList<String>();
14         al1.add("qwe");
15         al1.add("asd");
16         al1.add("zxc");
17         
18         ArrayList<Integer> al2 = new ArrayList<Integer>();
19         al2.add(123);
20         al2.add(456);
21         al2.add(789);
22         
23         demo(al1);
24         demo(al2);
25         
26         demo2(al1);
27         demo2(al2);
28     }
29     
30     // 不清楚是什么類型時候,可以用?代替
31     public static void demo(ArrayList<?> al)
32     {
33         Iterator<?> it = al.iterator();
34         while(it.hasNext())
35         {
36             System.out.println("al:" + it.next());
37             // 以下使用length()是錯誤的
38             // 因為不知道是什么類型,所以不能使用某一具體類型的特有方法
39             // System.out.println(it.next().length());
40         }
41     }
42     
43     // 也可以換成T,但T代表了某一個具體類型
44     // 操作方面有一點變化
45     public static <T> void demo2(ArrayList<T> al)
46     {
47         Iterator<T> it = al.iterator();
48         while(it.hasNext())
49         {
50             System.out.println("al:" + it.next());
51             // 使用了某一具體類型之后
52             // 可以用這個具體類型來接收迭代出來的元素,並進行其他具體操作
53             // T t = it.next();
54             // System.out.println("al:" + t);
55         }
56     }
57 }

 

  1 /**
  2  * 功能:泛型的高級特性2
  3  */
  4 package collection;
  5 
  6 import java.util.ArrayList;
  7 import java.util.Iterator;
  8 
  9 public class GenericDemo6
 10 {
 11     public static void main(String[] args)
 12     {
 13         ArrayList<Person> al = new ArrayList<Person>();
 14         al.add(new Person("qwe"));
 15         al.add(new Person("asd"));
 16         al.add(new Person("zxc"));
 17         
 18         ArrayList<Worker> al2 = new ArrayList<Worker>();
 19         al2.add(new Worker("qwe"));
 20         al2.add(new Worker("asd"));
 21         al2.add(new Worker("zxc"));
 22         
 23         ArrayList<Student6> al3 = new ArrayList<Student6>();
 24         al3.add(new Student6("qwe"));
 25         al3.add(new Student6("asd"));
 26         al3.add(new Student6("zxc"));
 27         
 28         // 正確
 29         demo(al);
 30         // 錯誤,以下兩種情況都是不允許的,左右不匹配
 31         // ArrayList<Person> al2 = new ArrayList<Student>();
 32         // ArrayList<Student> al2 = new ArrayList<Person>();
 33         // demo(al2);
 34         
 35         demo3(al2);
 36         demo3(al);
 37         // Student6類不是Person類的子類,所以下面寫法錯誤
 38         // demo3(al3);
 39         
 40         demo4(al);
 41         demo4(al2);
 42         // Student6類不是Worker類的父類,所以下面寫法錯誤
 43         // demo4(al3);
 44     }
 45     
 46     public static void demo(ArrayList<Person> al)
 47     {
 48         Iterator<Person> it = al.iterator();
 49         while(it.hasNext())
 50         {
 51             Person p = it.next();
 52             System.out.println("name:" + p.getName());
 53         }
 54     }
 55     
 56     // 打印出所有類型
 57     public static void demo2(ArrayList<?> al)
 58     {
 59         Iterator<?> it = al.iterator();
 60         while(it.hasNext())
 61         {
 62             System.out.println(it.next());
 63         }
 64     }
 65     
 66     // 打印出指定的范圍:泛型限定
 67     // 只打印Person和它的子類
 68     public static void demo3(ArrayList<? extends Person> al)
 69     {
 70         Iterator<? extends Person> it = al.iterator();
 71         while(it.hasNext())
 72         {
 73             System.out.println(it.next().getName());
 74         }
 75     }
 76     
 77     public static void demo4(ArrayList<? super Worker> al)
 78     {
 79         Iterator<? super Worker> it = al.iterator();
 80         while(it.hasNext())
 81         {
 82             System.out.println(it.next());
 83         }
 84     }
 85 }
 86 
 87 class Person
 88 {
 89     private String name;
 90     
 91     public Person(String name)
 92     {
 93         this.name = name;
 94     }
 95     
 96     public String getName()
 97     {
 98         return name;
 99     }
100     
101     public void setName(String name)
102     {
103         this.name = name;
104     }
105 }
106 
107 class Worker extends Person
108 {
109     public Worker(String name)
110     {
111         super(name);
112     }
113 }
114 
115 class Student6
116 {
117     private String name;
118     public Student6(String name)
119     {
120         this.name = name;
121     }
122     public String getName()
123     {
124         return name;
125     }
126     public void setName(String name)
127     {
128         this.name = name;
129     }
130 }

 

  1 /**
  2  * 功能:泛型的高級應用3
  3  */
  4 package collection;
  5 
  6 import java.util.Comparator;
  7 import java.util.Iterator;
  8 import java.util.TreeSet;
  9 
 10 public class GenericDemo7
 11 {
 12     public static void main(String[] args)
 13     {
 14         // 使用Studnet3類的構造器
 15         // TreeSet<Student3> tr = new TreeSet<Student3>(new StuComparator());
 16         // 使用通用的比較器(父類的比較器)
 17         TreeSet<Student3> tr = new TreeSet<Student3>(new MyComparator2());
 18         tr.add(new Student3("stu4"));
 19         tr.add(new Student3("stu2"));
 20         tr.add(new Student3("stu3"));
 21         
 22         Iterator<Student3> it = tr.iterator();
 23         while(it.hasNext())
 24         {
 25             System.out.println("tr:" + it.next().getName());
 26         }
 27         
 28         // 使用Worker2類的構造器
 29         // TreeSet<Worker2> tr2 = new TreeSet<Worker2>(new WorComparator());
 30         // 使用通用的比較器(父類的比較器)
 31         TreeSet<Worker2> tr2 = new TreeSet<Worker2>(new MyComparator2());
 32         tr2.add(new Worker2("wor1"));
 33         tr2.add(new Worker2("wor5"));
 34         tr2.add(new Worker2("wor3"));
 35         
 36         Iterator<Worker2> it2 = tr2.iterator();
 37         while(it2.hasNext())
 38         {
 39             System.out.println("tr:" + it2.next().getName());
 40         }
 41     }
 42 }
 43 
 44 // Student3類的比較器,分開寫很麻煩
 45 class StuComparator implements Comparator<Student3>
 46 {
 47     @Override
 48     public int compare(Student3 o1, Student3 o2)
 49     {
 50         return o1.getName().compareTo(o2.getName());
 51     }
 52 }
 53 
 54 // Worker2類的比較器,分開寫很麻煩
 55 class WorComparator implements Comparator<Worker2>
 56 {
 57     @Override
 58     public int compare(Worker2 o1, Worker2 o2)
 59     {
 60         return o1.getName().compareTo(o2.getName());
 61     }
 62 }
 63 
 64 // Comparator<? super E>
 65 class MyComparator2 implements Comparator<Person2>
 66 {
 67     @Override
 68     public int compare(Person2 o1, Person2 o2)
 69     {
 70         return o1.getName().compareTo(o2.getName());
 71     }
 72 }
 73 
 74 class Person2
 75 {
 76     private String name;
 77     
 78     public Person2(String name)
 79     {
 80         this.name = name;
 81     }
 82 
 83     public String getName()
 84     {
 85         return name;
 86     }
 87 
 88     public void setName(String name)
 89     {
 90         this.name = name;
 91     }
 92     
 93 }
 94 
 95 class Student3 extends Person2
 96 {
 97     // private String name;
 98     public Student3(String name)
 99     {
100         super(name);
101     }
102 }
103 
104 class Worker2 extends Person2
105 {
106     public Worker2(String name)
107     {
108         super(name);
109     }
110 }

 

 1 /**
 2  * 功能:獲取Map集合數據的兩種方式
 3  */
 4 package collection;
 5 
 6 import java.util.HashMap;
 7 import java.util.Iterator;
 8 import java.util.Map;
 9 import java.util.Set;
10 
11 public class MapDemo
12 {
13     public static void main(String[] args)
14     {
15         keySet();
16         entrySet();
17     }
18     
19     // 方法一:通過keySet()來獲取
20     public static void keySet()
21     {
22         HashMap<String,String> map = new HashMap<String,String>();
23         map.put("01", "zhangsan");
24         map.put("05", "lisi");
25         map.put("03", "wangwu");
26         
27         Set<String> keySet = map.keySet();
28         
29         Iterator<String> it = keySet.iterator();
30         while(it.hasNext())
31         {
32             String key = it.next();
33             String value = map.get(key);
34             System.out.println("key:" + key + ",value:" + value);
35         }
36     }
37     
38     // 方法二:通過entrySet()來獲取
39     public static void entrySet()
40     {
41         HashMap<String,String> map = new HashMap<String,String>();
42         map.put("01", "zhangsan");
43         map.put("05", "lisi");
44         map.put("03", "wangwu");
45         
46         Set<Map.Entry<String, String>> entrySet = map.entrySet();
47         Iterator<Map.Entry<String, String>> it = entrySet.iterator();
48         while(it.hasNext())
49         {
50             Map.Entry<String, String> me = it.next();
51             String key = me.getKey();
52             String value = me.getValue();
53             System.out.println("key:" + key + ",value:" + value);
54         }
55     }
56 }

 

 1 /**
 2  * 功能:HashMap集合的擴展
 3  */
 4 package collection;
 5 
 6 import java.util.HashMap;
 7 import java.util.Iterator;
 8 import java.util.Set;
 9 
10 public class MapDemo2
11 {
12     public static void main(String[] args)
13     {
14         HashMap<String,String> yure = new HashMap<String,String>();
15         yure.put("01", "zhangsan");
16         yure.put("02", "lisi");
17         
18         HashMap<String,String> jiuye = new HashMap<String,String>();
19         jiuye.put("03", "wangwu");
20         jiuye.put("04", "zhaoliu");
21         
22         HashMap<String,HashMap<String,String>> czbk = new HashMap<String,HashMap<String,String>>();
23         czbk.put("yure", yure);
24         czbk.put("jiuye", jiuye);
25         
26         Set<String> map = czbk.keySet();
27         Iterator<String> it = map.iterator();
28         while(it.hasNext())
29         {
30             String key = it.next();
31             HashMap<String,String> values = czbk.get(key);
32             System.out.println("key:" + key + "values:" + values);
33             getStuInfo(values);
34         }
35         
36         // getStuInfo(jiuye);
37     }
38     
39     public static void getStuInfo(HashMap<String,String> room)
40     {
41         Set<String> map = room.keySet();
42         Iterator<String> it = map.iterator();
43         while(it.hasNext())
44         {
45             String key = it.next();
46             String value = room.get(key);
47             System.out.println("id:" + key + ",value:" + value);
48         }
49     }
50 }

 

 1 /**
 2  * 功能:JDK1.5新特性,可變參數
 3  */
 4 package collection;
 5 
 6 public class CollectionDemo
 7 {
 8     public static void main(String[] args)
 9     {
10         syso(1,2,3,4,5);
11         syso(3,4);
12     }
13     
14     public static void syso(int... arr)
15     {
16         for(int i=0;i<arr.length;i++)
17         {
18             System.out.println(i);
19         }
20     }
21 }

 

 1 /**
 2  * 功能:JDK1.5新特性,靜態導入
 3  */
 4 package collection;
 5 
 6 import java.util.Arrays;
 7 
 8 // 實現靜態導入,導入的是Arrays這個類中的所有靜態成員
 9 import static java.util.Arrays.*;
10 
11 public class CollectionDemo2
12 {
13     public static void main(String[] args)
14     {
15         int[] arr = {6,2,8};
16         // 原來是這樣寫的
17         // int index = Arrays.binarySearch(arr, 2);
18         // 現在可以這樣寫
19         int index = binarySearch(arr, 2);
20         
21         System.out.println(index);
22         
23     }
24 }

 


免責聲明!

本站轉載的文章為個人學習借鑒使用,本站對版權不負任何法律責任。如果侵犯了您的隱私權益,請聯系本站郵箱yoyou2525@163.com刪除。



 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM