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的父類物件