7.Java集合

1.對象的存儲：①數組（基本數據類型 & 引用數據類型） ②集合（引用數據類型）

>數組存儲數據的弊端：長度一旦初始化以後，就不可變；真正給數組元素賦值的個數沒有現成的方法可用。

2.集合框架

Collection接口 ：方法：

①add(Object obj),addAll(Collection coll),size(),clear(),isEmpty();

②remove(Object obj),removeAll(Collection coll),retainAll(Collectioncoll),equals(Object obj),contains(Object obj),containsAll(Collection coll),hashCode()

③ iterator(),toArray();

* |------List接口：存儲有序的，可以重複的元素.---相當於“動態”數組

>新增的方法：刪除remove(int index) 修改set(int index,Object obj) 獲取get(int index)插入add(int index,Object obj)

>添加進List集合中的元素（或對象）所在的類一定要重寫equals()方法

* |------ArrayList（主要的實現類）

|------LinkedList（更適用於頻繁的插入、刪除操作）

|------Vector（古老的實現類、線程安全的，但效率要低於ArrayList）

* |------Set接口：存儲無序的，不可重複的元素。---相當於高中的“集合”概念

>Set使用的方法基本上都是Collection接口下定義的。

>添加進Set集合中的元素所在的類一定要重寫equals() 和 hashCode()。要求重寫equals() 和 hashCode()方法保持一致。

>1.無序性：無序性！= 隨機性。真正的無序性，指的是元素在底層存儲的位置是無序的。

>2.不可重複性：當向Set中添加進相同的元素的時候，後面的這個不能添加進去。

* |------HashSet（主要的實現類）

|------LinkedHashSet(是HashSet的子類，當我們遍歷集合元素時，是按照添加進去的順序實現的；頻繁的遍歷，較少的添加、插入操作建議選擇此)

|------TreeSet（可以按照添加進集合中的元素的指定屬性進行排序）

>要求TreeSet添加進的元素必須是同一個類的！

>兩種排序方式：自然排序：①要求添加進TreeSet中的元素所在的類implements Comparable接口

②重寫compareTo(Object obj)，在此方法內指明按照元素的哪個屬性進行排序

③向TreeSet中添加元素即可。若不實現此接口，會報運行時異常

定製排序：①創建一個實現Comparator接口的實現類的對象。在實現類中重寫Comparator的compare(Object o1,Object o2)方法

②在此compare()方法中指明按照元素所在類的哪個屬性進行排序

③將此實現Comparator接口的實現類的對象作為形參傳遞給TreeSet的構造器中

④向TreeSet中添加元素即可。若不實現此接口，會報運行時異常

>要求重寫的compareTo()或者compare()方法與equals()和hashCode()方法保持一致。

Map接口：存儲“鍵-值”對的數據 ----相當於高中的“函數y = f(x)” (x1,y1) (x2,y2)

>key是不可重複的，使用Set存放。value可以重複的，使用Collection來存放的。一個key-value對構成一個entry(Map.Entry)，entry使用Set來存放。

>添加、修改 put(Object key,Object value) 刪除remove(Object key) 獲取get(Object key) size() / keySet() values() entrySet()

* |-----HashMap：主要的實現類，可以添加null鍵，null值

|-----LinkedHashMap：是HashMap的子類，可以按照添加進Map的順序實現遍歷

|-----TreeMap：需要按照key所在類的指定屬性進行排序。要求key是同一個類的對象。對key考慮使用自然排序 或 定製排序

|-----Hashtable：是一個古老的實現類，線程安全的，不可以添加null鍵，null值不建議使用。

|-----子類：Properties：常用來處理屬性文件

Iterator接口：用來遍歷集合Collection元素

Collections工具類：操作Collection及Map的工具類，大部分為static的方法。

附：Properties的使用

Properties pros = new Properties();

pros.load(new FileInputStream(new File("jdbc.properties")));

String user = pros.getProperty("user");

System.out.println(user);

String password = pros.getProperty("password");

System.out.println(password);

代碼塊：

