集合知識點

集合與數組一樣，也是一個容器，與數組不同的是，集合的長度不定，可以無限的向集合中添加元素，而且集合中存儲的元素類型可以隨意。

集合的框架結構介紹

 

Map集合的框架結構

 

集合與數組的對比

相同點：

都是數據的容器，在一個數組或集合中可以聲明（存儲）多個數據

不同點：

元素：數組中的元素只能是相同（相兼容類型）
    集合中的元素是任意的（泛型）

數組中可以存儲基本類型和引用類型，集合只能存儲引用類型

長度(元素個數)：
    數組是定長的，一旦初始化長度就不可以修改
    集合長度可以修改，可以刪除元素和添加元素

第二節 Collection接口

2.1 Collection中常用的方法(Collection中定義是整個集合體系最共性的方法:)

測試：
 

package a;

import java.util.*;


public class TestA {
	
	static ArrayList<String> arr=new ArrayList<String>();
	static ArrayList<String> x=new ArrayList<String>();
	static void f1()//add
	{
		arr.add("HELLO");
		arr.add("WORLD");
		System.out.println(arr.toString());
	}
	static void f2()//addAll()
	{
		arr.add("HELLO");
		arr.add("WORLD");
		x.add("I LOVE");
		x.add("MY L.I.F.E");
		arr.addAll(x);
		System.out.println(arr.toString());
	}
	static void f3()//clear()
	{
		arr.add("A");
		arr.add("B");
		System.out.println(arr.toString());
		arr.clear();
		System.out.println(arr.toString());
	}
	static void f4()//contains()
	{
		arr.add("ABC");
		arr.add("DEF");
		System.out.println(arr.contains("ABC"));
	}
	static void f5()//containsAll()
	{
		arr.add("ABC");
		arr.add("DEF");
		arr.add("IGH");
		x.add("ABC");
		x.add("IGH");
		System.out.println(arr.containsAll(x));
		System.out.println(x.containsAll(arr));
	}
	static void f6()//equals()
	{
		arr.add("AB");
		arr.add("CD");
		x.add("AB");
		x.add("CD");
		System.out.println(arr.equals(x));
	}
	static void f7()//isEmpty()
	{
		System.out.println(arr.isEmpty());
		arr.add("AA");
		System.out.println(arr.isEmpty());
	}
	static void f8()//iterator()
	{
		arr.add("ABC");
		arr.add("DEF");
		arr.add("GHI");
		Iterator<String> it=arr.iterator();
		while(it.hasNext())
		{
			System.out.println(it.next());
		}
	}
	static void f9()//remove()
	{
		arr.add("ABC");
		arr.add("ABC");
		arr.add("ABC");
		arr.add("ABC");
		arr.add("DEF");
		arr.add("GHI");
		System.out.println(arr.toString());
		
		arr.remove(0);//通過索引刪除
		System.out.println(arr.toString());
		
		arr.remove("ABC");//通過元素刪除,如果有重複的，每次只刪除一個
		System.out.println(arr.toString());
		
	}
	static void f10()//removeAll
	{
		arr.add("ABC");
		arr.add("ABC");
		arr.add("ABC");
		arr.add("ABC");
		arr.add("DEF");
		arr.add("GHI");

		x.add("ABC");
		x.add("DEF");
		
		System.out.println(arr.toString());
		System.out.println(x.toString());
		
		arr.removeAll(x);//刪除arr中所有和x一樣的元素
		System.out.println(arr.toString());
		System.out.println(x.toString());
	}
	static void f11()//retain()僅保留arr中和x內相同的元素
	{
		arr.add("ABC");
		arr.add("ABC");
		arr.add("ABC");
		arr.add("ABC");
		arr.add("DEF");
		arr.add("GHI");
		arr.add("666");
		
		x.add("ABC");
		x.add("DEF");
		arr.retainAll(x);
		
		System.out.println(arr.toString());
		System.out.println(x.toString());
	}
	static void f12()//size()返回所含元素個數
	{
		arr.add("ABC");
		arr.add("DEF");
		arr.add("GHI");
		arr.add("666");
		System.out.println(arr.size());
	}
	static void f13()//toArray()轉化爲Object類型的數組
	{
		arr.add("ABC");
		arr.add("DEF");
		arr.add("GHI");
		arr.add("666");
		Object[] str= arr.toArray();
		for(int i=0;i<=str.length-1;i++)
			System.out.println(str[i].toString());	
	}
	public static void main(String[] args) {
		f13();
	}

}

