本節內容總結來自傳智播客畢向東老師的公開課,感謝畢向東老師 !如有錯誤之處,歡迎大家指教 !
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必須有被遍歷的目標;
方法的可變參數一定要定義在參數列表的最后面;
靜態導入:
當類重名時,需要指定具體的包名;
當方法重名時,需要制定具體的所屬對象或類;
一些實例:
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 }