/*
 * 1.存儲對象可以考慮：①數組 ②集合
 * 2.數組存儲對象的特點：Student[] stu = new Student[20]; stu[0] = new Student();....
 * >弊端：①一旦創建，其長度不可變。②真實的數組存放的對象的個數是不可知。
 * 3.集合
 * Collection接口
 * 		|------List接口：存儲有序的，可以重複的元素
 * 				|------ArrayList（主要的實現類）、LinkedList（對於頻繁的插入、刪除操作）、Vector（古老的實現類、線程安全的） 

 * 		|------Set接口：存儲無序的，不可重複的元素
 * 				|------HashSet、LinkedHashSet、TreeSet
 * Map接口：存儲“鍵-值”對的數據
 * 		|-----HashMap、LinkedHashMap、TreeMap、Hashtable(子類：Properties)
 */
public class TestCollection {
	@Test
	public void testCollection3() {
		Collection coll = new ArrayList();
		coll.add(123);
		coll.add(new String("AA"));
		coll.add(new Date());
		coll.add("BB");
		coll.add(new Person("MM", 23));
		
		Collection coll1 = new ArrayList();
		coll1.add(123);
		coll1.add(new String("AA"));
		// 10.removeAll(Collection coll):從當前集合中刪除包含在coll中的元素。
		coll.removeAll(coll1);
		System.out.println(coll);
		//11.equals(Object obj):判斷集合中的所有元素是否完全相同
		Collection coll2 = new ArrayList();
		coll2.add(123);
		coll2.add(new String("AA1"));
		System.out.println(coll1.equals(coll2));
		//12.hashCode():
		System.out.println(coll.hashCode());
		System.out.println();
		//13.toArray() :將集合轉化為數組
		Object[] obj = coll.toArray();
		for(int i = 0;i < obj.length;i++){
			System.out.println(obj[i]);
		}
		System.out.println();
		//14.iterator():返回一個Iterator接口實現類的對象,進而實現集合的遍歷！
		Iterator iterator = coll.iterator();
		//方式一：不用
		/*System.out.println(iterator.next());
		System.out.println(iterator.next()); 

		System.out.println(iterator.next());*/
		//方式二：不用
//		for(int i = 0;i < coll.size();i++){
//			System.out.println(iterator.next());
//		}
		//方式三：使用
		while(iterator.hasNext()){
			System.out.println(iterator.next());
		}
	}
	@Test
	public void testCollection2() {
		Collection coll = new ArrayList();
		coll.add(123);
		coll.add(new String("AA"));
		coll.add(new Date());
		coll.add("BB");
		// Person p = new Person("MM",23);
		coll.add(new Person("MM", 23));
		System.out.println(coll);
		// 6.contains(Object obj):判斷集合中是否包含指定的obj元素。如果包含，返回true，反之返回false
		// 判斷的依據：根據元素所在的類的equals()方法進行判斷
		// 明確：如果存入集合中的元素是自定義類的對象。要求：自定義類要重寫equals()方法！
		boolean b1 = coll.contains(123);
		b1 = coll.contains(new String("AA"));
		System.out.println(b1);
		boolean b2 = coll.contains(new Person("MM", 23));
		System.out.println(b2);
		// 7.containsAll(Collection coll):判斷當前集合中是否包含coll中所有的元素
		Collection coll1 = new ArrayList();
		coll1.add(123);
		coll1.add(new String("AA"));
		boolean b3 = coll.containsAll(coll1);
		System.out.println("#" + b3);
		coll1.add(456);
		// 8.retainAll(Collection coll):求當前集合與coll的共有的元素，返回給當前集合
		coll.retainAll(coll1); 

		System.out.println(coll);
		// 9.remove(Object obj):刪除集合中的obj元素。若刪除成功，返回true。否則，返回false
		boolean b4 = coll.remove("BB");
		System.out.println(b4);
	}
	@Test
	public void testCollection1() {
		Collection coll = new ArrayList();
		// 1.size():返回集合中元素的個數
		System.out.println(coll.size());
		// 2.add(Object obj):向集合中添加一個元素
		coll.add(123);
		coll.add("AA");
		coll.add(new Date());
		coll.add("BB");
		System.out.println(coll.size());
		// 3.addAll(Collection coll):將形參coll中包含的所有元素添加到當前集合中
		Collection coll1 = Arrays.asList(1, 2, 3);
		coll.addAll(coll1);
		System.out.println(coll.size());
		// 查看集合元素
		System.out.println(coll);
		// 4.isEmpty():判斷集合是否為空
		System.out.println(coll.isEmpty());
		// 5.clear():清空集合元素
		coll.clear();
		System.out.println(coll.isEmpty());
	}
}

