學習Collection類的時候先看一下API怎麼解釋的：


Collection類：
public interface Collection<E>extends Iterable<E>
Collection層次結構中的根介面。
下面我們要學習的兩個子介面：List<E>  Set<E>
--Collection
-List
-ArrayList
-LinkedList
-Set
-HashSet
-TreeSet


Map類：
public interface Map<k,v>;
將鍵對映到值的物件。一個對映不能包含重複的鍵；每個鍵最多隻能對映到一個值
要學習的實現類：
HashMap   LinkedHashMap   TreeMap

Collection 介面，針對的集合是單層集合
而Map<k,v>介面是以鍵值對出現的。我個人稱為多層集合


第一步：學習Collection類：《父介面》
一：Collection類的概述：
Collection類：


位於：java.util包下，所以在使用的時候結的匯入這個包。
public interface Collection<E>extends Iterable<E>，是根介面。


Collection類表示一組物件，這些物件也稱為Collection的元素。
一些 collection 允許有重複的元素，而另一些則不允許。
一些 collection 是有序的，而另一些則是無序的

注意：哪些集合類可以重複？哪些集合類不能重複？
List集合可以重複------Set集合不能重複
 哪些集合類表示有序？哪些集合類不表示有序了？
List集合有序-------Set集合無序

說明：有序表示誰先儲存，誰先出來
Collection是從1.2版本開始使用的


二、集合和陣列的區別：
1.長度的區別：
A:陣列的長度是固定的
B:集合的長度是可變的
2.儲存的內容不一樣，
A:陣列儲存的是同一種資料型別的元素
B:集合可以儲存不同的型別的元素
3.儲存的資料型別不一樣：
A:陣列可以儲存基本資料型別，也可以儲存引用資料型別
B:集合只能儲存引用資料型別
關鍵程式碼：
Collection c = new ArrayList();
c.add(1);//自動轉換成Integer類，呼叫的valueOf（）方法
c.add(2);
c.add(3);
c.add('a');
c.add("a");//自動轉換成包裝類 呼叫的valueOf（）方法
c.add(false);
System.out.println("c:"+c);


----------------------------
原始碼：
Collection c = new ArrayList();
c.add(Integer.valueOf(1));
c.add(Integer.valueOf(2));
c.add(Integer.valueOf(3));
c.add(Character.valueOf('a'));
c.add("a");
c.add(Boolean.valueOf(false));
System.out.println("c:" + c);
補充：在分析問題的時候：
從具體到抽象
在實現程式碼的時候：
從抽象到具體
在使用的時候：
使用具體
三、Collection介面的成員方法：
1.新增方法：
boolean add(Object obj):新增一個元素;
boolean addAlll(Collection c);新增一個集合元素；誰呼叫就往哪個裡面新增所有
2.刪除功能：
void clear();移除所有的元素
boolean remove(Object o);移除一個元素
boolean removeAll(Collection c）移除一個集合的元素《只要移除了一個元素，都返回true》
3判斷功能：
boolean contains(Object o):判斷集合中是否包含指定的元素
boolean containsAll(Collection c):判斷集合中是否包含指定的集合元素（包含了所有元素才返回true）
boolean isEmpty();是否為空
4.長度：
集合的長度是通過：int size()方法
而陣列是通過length屬性來獲取陣列的長度的
字串中有length方法。
5.把集合轉換成陣列：
Object[] toArray();
6.交集功能：
boolean retainAll(Collection c);兩個集合是否有交集
思考：
思考元素去哪了，返回的boolean又是什麼意思呢?
如果有兩個集合A和B
A對B做交集，最終的結果儲存在A中，
返回值表示的是A是否發生過改變
7.集合框架的節點：Iterator
Collection<String> c = new ArrayList<String>();
c.add("hello");
c.add("world");
c.add("java");
c.add("kevin");
c.add("cidy");

Iterator<String> it = c.iterator();
while(it.hasNext()){//判斷是否存在下一個元素
String s = it.next();
System.out.println(s):
}
案例：用集合儲存5個學生物件，並把學生物件進行遍歷：
/*
 * 學生類：
 */
public class Student {
//姓名
private String name;
//年齡：
private int age;
public Student() {
super();
// TODO Auto-generated constructor stub
}
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
//重寫了toString()方法
@Override
public String toString() {
return name+"-----"+age;
}
}



import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;


/*
 * 用集合儲存5個學生物件，並把學生物件進行遍歷
 */
public class CollectionTest {
public static void main(String[] args) {
Collection<Student> c = new ArrayList<Student>();


Student s1 = new Student("tom", 24);
Student s2 = new Student("kevin", 28);
Student s3 = new Student("cidy", 22);
Student s4 = new Student("Jon", 24);
Student s5 = new Student("Dive", 29);


c.add(s1);
c.add(s2);
c.add(s5);
c.add(s4);
c.add(s3);


Object[] arr = c.toArray();
for (int i = 0; i < arr.length; i++) {
// 如果不重寫toString()方法，列印的是地址值，在Studnet類中重寫toString方法
System.out.println(arr[i]);
}
System.out.println("----------------------");
// 轉換成陣列後可以使用增強for
for (Object o : arr) {
System.out.println(o);


System.out.println("--------------------------");
Iterator<Student> it = c.iterator();
while (it.hasNext()) {
Student s = it.next();
System.out.println(s.getName() + "---" + s.getAge());
//java.util.NoSuchElementException
//不要多次呼叫it.next();彙報上面的錯誤的
//System.out.println(it.next().getName()+"---"+it.next().getAge());

}
}
}
}


思考：迭代器為什麼定義成一個介面，而不是類了？
假如把迭代器定義一個類，那麼都可以建立物件，通過物件呼叫方法
從而來遍歷集合，但是在java中有有多種不同的集合，每一種集合的資料結構不一樣，
儲存資料和遍歷方式應該不一樣，所以把迭代器定義為一個介面。

無論你是哪種集合的遍歷，都應該具備判斷和獲取功能，每種集合遍歷的方式不一樣，
我們把具有相同功能抽取出來，並不提供具體的實現。
那麼正直的實現，應該在子類中，以內部類的方式體現