集合框架-Collection集合

1:物件陣列(掌握)

(1)陣列既可以儲存基本資料型別，也可以儲存引用型別。它儲存引用型別的時候的陣列就叫物件陣列。

(2)案例：用陣列儲存5個學生物件，並遍歷陣列。

package cn.itcast_01;

/*
 * 我有5個學生，請把這個5個學生的資訊儲存到陣列中，並遍歷陣列，獲取得到每一個學生資訊。
 *		 學生：Student
 *		 成員變數：name,age
 *		 構造方法：無參,帶參
 *		 成員方法：getXxx()/setXxx()
 *		 儲存學生的陣列?自己想想應該是什麼樣子的?
 * 分析：
 * 		A:建立學生類。
 * 		B:建立學生陣列(物件陣列)。
 * 		C:建立5個學生物件，並賦值。
 * 		D:把C步驟的元素，放到陣列中。
 * 		E:遍歷學生陣列。
 */
public class ObjectArrayDemo {
	public static void main(String[] args) {
		// 建立學生陣列(物件陣列)。
		Student[] students = new Student[5];

		// 建立5個學生物件，並賦值。
		Student s1 = new Student("林青霞", 27);
		Student s2 = new Student("風清揚", 30);
		Student s3 = new Student("劉意", 30);
		Student s4 = new Student("趙雅芝", 60);
		Student s5 = new Student("王力巨集", 35);

		// 把C步驟的元素，放到陣列中。
		students[0] = s1;
		students[1] = s2;
		students[2] = s3;
		students[3] = s4;
		students[4] = s5;

		// 遍歷
		for (int x = 0; x < students.length; x++) {
			//System.out.println(students[x]);
			
			Student s = students[x];
			System.out.println(s.getName()+"---"+s.getAge());//比System.out.println(students[x])要靈活
		}
	}
}

2:集合(Collection)(掌握)

(1)集合的由來?

我們學習的是Java -- 物件導向 -- 操作很多物件 -- 儲存 -- 容器(陣列和StringBuffer) -- 陣列

而陣列的長度固定，所以不適合做變化的需求，Java就提供了集合供我們使用。

(2)集合和陣列的區別?

A:長度區別

    陣列固定

    集合可變

B:內容區別

    陣列可以是基本型別，也可以是引用型別

    集合只能是引用型別

C:元素內容

    陣列只能儲存同一種型別

    集合可以儲存不同型別(其實集合一般儲存的也是同一種型別)

(3)集合的繼承體系結構?

    由於需求不同，Java就提供了不同的集合類。這多個集合類的資料結構不同，但是它們都是要提供儲存和遍歷功能的，

    我們把它們的共性不斷的向上提取，最終就形成了集合的繼承體系結構圖。

package cn.itcast_01;

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

/*
* 集合的由來：
* 我們學習的是面嚮物件語言，而面嚮物件語言對事物的描述是通過物件體現的，為了方便對多個物件進行操作，我們就必須把這多個物件進行儲存。
* 而要想儲存多個物件，就不能是一個基本的變數，而應該是一個容器型別的變數，在我們目前所學過的知識裡面，有哪些是容器型別的呢?
* 陣列和StringBuffer。但是呢?StringBuffer的結果是一個字串，不一定滿足我們的要求，所以我們只能選擇陣列，這就是物件陣列。
* 而物件陣列又不能適應變化的需求，因為陣列的長度是固定的，這個時候，為了適應變化的需求，Java就提供了集合類供我們使用。
* 
* 陣列和集合的區別?
* 	A:長度區別
* 		陣列的長度固定
* 		集合長度可變
* 	B:內容不同
* 		陣列儲存的是同一種型別的元素
* 		而集合可以儲存不同型別的元素
* 	C:元素的資料型別問題	
* 		陣列可以儲存基本資料型別，也可以儲存引用資料型別
* 		集合只能儲存引用型別
* 
* 剛說過集合是儲存多個元素的，但是呢，儲存多個元素我們也是有不同需求的：比如說，我要這多個元素中不能有相同的元素，
* 再比如說，我要這多個元素按照某種規則排序一下。針對不同的需求，Java就提供了不同的集合類，這樣呢，Java就提供了很多個集合類。

* 這多個集合類的資料結構不同,結構不同不重要的，重要的是你要能夠儲存東西，並且還要能夠使用這些東西，比如說判斷，獲取等。
* 既然這樣，那麼，這多個集合類是有共性的內容的，我們把這些集合類的共性內容不斷的向上提取，最終就能形成集合的繼承體系結構。
* 
* 資料結構：資料的儲存方式。
* 
* Collection:是集合的頂層介面，它的子體系有重複的，有唯一的，有有序的，有無序的。(後面會慢慢的講解)
* 
* Collection的功能概述：
* 1：新增功能
* 		boolean add(Object obj):新增一個元素
* 		boolean addAll(Collection c):新增一個集合的元素
* 2:刪除功能
* 		void clear():移除所有元素
* 		boolean remove(Object o):移除一個元素
* 		boolean removeAll(Collection c):移除一個集合的元素(是一個還是所有)
* 3:判斷功能
* 		boolean contains(Object o)：判斷集合中是否包含指定的元素
* 		boolean containsAll(Collection c)：判斷集合中是否包含指定的集合元素(是一個還是所有)
* 		boolean isEmpty()：判斷集合是否為空
* 4:獲取功能
* 		Iterator<E> iterator()(重點)
* 5:長度功能
* 		int size():元素的個數
*
面試題：陣列有沒有length()方法呢?字串有沒有length()方法呢?集合有沒有length()方法呢?  

1 java中的length屬性是針對陣列說的,比如說你宣告瞭一個陣列,想知道這個陣列的長度則用到了length這個屬性.

2 java中的length()方法是針對字串String說的,如果想看這個字串的長度則用到length()這個方法.
		
3.java中的size()方法是針對泛型集合說的,如果想看這個泛型有多少個元素,就呼叫此方法來檢視!
		
這個例子來演示這兩個方法和一個屬性的用法

public static void main(String[] args) {
	String []list={"ma","cao","yuan"};
	String a="macaoyuan";
	System.out.println(list.length);
	System.out.println(a.length());


	List<Object> array=new ArrayList();
	array.add(a);
	System.out.println(array.size());
}

輸出的值為:

3

9

1

* 6:交集功能
* 		boolean retainAll(Collection c):兩個集合都有的元素?思考元素去哪了，返回的boolean又是什麼意思呢?
* 7：把集合轉換為陣列
* 		Object[] toArray()
*/