注意點：
        1在使用迭代器遍歷期間，最好不要使用集合的刪除方法，刪除元素，如果要刪除可以使用迭代器自帶的remove方法
        2迭代器的add(增),remove(刪),set(改)最好不要同時使用
        在用Itrator遍歷時用list的remove刪除集合中的元素，會報錯，因爲破壞了集合和迭代器的關係，使得他們不穩定
        但是用迭代器對象的remove就不會出錯 

注List特有方法：可以操作下標 

    List l1=new ArrayList();
        //如果不指定類型的話，元素的類型爲Object

package a;

import java.util.*;

public class TestB//測試List接口中的方法，ArrayList是List的實現類
{
	static List<String> list=new ArrayList<String>();
	static List<String> x=new ArrayList<String>();
	static void f1()//add(索引,值)
	{
		list.add(0,"ABC");
		list.add(0,"DEF");//去了0索引，"ABC"整體後移
		System.out.println(list.toString());
	}
	static void f2()//addAll(索引,集合類對象的引用)
	{
		list.add("AAA");
		list.add("BBB");
		list.add("CCC");
		
		x.add("111");
		x.add("222");
		
		list.addAll(1,x);
		System.out.println(list.toString());
	}
	static void f3()//get(索引)
	{
		list.add("AAA");
		list.add("BBB");
		list.add("CCC");
		System.out.println(list.get(0));
	}
	static void f4()//indexOf() lastIndexOf()
	{
		list.add("AAA");
		list.add("BBB");
		list.add("CCC");
		list.add("AAA");
		System.out.println(list.indexOf("BBB"));
		System.out.println(list.lastIndexOf("AAA"));
		System.out.println(list.indexOf("666"));
	}
	static void f5()//set(索引,要改爲的值) 修改
	{
		list.add("AAA");
		list.add("BBB");
		list.add("CCC");
		list.add("AAA");
		list.set(3,"DDD");
		System.out.println(list.toString());
	}
	static void f6()
	{
		list.add("AAA");
		list.add("BBB");
		list.add("CCC");
		list.add("DDD");
		list.add("EEE");
		List<String>s=list.subList(1, 3); //左閉右開
		System.out.println(s.toString());
		System.out.println(list.toString());
	}
	public static void main(String[] args) {
		f6();

	}

}

//4List特有的迭代器:ListIterator 這種方法瞭解就可以了
	 public class Demo2 {

	public static void main(String[] args) {

		//4這種方法瞭解就可以了
		//ListIterator<E> listIterator()
		List l1=new ArrayList<>();
		l1.add("hello");
		l1.add(0,"Hello");
		l1.add("world");
		ListIterator it=l1.listIterator();
		while(it.hasNext()) {
			System.out.println(it.next());
		}
		/*
		 * 輸出：
		 *	Hello
			hello
			world
		 */
		
		
		//ListIterator<E> listIterator(int index)
		List list=new ArrayList<>();
		list.add("I");
		list.add(" love");
		list.add(" my");
		list.add(" life");
		ListIterator it1=list.listIterator(2);//從指定索引開始生成迭代器
		while(it1.hasNext()) {
			System.out.println(it1.next());
		}
		/*
		 *輸出： 
		 * my
 		 * life
		 */	
	}

}

 