public class TestList {
	
	//ArrayList：List的主要實現類
	/*
	 * List中相對於Collection，新增加的方法
	 * void add(int index, Object ele):在指定的索引位置index添加元素ele
		boolean addAll(int index, Collection eles) 

		Object get(int index):獲取指定索引的元素
		Object remove(int index):刪除指定索引位置的元素
		Object set(int index, Object ele):設置指定索引位置的元素為ele
		int indexOf(Object obj):返回obj在集合中首次出現的位置。沒有的話，返回-1
		int lastIndexOf(Object obj)：返回obj在集合中最後一次出現的位置.沒有的話，返回-1
		List subList(int fromIndex, int toIndex):返回從fromIndex到toIndex結束的左閉右開一個子list
		
		List常用的方法：增(add(Object obj)) 刪(remove) 改(set(int index,Object obj))
					查(get(int index)) 插(add(int index, Object ele)) 長度(size())
	 */
	@Test
	public void testList2(){
		List list = new ArrayList();
		list.add(123);
		list.add(456);
		list.add(new String("AA"));
		list.add(new String("GG"));
		list.add(456);
		System.out.println(list.indexOf(456));
		System.out.println(list.lastIndexOf(456));
		System.out.println(list.indexOf(123) == list.lastIndexOf(123));
		System.out.println(list.indexOf(444));
		
		List list1 = list.subList(0, 3);
		System.out.println(list1);
	}
	
	@Test
	public void testList1(){
		List list = new ArrayList();
		list.add(123);
		list.add(456);
		list.add(new String("AA"));
		list.add(new String("GG"));
		System.out.println(list);
		list.add(0,555);
		System.out.println(list);
		Object obj = list.get(1);
		System.out.println(obj);
		list.remove(0); 

		System.out.println(list.get(0));
		list.set(0, 111);
		System.out.println(list.get(0));
	}
}

public class TestIterator {
	//面試題：
	@Test
	public void testFor3(){
		String[] str = new String[]{"AA","BB","DD"};
		for(String s : str){
			s = "MM";//此處的s是新定義的局部變量，其值的修改不會對str本身造成影響。
			System.out.println(s);
		}		
		
		for(int i = 0;i < str.length;i++){
			System.out.println(str[i]);
		}
	}
	@Test
	public void testFor2(){
		String[] str = new String[]{"AA","BB","DD"};
		for(int i = 0;i < str.length;i++){
			str[i] = i + "";
		}
		
		for(int i = 0;i < str.length;i++){
			System.out.println(str[i]);
		}
	}
	
	//***********************************************
	//使用增強for循環實現數組的遍歷
	@Test
	public void testFor1(){
		String[] str = new String[]{"AA","BB","DD"};
		for(String s:str){
			System.out.println(s);
		}
	}
	
	//使用增強for循環實現集合的遍歷 

	@Test
	public void testFor(){
		Collection coll = new ArrayList();
		coll.add(123);
		coll.add(new String("AA"));
		coll.add(new Date());
		coll.add("BB");
		coll.add(new Person("MM", 23));
		
		for(Object i:coll){
			System.out.println(i);
		}
	}
	