public class CollectionDemo {
	public static void main(String[] args) {
		// 測試不帶All的方法

		// 建立集合物件
		// Collection c = new Collection(); //錯誤，因為介面不能例項化，要找實現類
		Collection c = new ArrayList();

		// boolean add(Object obj):新增一個元素
		c.add("hello");
		c.add("world");
		c.add("java");

		// void clear():移除所有元素
		c.clear();

		// boolean remove(Object o):移除一個元素
		System.out.println("remove:" + c.remove("hello"));
		System.out.println("remove:" + c.remove("javaee"));

		// boolean contains(Object o)：判斷集合中是否包含指定的元素
		System.out.println("contains:"+c.contains("hello"));
		System.out.println("contains:"+c.contains("android"));

		// boolean isEmpty()：判斷集合是否為空，有元素就false，沒有元素就true
		System.out.println("isEmpty:"+c.isEmpty());

		//int size():元素的個數
		System.out.println("size:"+c.size());
		
		System.out.println("c:" + c);
	}
}

package cn.itcast_01;

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

/*
 * boolean addAll(Collection c):新增一個集合的元素
 * boolean removeAll(Collection c):移除一個集合的元素(是一個還是所有)
 * boolean containsAll(Collection c)：判斷集合中是否包含指定的集合元素(是一個還是所有)
 * boolean retainAll(Collection c):兩個集合都有的元素?思考元素去哪了，返回的boolean又是什麼意思呢?
 */
public class CollectionDemo2 {
    public static void main(String[] args) {
        //建立集合1
        Collection c1 = new ArrayList();
        c1.add("abc1");
        c1.add("abc2");
        c1.add("abc3");
        c1.add("abc4");

        //建立集合2
        Collection c2 = new ArrayList();
        c2.add("abc5");
        c2.add("abc6");
        c2.add("abc7");

        //boolean addAll(Collection c):新增一個集合的元素
        System.out.println("addAll:" + c1.addAll(c2));
        
        //boolean removeAll(Collection c):移除一個集合的元素(只要有一個被移除了，它就是移除)
        //只要有一個元素被移除了，就返回true。
        System.out.println("removeAll:"+c1.removeAll(c2));

        //boolean containsAll(Collection c)：判斷集合中是否包含指定的集合元素(只有包含所有的元素，才叫包含)
        //只有包含所有的元素，才叫包含
        System.out.println("containsAll:"+c1.containsAll(c2));

        //boolean retainAll(Collection c):兩個集合都有的元素?思考元素去哪了，返回的boolean又是什麼意思呢?
        //假設有兩個集合A，B。
        //A對B做交集，最終的結果儲存在A中，B不變。
        //返回值表示的是A是否發生過改變。
        //A沒有改變了，返回false;A改變了，返回true
        System.out.println("retainAll:"+c1.retainAll(c2));
        
        System.out.println("c1:" + c1);
        System.out.println("c2:" + c2);
    }
}

package cn.itcast_01;

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

/*
 * 集合的遍歷。其實就是依次獲取集合中的每一個元素。
 * 
 * Object[] toArray():把集合轉成陣列，可以實現集合的遍歷
 */
public class CollectionDemo3 {
	public static void main(String[] args) {
		// 建立集合物件
		Collection c = new ArrayList();

		// 新增元素
		c.add("hello"); // Object obj = "hello"; 向上轉型
		c.add("world");
		c.add("java");

		// 遍歷
		// Object[] toArray():把集合轉成陣列，可以實現集合的遍歷
		Object[] objs = c.toArray();
		for (int x = 0; x < objs.length; x++) {
		
			// System.out.println(objs[x]);
			
			// 改變需求：我知道元素是字串，我在獲取到元素的的同時，還想知道元素的長度。
			// System.out.println(objs[x] + "---" + objs[x].length());
			
			// 上面的實現不了，原因是Object中沒有length()方法
			// 我們要想使用字串的方法，就必須把元素還原成字串
			// 向下轉型
			String s = (String) objs[x];
			System.out.println(s + "---" + s.length());
		}
	}
}