集合 ArrayList 集合的繼承實現關係 Collection Iterator迭代器 增強for循環 泛型 集合的向下轉型

1.集合介紹

    集合，集合是java中提供的一種容器，可以用來存儲多個數據。    

    我們知道數據多了，可以使用數組存放或者使用ArrayList集合進行存放數據。那麼，集合和數組既然都是容器，它們有啥區別呢？

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

 集合中存儲的元素必須是引用類型數據

2. ArrayList集合存儲元素

public static void main(String[] args) {
     ArrayList<Integer> list = new ArrayList<Integer>();
	list.add(111);
	list.add(222);
	list.add(333);
	list.add(444);
	list.add(555);
	for(int i=0; i<list.size(); i++){
         System.out.println(list.get(i));
}
}
練習二：ArrayList集合存儲5個Person類型元素
public static void main(String[] args) {
     ArrayList<Person> list = new ArrayList<Person>();
	list.add(new Person(“小強”));
	list.add(new Person(“老王”));
	list.add(new Person(“小虎”));
	list.add(new Person(“小澤”));
	list.add(new Person(“小紅”));
	for(int i=0; i<list.size(); i++){
		Person p = list.get(i);
         System.out.println(p);
}

3. 集合的繼承實現關係

     

查看ArrayList類發現它繼承了抽象類AbstractList同時實現接口List，而List接口又繼承了Collection接口。Collection接口爲最頂層集合接口了。

源代碼：
interface List extends Collection {
}
public class ArrayList extends AbstractList implements List{
}

這說明我們在使用ArrayList類時，該類已經把所有抽象方法進行了重寫。那麼，實現Collection接口的所有子類都會進行方法重寫。

l Collecton接口常用的子接口有：List接口、Set接口

l List接口常用的子類有：ArrayList類、LinkedList類

l Set接口常用的子類有：HashSet類、LinkedHashSet類

4.Collection接口概述

既然Collection接口是集合中的頂層接口，那麼它中定義的所有功能子類都可以使用。查閱API中描述的Collection接口。Collection 層次結構中的根接口。Collection 表示一組對象，這些對象也稱爲 collection 的元素。一些 collection 允許有重複的元素，而另一些則不允許。一些 collection 是有序的，而另一些則是無序的。

繼續查閱API，發現Collection接口中很多集合的操作方法，那麼這些方法都具體能做什麼呢？

     Collection接口的基本方法

   

這裏我們不關心具體創建的Collection中的那個子類對象，這裏重點演示的是Collection接口中的方法。

創建集合的格式：

方式1：Collection<元素類型> 變量名 = new ArrayList<元素類型>();

方式2：Collection 變量名 = new ArrayList();

l 方式1創建的集合，只能存儲<>中指定的元素類型，該方式爲常用方式

l 方式2創建的集合，集合的元素類型默認爲Object類型，即任何類型的元素都可以存儲。

 

演示Collection接口中的方法

//創建集合
Collection coll = new ArrayList();

//1,往集合中添加對象元素。add(E e)方法，E代表創建集合時所指定的數據類型如<String>，那麼，E就代表String類型；創建集合時若沒有指定數據類型，那麼，E就代表Object類型。
coll.add("t1");
coll.add("t2");
coll.add("t3");		
//把集合打印一下。
System.out.println(coll); //打印結果爲：[t1, t2, t3]
System.out.println(coll.toString()); //打印結果爲：[t1, t2, t3]

//2,從集合中刪除元素。remove(Object o)方法
coll.remove("t2");		
//刪除後，集合元素爲[t1, t3]

//3,判斷集合中是否包含指定元素。contains(Object o)方法
System.out.println(coll.contains("t1"));
//打印結果爲true
System.out.println(coll.contains("t2"));
//打印結果爲false
	
//4,獲取集合元素個數。size()方法
System.out.println(coll.size());
//打印結果爲2

//5,返回包含集合中所有元素的數組。toArray()方法
String[] array = coll.toArray();
//數組中的元素爲{"t1", "t3"}

//6,清除集合元素。remove()方法
coll.clear();
//清空後，集合元素爲[]，代表沒有元素

Iterator迭代器

java中提供了很多個集合，它們在存儲元素時，採用的存儲方式不同。我們要取出這些集合中的元素，可通過一種通用的獲取方式來完成。

Collection集合元素的通用獲取方式：在取元素之前先要判斷集合中有沒有元素，如果有，就把這個元素取出來，繼續在判斷，如果還有就再取出出來。一直把集合中的所有元素全部取出。這種取出方式專業術語稱爲迭代。

集合中把這種取元素的方式描述在Iterator接口中。Iterator接口的常用方法如下：

hasNext（）方法：用來判斷集合中是否有下一個元素可以迭代。如果返回true,說明可以迭代。

 next（）方法：用來返回迭代的下一個元素，並把指針向後移動一位。

迭代集合元素圖解：

Iterator迭代方式的代碼體現

在Collection接口描述了一個抽象方法iterator方法，所有Collection子類都實現了這個方法，並且有自己的迭代形式。

進行代碼演示：
//1，創建集合對象。
Collection<String> coll = new ArrayList<String>();
coll.add("abc1");
coll.add("abc2");
coll.add("abc3");
coll.add("abc4");

//2.獲取容器的迭代器對象。通過iterator方法。
Iterator it = coll.iterator();

//3,使用具體的迭代器對象獲取集合中的元素。參閱迭代器的方法
while(it.hasNext()){
	System.out.println(it.next());
}

/* 
迭代器for循環的形式的使用
for (Iterator it = coll.iterator(); it.hasNext();  ) {
	System.out.println(it.next());
}
*/
注意：在進行集合元素取出時，如果集合中已經沒有元素了，還繼續使用迭代器的next方法，將會發生java.util.NoSuchElementException沒有集合元素的錯誤。

集合元素的向下轉型

學習到這裏，基本知道了Collection接口的簡單使用。可是集合中可以存儲任何對象，那麼存放進去的數據都是還是原來類型嗎？不是了，提升成了Object。

在使用集合時，我們需要注意以下幾點：

l 集合中存儲其實都是對象的地址。

l 集合中可以存儲基本數值嗎？jdk1.5版本以後可以存儲了。因爲出現了基本類型包裝類，它提供了自動裝箱操作（基本類型à對象），這樣，集合中的元素就是基本數值的包裝類對象。

l 存儲時提升了Object。取出時要使用元素的特有內容，必須向下轉型。

Collection coll = new ArrayList();
coll.add("abc");
coll.add("aabbcc");
coll.add("ffffff");
Iterator it = coll.iterator();
while (it.hasNext()) {
	//由於元素被存放進集合後全部被提升爲Object類型
//當需要使用子類對象特有方法時，需要向下轉型
	String str = (String) it.next();
	System.out.println(str.length());
}

注意：如果集合中存放的是多個對象，這時進行向下轉型會發生類型轉換異常。

提示：Iterator接口也可以使用<>來控制迭代元素的類型的。代碼演示如下：
Collection<String> coll = new ArrayList<String>();
coll.add("abc");
coll.add("aabbcc");
coll.add("fffff");
Iterator<String> it = coll.iterator();
while (it.hasNext()) {
	String str =  it.next(); 
//當使用Iterator<String>控制元素類型後，就不需要強轉了。獲取到的元素直接就是String類型
	System.out.println(str.length());
}

增強for循環

增強for循環是JDK1.5以後出來的一個高級for循環，專門用來遍歷數組和集合的。它的內部原理其實是個Iterator迭代器，所以在遍歷的過程中，不能對集合中的元素進行增刪操作。

格式：

for(元素的數據類型  變量 : Collection集合or數組){
}
它用於遍歷Collection和數組。通常只進行遍歷元素，不要在遍歷的過程中對集合元素進行增刪操作。
練習一：遍歷數組
int[] arr = new int[]{11,22,33};
for (int n : arr) {//變量n代表被遍歷到的數組元素
	System.out.println(n);
}

練習二:遍歷集合
Collection<String> coll = new ArrayList<String>();
coll.add("t1");
coll.add("t2");
coll.add("t3");
coll.add("t4");
for(String str : coll){//變量Str代表被遍歷到的集合元素
System.out.println(str);

增強for循環和老式的for循環有什麼區別？

注意：新for循環必須有被遍歷的目標。目標只能是Collection或者是數組。

建議：遍歷數組時，如果僅爲遍歷，可以使用增強for如果要對數組的元素進行 操作，使用老式for循環可以通過角標操作。

泛型的引入

 

我們都知道集合中是可以存放任意對象的，只要把對象存儲集合後，那麼這時他們都會被提升成Object類型。當我們在取出每一個對象，並且進行相應的操作，這時必須採用類型轉換。比如下面程序：

public class GenericDemo {
	public static void main(String[] args) {
		List list = new ArrayList();
		list.add("abc");
		list.add("sdf");
		list.add(5);//由於集合沒有做任何限定，任何類型都可以給其中存放
		Iterator it = list.iterator();
		while(it.hasNext()){
			//需要打印每個字符串的長度,就要把迭代出來的對象轉成String類型
			String str = (String) it.next();
			System.out.println(str.length());
		}
	}
}

程序在運行時發生了問題java.lang.ClassCastException

爲什麼會發生類型轉換異常呢？我們來分析下：

由於集合中什麼類型的元素都可以存儲。導致取出時，如果出現強轉就會引發運行時 ClassCastException。怎麼來解決這個問題呢？使用集合時，必須明確集合中元素的類型。這種方式稱爲：泛型。

泛型的定義與使用

我們在集合中會大量使用到泛型，這裏來完整地學習泛型知識。

泛型，用來靈活地將數據類型應用到不同的類、方法、接口當中。將數據類型作爲參數進行傳遞。

4.2.1含有泛型的類
	定義格式：修飾符 class 類名<代表泛型的變量> {  }
例如，API中的ArrayList集合：
class ArrayList<E>{ 
     public boolean add(E e){ }
	public E get(int index){  }
}

	使用格式：創建對象時，確定泛型的類型
例如，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){  }
}