/* 集合：
 * 集合與數組的比較：
 * 數組：可以存儲多個相同類型的數據，數據類型可以是簡單數據類型也可以是引用類型
 *     缺點：只能存儲固定長度的數據，一旦存完了就不能再繼續存儲
 * 集合：可以存儲多個類型相同或不同類型的數據
 * 		缺點：只能存儲引用數據類型
 * 		優點：存儲空間會隨着數據量的變化而變化，可以更加合理的使用內存空間。方法很多，方便我們進行操作
 * 集合的分類：
 * 常用的集合體系：
 * 	>Collection(接口)
 * 		>List(接口)存儲的值是有序(元素的存在順序與添加順序一致)的，可重複的.List的特殊之處在於可以對索引進行處理
 * 			>ArrayList(實現類)--類：底層的數據結構是數組，是線程不安全的，查找速度快，添加刪除速度慢
 * 			>LinkedList(實現類)--類：類：底層的數據結構是鏈表，是線程不安全的，查找速度慢，添加刪除速度快
 * 			>Vector(實現類)--類：底層的數據結構是數組，是線程安全的，查找速度快，添加刪除速度慢
 * 		>Set(接口)無序，不可重複
 * 			>HashSet(實現類)
 * 			>TreeSet(實現類)
 * 	>Map(接口)
 * 		>HashMap(實現類)
 * 		>TreeMap(實現類)
 */

 

public class Demo2 {

	public static void main(String[] args) {

//		LindedList特有的方法：
		LinkedList l1=new LinkedList<>();
//		addFirst()//始終在首位添加
//		addLast()//始終在末尾添加
		l1.add("hello");
		l1.addFirst("world");
		l1.addLast("WORLD");
		System.out.println(l1);
//		getFirst()//從頭部獲取，當獲取的對象不存在時，會發生異常
//		l1.clear();
//		l1.getFirst();報異常
//		getLast()從尾部獲取
//		System.out.println(l1.getLast());//異常
//		removeFirst()//刪除頭刪除的對象不存在會發生異常
//		removeLast()刪除尾
//
//		從jdk1.6開始出現以下方法(和上面那六個方法相對應，區別在於處理對象不存在時的方式)
		LinkedList l2=new LinkedList<>();
//		offerFirst()//始終在首位添加
		l2.offerFirst("haha");
//		offerLast()//始終在末尾添加
		l2.offerFirst("hehe");
		System.out.println(l2);
//		peekFirst()//獲取的對象不存在會返回null
//		peekLast()
//
//		pollFirst()//刪除的對象不存在會返回null
//		pollLast()

	}

}

關於Iterator

//Iterator<E> iterator() //獲取集合中的對象
//hasnext():盤點當前位置是否有元素，如果有返回true，沒有返回false
//當產生迭代器的時候，指針已經指向第一個元素
//next()：將當前值取出並返回，並將指針後移一位
//程序給每個集合都準備了一個屬於自己的迭代器對象，所以我們獲取迭代器對象的方法是調用集合的一個方法得到迭代器對象

	Iterator it=c1.iterator();
	while(it.hasNext()) {
		String s=(String)it.next();
		System.out.println(s);
	}
	
	//注意點：這個遍歷運行完之後，當前it迭代器對象的指針指向最後，要是再對這個迭代器對象進行遍
//歷...是不能成功的，除非產生新的迭代器
	//第二種遍歷方式
	for(Object str:c1)
	{
		System.out.println(str);
	}
	
	//在使用時，集合中可能有多種類型的元素，要進行容錯處理
	c1.add(5);//自動裝包爲Iteger
	Iterator it1=c1.iterator();
	while(it1.hasNext()) {
		Object s=it1.next();//相當於將String類型的對象賦值給Object類型（向上轉型，實際上是子類的類型）
		if(s instanceof String)//所以可以用instanceof方法判斷
			System.out.println(s);
		else
			System.out.println((Integer)s);
	}
	
	Iterator it2=c1.iterator();//但其實這樣不做類型轉換也是可以正常運行的
	while(it2.hasNext()) {
		Object s=it2.next();
			System.out.println(s);
	}

 

注：

1.List<String> list=new ArrayList<>();//後面<>可以不寫東西，但是前面<>必須寫

2.

public class TestC {