	//錯誤的寫法
	@Test
	public void test2(){
		Collection coll = new ArrayList();
		coll.add(123);
		coll.add(new String("AA"));
		coll.add(new Date());
		coll.add("BB");
		coll.add(new Person("MM", 23));
		
		Iterator i = coll.iterator();
		
		while((i.next())!= null){
			//java.util.NoSuchElementException
			System.out.println(i.next());
		}
	}
	//正確的寫法：使用迭代器Iterator實現集合的遍歷
	@Test
	public void test1(){
		Collection coll = new ArrayList();
		coll.add(123);
		coll.add(new String("AA"));
		coll.add(new Date());
		coll.add("BB");
		coll.add(new Person("MM", 23));
		
		Iterator i = coll.iterator();
		while(i.hasNext()){
			System.out.println(i.next());
		}
	}
}
 

/*
 * Collection接口
 * 
 * Map接口
 * 		|-----HashMap:Map的主要實現類
 * 		|-----LinkedHashMap:使用鏈表維護添加進Map中的順序。故遍歷Map時，是按添加的順序遍歷的。
 * 		|-----TreeMap:按照添加進Map中的元素的key的指定屬性進行排序。要求：key必須是同一個類的對象！
 * 				針對key：自然排序 vs 定製排序
 * 		|-----Hashtable:古老的實現類，線程安全，不建議使用。
 * 			|----Properties:常用來處理屬性文件。鍵和值都為String類型的
 */
public class TestMap {
	//使用Properties處理屬性文件
	@Test
	public void test6() throws FileNotFoundException, IOException{
		Properties pros = new Properties();
		pros.load(new FileInputStream(new File("jdbc.properties")));
		String user = pros.getProperty("user");
		System.out.println(user);
		String password = pros.getProperty("password");
		System.out.println(password);
	}
	
	// 定製排序
	@Test
	public void test5() {
		Comparator com = new Comparator() {
			public int compare(Object o1, Object o2) {
				if (o1 instanceof Customer && o2 instanceof Customer) {
					Customer c1 = (Customer) o1;
					Customer c2 = (Customer) o2;
					int i = c1.getId().compareTo(c2.getId());
					if (i == 0) {
						return c1.getName().compareTo(c2.getName());
					} 

					return i;
				}
				return 0;
			}
		};
		TreeMap map = new TreeMap(com);
		map.put(new Customer("AA", 1001), 87);
		map.put(new Customer("CC", 1001), 67);
		map.put(new Customer("MM", 1004), 77);
		map.put(new Customer("GG", 1002), 97);
		
		Set set1 = map.keySet();
		for (Object obj : set1) {
			System.out.println(obj + "----->" + map.get(obj));
		}
	}
	// 自然排序
	@Test
	public void test4() {
		Map map = new TreeMap();
		map.put(new Person("AA", 23), 89);
		map.put(new Person("MM", 22), 79);
		map.put(new Person("GG", 23), 99);
		map.put(new Person("JJ", 13), 69);
		Set set1 = map.keySet();
		for (Object obj : set1) {
			System.out.println(obj + "----->" + map.get(obj));
		}
	}
	@Test
	public void test3() {
		Map map = new LinkedHashMap();
		map.put("AA", 213);
		map.put("BB", 45);
		map.put(123, "CC");
		map.put(null, null);
		map.put(new Person("DD", 23), 89);
		Set set1 = map.keySet();
		for (Object obj : set1) {
			System.out.println(obj + "----->" + map.get(obj));
		}
	}
	/*
	 * 如何遍歷Map Set keySet() Collection values() Set entrySet()
	 */
	@Test
	public void test2() {
		Map map = new HashMap();
		map.put("AA", 213);
		map.put("BB", 45); 

		map.put(123, "CC");
		map.put(null, null);
		map.put(new Person("DD", 23), 89);
		// 1.遍歷key集。
		Set set = map.keySet();
		for (Object obj : set) {
			System.out.println(obj);
		}
		// 2.遍歷value集
		Collection values = map.values();
		Iterator i = values.iterator();
		while (i.hasNext()) {
			System.out.println(i.next());
		}
		// 3.如何遍歷key-value對。
		// 方式一：
		Set set1 = map.keySet();
		for (Object obj : set1) {
			System.out.println(obj + "----->" + map.get(obj));
		}
		// 方式二：
		Set set2 = map.entrySet();
		for (Object obj : set2) {
			Map.Entry entry = (Map.Entry) obj;
			// System.out.println(entry.getKey() + "---->" + entry.getValue());
			System.out.println(entry);
		}
	}
	/*
	 * Object put(Object key,Object value):向Map中添加一個元素 Object remove(Object
	 * key):按照指定的key刪除此key-value void putAll(Map t) void clear():清空 Object
	 * get(Object key)：獲取指定key的value值。若無此key，則返回null boolean containsKey(Object
	 * key) boolean containsValue(Object value) int size():返回集合的長度 boolean
	 * isEmpty() boolean equals(Object obj)
	 * 
	 * HashMap： 1.key是用Set來存放的，不可重複。value是用Collection來存放的，可重複
	 * 一個key-value對，是一個Entry。所有的Entry是用Set存放的，也是不可重複的。
	 * 2.向HashMap中添加元素時，會調用key所在類的equals()方法，判斷兩個key是否相同。若相同 則只能添加進後添加的那個元素。 

	 */
	
	
	@Test
	public void test1() {
		Map map = new HashMap();
		map.put("AA", 213);
		map.put("BB", 456);
		map.put("BB", 45);
		map.put(123, "CC");
		map.put(null, null);
		map.put(new Person("DD", 23), 89);
		map.put(new Person("DD", 23), 87);
		System.out.println(map.size());
		System.out.println(map);
		map.remove("BB");
		System.out.println(map);
		Object value = map.get(1234);
		System.out.println(value);
	}
}

