Java_集合與泛型
Collection
集合，集合是java中提供的一種容器，可以用來存儲多個數據。
在前面的學習中，我們知道數據多了，可以使用數組存放或者使用ArrayList集合進行存放數據。那麽，集合和數組既然都是容器，它們有啥區別呢？
- 數組的長度是固定的。集合的長度是可變的。
- 集合中存儲的元素必須是引用類型數據
集合的繼承關系圖
a:ArrayList的繼承關系:
查看ArrayList類發現它繼承了抽象類AbstractList同時實現接口List，而List接口又繼承了Collection接口。Collection接口為最頂層集合接口了。
源代碼：
interface List extends Collection {
}
public class ArrayList extends AbstractList implements List{
}
b:集合繼承體系
這說明我們在使用ArrayList類時，該類已經把所有抽象方法進行了重寫。那麽，實現Collection接口的所有子類都會進行方法重寫。
- Collecton接口常用的子接口有：List接口、Set接口
- List接口常用的子類有：ArrayList類、LinkedList類
- Set接口常用的子類有：HashSet類、LinkedHashSet類
可以看下圖了解繼承關系
集合Collection的方法
Collection接口中的方法是集合中所有實現類必須擁有的方法,程序演示:ArrayList implements List,List extends Collection
方法的執行,都是實現的重寫
Collection接口方法 Object[] toArray() 集合中的元素,轉成一個數組中的元素, 集合轉成數組
返回是一個存儲對象的數組, 數組存儲的數據類型是Object
/* Collection接口方法 * Object[] toArray() 集合中的元素,轉成一個數組中的元素, 集合轉成數組 * 返回是一個存儲對象的數組, 數組存儲的數據類型是Object */ private static void function_2() { Collection<String> coll = new ArrayList<String>(); coll.add("abc"); coll.add(View Code"dashao"); coll.add("xixi"); coll.add("money"); coll.add("123"); Object[] objs = coll.toArray(); for(int i = 0 ; i < objs.length ; i++){ System.out.println(objs[i]); } }
順便提一下,java中三種長度表現形式
數組.length屬性 返回值 int
字符串.length() 方法 返回值 int
集合.size()方法 返回值int
Collection接口方法 boolean contains(Object o) 判斷對象是否存在於集合中,對象存在返回true,方法參數是Object類型
private static void function_1() { Collection<String> coll = new ArrayList<String>(); coll.add("abc"); coll.add("dashao"); coll.add("xixi"); coll.add("money"); coll.add("123"); boolean b = coll.contains("itcast"); System.out.println(b); }View Code
Collection接口的方法
* void clear() 清空集合中的所有元素
* 集合容器本身依然存在
public static void function(){ //接口多態的方式調用 Collection<String> coll = new ArrayList<String>(); coll.add("abc"); coll.add("bcd"); System.out.println(coll); coll.clear(); System.out.println(coll); } }View Code
Collection接口方法
* boolean remove(Object o)移除集合中指定的元素
private static void function_3(){ Collection<String> coll = new ArrayList<String>(); coll.add("abc"); coll.add("money"); coll.add("dashao"); coll.add("xixi"); coll.add("money"); coll.add("123"); System.out.println(coll); boolean b = coll.remove("money"); System.out.println(b); System.out.println(coll); }View Code
還有其他方法可以通過查詢API了解
叠代器的概述
a:java中提供了很多個集合，它們在存儲元素時，采用的存儲方式不同。
我們要取出這些集合中的元素，可通過一種通用的獲取方式來完成。
b:Collection集合元素的通用獲取方式：在取元素之前先要判斷集合中有沒有元素，
如果有，就把這個元素取出來，繼續在判斷，如果還有就再取出出來。一直把集合中的所有元素全部取出。這種取出方式專業術語稱為叠代。
c:每種集合的底層的數據結構不同,例如ArrayList是數組,LinkedList底層是鏈表,但是無論使用那種集合,我們都會有判斷是否有元素
以及取出裏面的元素的動作,那麽Java為我們提供一個叠代器定義了統一的判斷元素和取元素的方法
實現原理
集合中的叠代器:
* 獲取集合中元素方式:接口 Iterator : 兩個抽象方法
* boolean hasNext() 判斷集合中還有沒有可以被取出的元素,如果有返回true
* next() 取出集合中的下一個元素
Iterator接口,找實現類.Collection接口定義方法 Iterator iterator() .ArrayList 重寫方法 iterator(),返回了Iterator接口的實現類的對象
使用ArrayList集合的對象, Iterator it =array.iterator(),運行結果就是Iterator接口的實現類的對象, it是接口的實現類對象,調用方法 hasNext 和 next 集合元素叠代
代碼實現:
public class IteratorDemo { public static void main(String[] args) { Collection<String> coll = new ArrayList<String>(); coll.add("abc1"); coll.add("abc2"); coll.add("abc3"); coll.add("abc4"); //叠代器,對集合ArrayList中的元素進行取出 //調用集合的方法iterator()獲取出,Iterator接口的實現類的對象 Iterator<String> it = coll.iterator(); //接口實現類對象,調用方法hasNext()判斷集合中是否有元素 //boolean b = it.hasNext(); //System.out.println(b); //接口的實現類對象,調用方法next()取出集合中的元素 //String s = it.next(); //System.out.println(s); //叠代是反復內容,使用循環實現,循環的條件,集合中沒元素, hasNext()返回了false while(it.hasNext()){ String s = it.next(); System.out.println(s); } } }View Code
執行過程
a:叠代器的原理: while(it.hasNext()) { System.out.println(it.next()); } //cursor記錄的索引值不等於集合的長度返回true,否則返回false public boolean hasNext() { return cursor != size; //cursor初值為0 } //next()方法作用: //①返回cursor指向的當前元素 //②cursor++ public Object next() { int i = cursor; cursor = i + 1; return elementData[lastRet = i]; } b:for循環叠代寫法: for (Iterator<String> it2 = coll.iterator(); it2.hasNext(); ) { System.out.println(it2.next()); }
集合中叠代的轉型
A:集合叠代中的轉型
- 在使用集合時，我們需要註意以下幾點：
集合中存儲其實都是對象的地址。
集合中可以存儲基本數值嗎？jdk1.5版本以後可以存儲了。
因為出現了基本類型包裝類，它提供了自動裝箱操作（基本類型 對象），這樣，集合中的元素就是基本數值的包裝類對象。
2.存儲時提升了Object。取出時要使用元素的特有內容，必須向下轉型。
Collection coll = new ArrayList();
coll.add("abc");
coll.add("aabbcc");
coll.add("shitcast");
Iterator it = coll.iterator();
while (it.hasNext()) {
//由於元素被存放進集合後全部被提升為Object類型
//當需要使用子類對象特有方法時，需要向下轉型
String str = (String) it.next();
System.out.println(str.length());
}
註意：如果集合中存放的是多個對象，這時進行向下轉型會發生類型轉換異常。
3.Iterator接口也可以使用<>來控制叠代元素的類型的。代碼演示如下：
Collection<String> coll = new ArrayList<String>();
coll.add("abc");
coll.add("aabbcc");
coll.add("shitcast");
Iterator<String> it = coll.iterator();
while (it.hasNext()) {
String str = it.next();
//當使用Iterator<String>控制元素類型後，就不需要強轉了。獲取到的元素直接就是String類型
System.out.println(str.length());
}
練習:
1.增強for循環遍歷數組
/* * JDK1.5新特性,增強for循環 * JDK1.5版本後,出現新的接口 java.lang.Iterable * Collection開是繼承Iterable * Iterable作用,實現增強for循環 * * 格式: * for( 數據類型 變量名 : 數組或者集合 ){ * sop(變量); * } */ public static void function_1(){ //for對於對象數組遍歷的時候,能否調用對象的方法呢 String[] str = {"abc","dashao","cn"}; for(String s : str){ System.out.println(s.length()); } } /* * 實現for循環,遍歷數組 * 好處: 代碼少了,方便對容器遍歷 * 弊端: 沒有索引,不能操作容器裏面的元素 */ public static void function(){ int[] arr = {3,1,9,0}; for(int i : arr){ System.out.println(i+1); } System.out.println(arr[0]); }View Code
2.增強for循環遍歷集合
/* * 增強for循環遍歷集合 * 存儲自定義Person類型 */ public static void function_2(){ ArrayList<Person> array = new ArrayList<Person>(); array.add(new Person("a",20)); array.add(new Person("b",10)); for(Person p : array){ System.out.println(p);// System.out.println(p.toString()); } }View Code
泛型的引入
在前面學習集合時，我們都知道集合中是可以存放任意對象的，
只要把對象存儲集合後，那麽這時他們都會被提升成Object類型。
當我們在取出每一個對象，並且進行相應的操作，這時必須采用類型轉換。比如下面程序：
public class GenericDemo { public static void main(String[] args) { List list = new ArrayList(); list.add("abc"); list.add("dashao"); list.add(5);//由於集合沒有做任何限定，任何類型都可以給其中存放 //相當於:Object obj=new Integer(5); Iterator it = list.iterator(); while(it.hasNext()){ //需要打印每個字符串的長度,就要把叠代出來的對象轉成String類型 String str = (String) it.next();//String str=(String)obj; //編譯時期僅檢查語法錯誤,String是Object的兒子可以向下轉型 //運行時期String str=(String)(new Integer(5)) //String與Integer沒有父子關系所以轉換失敗 //程序在運行時發生了問題java.lang.ClassCastException System.out.println(str.length()); } } }
泛型的定義和使用
針對上述的類型轉換問題,Java 泛型（generics）是 JDK 5 中引入的一個新特性, 泛型提供了編譯時類型安全檢測機制，該機制允許程序員在編譯時檢測到非法的類型。泛型的本質是參數化類型，也就是說所操作的數據類型被指定為一個參數。
* 泛型: 指明了集合中存儲數據的類型 <數據類型>
public class GenericDemo { public static void main(String[] args) { function(); } public static void function(){ Collection<String> coll = new ArrayList<String>(); coll.add("abc"); coll.add("rtyg"); coll.add("43rt5yhju"); // coll.add(1); Iterator<String> it = coll.iterator(); while(it.hasNext()){ String s = it.next(); System.out.println(s.length()); } } }View Code
Java中的偽泛型：
泛型只在編譯時存在,編譯後就被擦除,在編譯之前我們就可以限制集合的類型,起到作用
例如:ArrayList<String> al=new ArrayList<String>();
編譯後:ArrayList al=new ArrayList();
泛型類
a:定義格式：
修飾符 class 類名<代表泛型的變量> { }
例如，API中的ArrayList集合：
class ArrayList<E>{ public boolean add(E e){ } public E get(int index){ } }
b:使用格式：
創建對象時，確定泛型的類型
例如，ArrayList<String> list = new ArrayList<String>();
此時，變量E的值就是String類型
class ArrayList<String>{ public boolean add(String e){ } public String get(int index){ } }
例如，ArrayList<Integer> list = new ArrayList<Integer>();
此時，變量E的值就是Integer類型
class ArrayList<Integer>{ public boolean add(Integer e){ } public Integer get(int index){ } }
泛型的方法
a:定義格式：修飾符 <代表泛型的變量> 返回值類型 方法名(參數){ }
b:泛型方法的使用:
1:例如，API中的ArrayList集合中的方法：
public <T> T[] toArray(T[] a){ }
//該方法，用來把集合元素存儲到指定數據類型的數組中，返回已存儲集合元素的數組
使用格式：調用方法時，確定泛型的類型
例如:
ArrayList<String> list = new ArrayList<String>();
String[] arr = new String[100];
String[] result = list.toArray(arr);
此時，變量T的值就是String類型。變量T，可以與定義集合的泛型不同
public <String> String[] toArray(String[] a){ }
例如:
ArrayList<String> list = new ArrayList<String>();
Integer[] arr = new Integer[100];
Integer [] result = list.toArray(arr);
此時，變量T的值就是Integer類型。變量T，可以與定義集合的泛型不同
public <Integer> Integer[] toArray(Integer[] a){ }
泛型接口
//帶有泛型的接口 public interface List <E>{ abstract boolean add(E e); } // 實現類,先實現接口,不理會泛型 public class ArrayList<E> implements List<E>{ } // 調用者 : new ArrayList<String>() 後期創建集合對象的時候,指定數據類型 // 實現類,實現接口的同時,也指定了數據類型 public class XXX implements List<String>{ } new XXX() public class GenericDemo2 { }View Code
好處:
a:將運行時期的ClassCastException，轉移到了編譯時期變成了編譯失敗。
b:避免了類型強轉的麻煩。
public class GenericDemo { public static void main(String[] args) { List<String> list = new ArrayList<String>(); list.add("abc"); list.add("itcast"); //list.add(5);//當集合明確類型後，存放類型不一致就會編譯報錯 //集合已經明確具體存放的元素類型，那麽在使用叠代器的時候，叠代器也同樣會知道具體遍歷元素類型 Iterator<String> it = list.iterator(); while(it.hasNext()){ String str = it.next(); System.out.println(str.length()); //當使用Iterator<String> //控制元素類型後，就不需要強轉了。獲取到的元素直接就是String類型 } } }View Code
泛型的通配符
類型通配符一般是使用?代替具體的類型參數。例如 List<?> 在邏輯上是List<String>,List<Integer> 等所有List<具體類型實參>的父類。
/* * 泛型的通配符 */ public class GenericDemo { public static void main(String[] args) { ArrayList<String> array = new ArrayList<String>(); HashSet<Integer> set = new HashSet<Integer>(); array.add("123"); array.add("456"); set.add(789); set.add(890); iterator(array); iterator(set); } /* * 定義方法,可以同時叠代2個集合 * 參數: 怎麽實現 , 不能寫ArrayList,也不能寫HashSet * 參數: 或者共同實現的接口 * 泛型的通配,匹配所有的數據類型 ? */ public static void iterator(Collection<?> coll){ Iterator<?> it = coll.iterator(); while(it.hasNext()){ //it.next()獲取的對象,什麽類型 System.out.println(it.next()); } } }View Code
泛型的限定:
通過下面例子了解泛型的限定
/* * 將的酒店員工,廚師,服務員,經理,分別存儲到3個集合中 * 定義方法,可以同時遍歷3集合,遍歷三個集合的同時,可以調用工作方法 */ import java.util.ArrayList; import java.util.Iterator; public class GenericTest { public static void main(String[] args) { //創建3個集合對象 ArrayList<ChuShi> cs = new ArrayList<ChuShi>(); ArrayList<FuWuYuan> fwy = new ArrayList<FuWuYuan>(); ArrayList<JingLi> jl = new ArrayList<JingLi>(); //每個集合存儲自己的元素 cs.add(new ChuShi("張三", "後廚001")); cs.add(new ChuShi("李四", "後廚002")); fwy.add(new FuWuYuan("翠花", "服務部001")); fwy.add(new FuWuYuan("酸菜", "服務部002")); jl.add(new JingLi("小名", "董事會001", 123456789.32)); jl.add(new JingLi("小強", "董事會002", 123456789.33)); // ArrayList<String> arrayString = new ArrayList<String>(); iterator(jl); iterator(fwy); iterator(cs); }View Code
/* * 定義方法,可以同時遍歷3集合,遍歷三個集合的同時,可以調用工作方法 work * ? 通配符,叠代器it.next()方法取出來的是Object類型,怎麽調用work方法 * 強制轉換: it.next()=Object o ==> Employee * 方法參數: 控制,可以傳遞Employee對象,也可以傳遞Employee的子類的對象 * 泛型的限定 本案例,父類固定Employee,但是子類可以無限? * ? extends Employee 限制的是父類, 上限限定, 可以傳遞Employee,傳遞他的子類對象 * ? super Employee 限制的是子類, 下限限定, 可以傳遞Employee,傳遞他的父類對象 */ public static void iterator(ArrayList<? extends Employee> array){ Iterator<? extends Employee> it = array.iterator(); while(it.hasNext()){ //獲取出的next() 數據類型,是什麽Employee Employee e = it.next(); e.work(); } } }View Code
Java_集合與泛型