	public static void main(String[] args) {
		LinkedList<String> link=new LinkedList<String>();
		link.add("AAA");
		link.add("BBB");
		link.add("CCC");
		System.out.println(link.peekFirst());//得到頭部元素
		System.out.println(link.toString());
		System.out.println(link.pop());//彈出AAA並返回其值
		System.out.println(link.toString());//[BBB, CCC]LinkedList是先進先出的
	}

輸出：
AAA
[AAA, BBB, CCC]
AAA
[BBB, CCC]

public class Demo3 {
/*
 * ArrayList是有序的，可以重複的
 * 要求：使用List存儲數據，但是：有序的，不能重複的
 */
	public static void main(String[] args) {
		ArrayList list=new ArrayList<>();
		list.add("java2");//1
		list.add("java2");//2
		list.add("java4");//3
		list.add("java5");//4
		list.add("java6");//5
		
		//創建一個臨時的集合，用於存儲去重後的元素
		ArrayList list1=new ArrayList<>();
		//遍歷List
		Iterator it=list.iterator();
		while(it.hasNext()) {
			String str=(String)it.next();
//當list1中沒有str的時候，就天津進去
//如果新的集合中不包含當前的元素，就將當前的元素添加進去
/*
 * 原理：在添加新元素的時候，去調用contains方法，看在新的集合中是否有這個元素，
 * 但在contains內部是去調用集合中元素的equals方法，遍歷list集合元素,讓list1中的指定元素去和list集合中的元素比較，
 * 當所有的equals方法都返回false,整個conrains的結果就是false,有一次比較返回true，整個conrains的結果就是true
 * 退出循環。
 * 
 */
			if(!list1.contains(str))
				list1.add(str);
			
		}
		System.out.println(list1);


	}

}
輸出：[java2, java4, java5, java6]

public class Demo1 {

	public static void main(String[] args) {
	/*
	 * Vector:瞭解
	 * 遍歷的是枚舉器
	 */
		//使用Vector存值
		Vector v1=new Vector<>();
		v1.add("hello");
		v1.add("world");
		v1.add("i");
		v1.add("love");
		v1.add("my Life");
		System.out.println(v1);
		
		//遍歷--枚舉器
		//獲取枚舉器對象
		Enumeration e1=v1.elements();
		//調用方法遍歷
		while(e1.hasMoreElements()) {
			Object o1=(Object)e1.nextElement();
			System.out.println(o1);
		}

	}

}

Stack用作資源池

public class TestD {

	public static void main(String[] args) {
		Stack<Integer> s=new Stack<>();//Stack是Vector的子類，底層是數組，它是線性安全的
		s.add(1);
		s.add(2);
		s.add(3);
		System.out.println(s.toString());
		s.pop();//棧，後進先出（只有它特殊）
		System.out.println(s.toString());
	}

}
輸出：
[1, 2, 3]
[1, 2]

import java.util.*;

/*
 * ArrayList是有序的，可以重複的
 * 要求：使用List存儲數據，但是：有序的，不能重複的
 * 存儲的是Person類的對象，只要姓名和年齡相同就認爲是一個人
 */
class Person{
	String name;
	int age;
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
	Person()
	{}
	Person(String name,int age)
	{
		this.name=name;
		this.age=age;
	}
	public boolean equals(Object obj) {
		if(!(obj instanceof Person)) {
			throw new ClassCastException("當前對象不是Person類的");
		}
		Person p=(Person)obj;
		return (age==p.age && name.equals(p.name));
	}
	
	
	
}
public class Demo4 {
/*
 * ArrayList是有序的，可以重複的
 * 要求：使用List存儲數據，但是：有序的，不能重複的
 * 存儲的是Person類型的對象
 */
	public static void main(String[] args) {
		ArrayList list=new ArrayList<>();
		list.add(new Person("小明",22));//1
		list.add(new Person("小蘿蔔頭",22));//2
		list.add(new Person("小明",22));//3
		list.add(new Person("趙彥",23));//4
		list.add(new Person("趙彥",23));//5
		
		System.out.println(list);
		ArrayList list1=new ArrayList<>();//新建一個集合，存儲結果
		Iterator it=list.iterator();
		while(it.hasNext()) {
//			Object obj=it.next();
//			if(!(list1.contains(obj)));//調用的是Object類中的equals方法
			Person p=(Person)it.next();	
			if(!(list1.contains(p)))//不包含存值,contains內部會調用equals方法比較，所以只要重寫equals方法就行了
				
			list1.add(p);
		}
		System.out.println(list1);
	}

}