/*
 * Collection接口 ：
 * 		|------List接口：
 * 			|------ArrayList（主要的實現類）、
 * 			|------LinkedList（對於頻繁的插入、刪除操作）、
 * 			|------Vector（古老的實現類、線程安全的，但效率要低於ArrayList）
 * 		|------Set接口：存儲無序的，不可重複的元素.Set中常用的方法都是Collection下定義的。
 * 				|------HashSet(主要實現類)
 |------LinkedHashSet
 |------TreeSet
 */
public class TestSet {
	@Test
	public void testTreeSet3() {
		TreeSet set = new TreeSet(new Comparator() {
			public int compare(Object o1, Object o2) {
				if (o1 instanceof Customer && o2 instanceof Customer) {
					Customer c1 = (Customer) o1; 

					Customer c2 = (Customer) o2;
					int i = c1.getId().compareTo(c2.getId());
					if (i == 0) {
						return c1.getName().compareTo(c2.getName());
					}
					return i;
				}
				return 0;
			}
		});
		set.add(new Customer("AA", 1003));
		set.add(new Customer("BB", 1002));
		set.add(new Customer("GG", 1004));
		set.add(new Customer("CC", 1001));
		set.add(new Customer("DD", 1001));
		for (Object str : set) {
			System.out.println(str);
		}
	}
	/*
	 * TreeSet的定製排序： 見下面的步驟 compare()與hashCode()以及equals()三者保持一致！
	 */
	@Test
	public void testTreeSet2() {
		// 1.創建一個實現了Comparator接口的類對象
		Comparator com = new Comparator() {
			// 向TreeSet中添加Customer類的對象，在此compare()方法中，指明是按照Customer
			// 的哪個屬性排序的。
			@Override
			public int compare(Object o1, Object o2) {
				if (o1 instanceof Customer && o2 instanceof Customer) {
					Customer c1 = (Customer) o1;
					Customer c2 = (Customer) o2;
					int i = c1.getId().compareTo(c2.getId());
					if (i == 0) {
						return c1.getName().compareTo(c2.getName());
					}
					return i;
				}
				return 0;
			}
		};
		// 2.將此對象作為形參傳遞給TreeSet的構造器中 

		TreeSet set = new TreeSet(com);
		// 3.向TreeSet中添加Comparator接口中的compare方法中涉及的類的對象。
		set.add(new Customer("AA", 1003));
		set.add(new Customer("BB", 1002));
		set.add(new Customer("GG", 1004));
		set.add(new Customer("CC", 1001));
		set.add(new Customer("DD", 1001));
		for (Object str : set) {
			System.out.println(str);
		}
	}
	/*
	 * TreeSet: 1.向TreeSet中添加的元素必須是同一個類的。
	 * 2.可以按照添加進集合中的元素的指定的順序遍歷。像String，包裝類等默認按照從小到大的順序遍歷。
	 * 3.當向TreeSet中添加自定義類的對象時，有兩種排序方法：①自然排序②定製排序
	 * 4.自然排序：要求自定義類實現java.lang.Comparable接口並重寫其compareTo(Object obj)的抽象方法
	 * 在此方法中，指明按照自定義類的哪個屬性進行排序。
	 * 
	 * 5.向TreeSet中添加元素時，首先按照compareTo()進行比較，一旦返回0，雖然僅是兩個對象的此
	 * 屬性值相同，但是程序會認為這兩個對象是相同的，進而後一個對象就不能添加進來。
	 * 
	 * >compareTo()與hashCode()以及equals()三者保持一致！
	 */
	@Test
	public void testTreeSet1() {
		Set set = new TreeSet();
		// set.add(new String("AA")); 

		// set.add(new String("AA"));
		// set.add("JJ");
		// set.add("GG");
		// set.add("MM");
		// 當Person類沒有實現Comparable接口時，當向TreeSet中添加Person對象時，報ClassCastException
		set.add(new Person("CC", 23));
		set.add(new Person("MM", 21));
		set.add(new Person("GG", 25));
		set.add(new Person("JJ", 24));
		set.add(new Person("KK", 20));
		set.add(new Person("DD", 20));
		// set.add("AA");
		for (Object str : set) {
			System.out.println(str);
		}
	}
	/*
	 * LinkedHashSet:使用鏈表維護了一個添加進集合中的順序。導致當我們遍歷LinkedHashSet集合
	 * 元素時，是按照添加進去的順序遍歷的！
	 * 
	 * LinkedHashSet插入性能略低於 HashSet，但在迭代訪問 Set 裡的全部元素時有很好的性能。
	 */
	@Test
	public void testLinkedHashSet() {
		Set set = new LinkedHashSet();
		set.add(123);
		set.add(456);
		set.add(new String("AA"));
		set.add(new String("AA"));
		set.add("BB");
		set.add(null);
		Iterator iterator = set.iterator();
		while (iterator.hasNext()) {
			System.out.println(iterator.next());
		}
	}
	/*
	 * Set:存儲的元素是無序的，不可重複的！
	 * 1.無序性：無序性！= 隨機性。真正的無序性，指的是元素在底層存儲的位置是無序的。 

	 * 2.不可重複性：當向Set中添加進相同的元素的時候，後面的這個不能添加進去。
	 * 
	 * 說明：要求添加進Set中的元素所在的類，一定要重寫equals()和hashCode()方法。 進而保證Set中元素的不可重複性！
	 * 
	 * Set中的元素時如何存儲的呢？使用了哈希算法。
	 * 當向Set中添加對象時，首先調用此對象所在類的hashCode()方法，計算此對象的哈希值，此哈希值
	 * 決定了此對象在Set中的存儲位置。若此位置之前沒有對象存儲，則這個對象直接存儲到此位置。若此位置
	 * 已有對象存儲，再通過equals()比較這兩個對象是否相同。如果相同，後一個對象就不能再添加進來。 萬一返回false呢，都存儲。（不建議如此）
	 * >要求：hashCode()方法要與equals()方法一致。
	 */
	@Test
	public void testHashSet() {
		Set set = new HashSet();
		set.add(123);
		set.add(456);
		set.add(new String("AA"));
		set.add(new String("AA"));
		set.add("BB");
		set.add(null);
		Person p1 = new Person("GG", 23);
		Person p2 = new Person("GG", 23);
		System.out.println(p1.equals(p2));
		System.out.println(p1.hashCode());
		System.out.println(p2.hashCode());
		set.add(p1);
		set.add(p2); 

		System.out.println(set.size());
		System.out.println(set);
	}
}

閱讀更多 異現場調查科 的文章

關鍵字: obj 接口 System