4.2.2含有泛型的方法
定義格式：修飾符 <代表泛型的變量> 返回值類型 方法名(參數){  }
例如，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){  } 

4.2.3含有泛型的接口
	定義格式：修飾符 interface接口名<代表泛型的變量> {  }
例如，API中的Iterator迭代器接口
public interface Iterator<E> {
	public abstract E next();
}
	
使用格式：
1、定義類時確定泛型的類型
例如
public final class Scanner implements Iterator<String> {
      public String next(){  }
}
此時，變量E的值就是String類型。

2、始終不確定泛型的類型，直到創建對象時，確定泛型的類型
例如
ArrayList<String> list = new ArrayList<String>();
Iterator<String> it = list.iterator();
此時，變量E的值就是String類型。
public interface Iterator<String> {
	public abstract String next();
}

 使用泛型的好處

 將運行時期的ClassCastException，轉移到了編譯時期變成了編譯失敗。

 避免了類型強轉的麻煩。

 演示下列代碼：

public class GenericDemo {
	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		list.add("abc");
		list.add("sdf");
		//list.add(5);//當集合明確類型後，存放類型不一致就會編譯報錯
		//集合已經明確具體存放的元素類型，那麼在使用迭代器的時候，迭代器也同樣會知道具體遍歷元素類型
		Iterator<String> it = list.iterator();
		while(it.hasNext()){
	String str = it.next();
//當使用Iterator<String>控制元素類型後，就不需要強轉了。獲取到的元素直接就是String類型
			System.out.println(str.length());
		}
	}
}

 泛型通配符

泛型是在限定數據類型，當在集合或者其他地方使用到泛型後，那麼這時一旦明確泛型的數據類型，那麼在使用的時候只能給其傳遞和數據類型匹配的類型，否則就會報錯。

代碼演示：

 定義迭代集合元素的方法

public static void printCollection(Collection<Person> list) {
	Iterator<Person> it = list.iterator();
	while (it.hasNext()) {
		System.out.println(it.next());
	}
}

調用方法
Collection<Student> list = new ArrayList<Student>();
printCollection(list);
上面調用方法語句屬於語法錯誤，因爲泛型限定不一致。方法要的是Collection<Person>類型，傳入的是Collection<Student>，二者類型不匹配。

上述定義的printCollection方法中，由於定義的是打印集合的功能，應該是可以打印任意集合中元素的。但定義方法時，根本無法確定具體集合中的元素類型是什麼。爲了解決這個“無法確定具體集合中的元素類型”問題，java中，爲我們提供了泛型的通配符<?>。
對上面的方法，進行修改後，實現了可迭代任意元素類型集合的方法
public static void printCollection(Collection<?> list) {
	Iterator<?> it = list.iterator();
	while (it.hasNext()) {
		System.out.println(it.next());
	}
}

 總結一下：

當使用泛型類或者接口時，傳遞的數據中，泛型類型不確定，可以通過通配符<?>表示。但是一旦使用泛型的通配符後，只能使用Object類中的共性方法，集合中元素自身方法無法使用。

 Collection:集合的頂層接口，定義了集合中通用的功能方法

常用方法：

l boolean add(Object e) 把給定的對象添加到當前集合中

l void clear() 清空集合中所有的元素

l boolean remove(Object o) 把給定的對象在當前集合中刪除

l boolean contains(Object o) 判斷當前集合中是否包含給定的對象

l boolean isEmpty() 判斷當前集合是否爲空

l Iterator iterator() 迭代器，用來遍歷集合中的元素的

l int size() 返回集合中元素的個數

l Object[] toArray() 把集合中的元素，存儲到數組中

l Iterator: 迭代器

l Object next()返回迭代的下一個元素

l boolean hasNext()如果仍有元素可以迭代，則返回 true。

l 增強for

簡化數組和Collection集合的遍歷

格式：

for(元素數據類型 變量 : 數組或者Collection集合) {

使用變量即可，該變量就是元素

}

好處：簡化遍歷

l 泛型： 用來約束數據的數據類型

l 泛型的格式：

<數據類型>

泛型可以使用在 類，接口，方法上

l 泛型的好處

A:將運行期遇到的問題轉移到了編譯期

B:省去了類型強轉的麻煩

l 泛型高級(通配符):

l  ? extends E  上限限定,傳遞E類對象, E的子類對象

l  ? Super E 下限限定,傳遞E類對象,E的父類對象