集合基礎

集合類的由來：

     JAVA是面向對象的，對象用來封裝特有數據，對象多了就需要儲存起來，當對象的個數不確定的時候，那麼就用集合容器進行存儲。

集合的特點：

　　1.集合的長度是可變的

　　2.用於存儲對象的容器

　　3.不可以存儲基本數據類型

體系：

　　集合容器因爲內部的數據結構不同，有多種具體容器，不斷的向上提取，形成了集合框架。

 Collection接口：

　　常見的方法

　　1.增加 

boolean add（Object obj）//添加一個對象
boolean addAll（Collection coll）//添加一個集合

　　2.刪除

boolean remove(Object Obj)//刪除一個對象
boolean removeAll(Collection coll)刪除集合中所有與coll相同的對象
void clear()清空

　　3.判斷

boolean contains(Object Obj)//判斷一個對象是否存在
boolean containsAll(Collection coll)//判斷集合中是否擁有coll總的所有對象
boolean isEmpty()//奇怪的很，沒有元素返回true

　　4.獲取

int size()//獲取對象的個數
Iterator iterator()//獲取對象，下面的代碼是這個方法的實現

Iterator接口

　　對集合進行迭代迭代器

　　這個接口是對所有的Collection容器進行元素獲取的公共接口

　　hasNext（）如果next仍然有元素可以迭代，就返回true

　　next（）返回迭代的下一個元素

方法一：

            Iterator it = coll.iterator();
	    while(it.hasNext()){
		System.out.println(it.next());
	    }        

方法二：節約空間，常用

for(Iterator it = coll.iterator();it.hasNext();){
			System.out.println(it.next());
}

這種迭代的獲取與直接打印( print(coll) )的區別在於，打印的是一串字符串，而迭代取得是單獨的對象，可以對他們單獨處理

　　5.其他

boolean retainAll（Collection coll）//取交集，刪除與coll集合中不同的元素
Object  toArray()//將集合轉成數組

List:

　　1.有序（存入和取出順序一致）

　　2.元素都有索引（腳標）

　　3.元素可以重複

常用子類：

　　1.Vector：內部是數組數據結構，同步的，增刪查詢都很慢。（基本淘汰）

　　2.ArrayList:內部是數組數據結構，不同步的，代替了Vector。查詢很快

　　3.LinkedList:內部是鏈表數據結構的，不同步的。增刪很快

常見的方法：

　　1.添加

void add(index,element)//在指定的位置插入對象
void add(index,collection)//在指定的位置插入集合

　　2.刪除

Object remove(index)//刪除指定位置的對象，返回值爲被刪除的對象

　　3.修改（只有List才具有增刪改查，collection都不具備）

Object set(index,element)//返回值爲被修改的對象，即修改前的對象

　　4.獲取

Object get(index)//返回值爲獲取的對象
List subList(from,to)//返回指定範圍的對象
int indexOf(Object)//返回對象的位置，從頭開始找
int lastIndexOf(Object)//返回對象的位置，從尾開始找

　　

list特有的取出元素的方法（只有list有set不具備）：

		for(int x=0;x<list.size();x++){
			System.out.println(list.get(x));
		}

　　

ListIterator:

　　1.Iterator的子接口

　　2.可以實現在迭代過程中完成對元素的操作（增刪改查）注意：只有List集合具備該迭代功能

如果有下面的代碼（在迭代的過程中，增加元素）

		 Iterator it =list.iterator();
		 while(it.hasNext()){
			 Object obj=it.next();
			 if(obj=="b"){
				 list.add("e");
			 }else{
				 System.out.println(obj);
			 }
		 }

　　這裏會發生異常，原因是在迭代的過程中，操作集合，產生了併發。

解決問題：

　　1.在迭代的時候不能操作集合，容易產生異常

　　2.使用ListIterator接口來完成在迭代過程中對元素的更多的操作

		 ListIterator it = list.listIterator();//獲取列表迭代器對象
		 while(it.hasNext()){
			 Object obj=it.next();
			 if(obj=="b"){
				 it.add("e");
				 System.out.println(obj);
			 }else{
				 System.out.println(obj);
			 }
		 }
		 while(it.hasPrevious()){//如果前一個任然有元素可以迭代，那麼就返回true
			 System.out.println(it.previous());//返回前一個元素
		 }

　　

Vector：

​ 　　Enumeration：

　　　　​ 1.這個接口淘汰了，基本不用

​ 　　　　2.這個接口的功能與Iterator接口的功能是重複來的

​ 　　　　3.Iterator接口添加了一個可選的移除操作，並且使用了較短的方法名。

　　​ 　　4.新的實現應該考慮優先使用Iterator接口而不是Eumeration接口

​ 　　　　elements:這個方法與List中的iterator方法有異曲同工之妙

        Vector ve=new Vector();
        ve.addElement("a");
        ve.addElement("b");
        ve.addElement("c");
        Enumeration em=ve.elements();
        while(em.hasMoreElements()){
            System.out.println(em.nextElement());
        }
        Iterator it=ve.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
//這兩個方法的作用基本一樣，但是前一種基本上是淘汰了

LinkedList:

​ 　　1.內部是鏈表數據結構，是不同步的，增刪很快

​　　 2.堆棧：先進後出

​ 　　  隊列：先進先出

​ 　　3.常用方法

​ 　　　　增加：

　　　　　　​ boolean add（ Collection<? extends E> c）//在結尾添加一個元素

​ 　　　　　　boolean addAll（int index, Collection<? extends E> c）//在指定位置插入一個集合

​ 　　　　　　void addFirst（E o）//在開頭加入一個元素

　　　　　　​ void addLast（E o）//在結尾加入一個元素

​ 　　　　刪除：

　　　　　　​ void clear()

​　　　　　　 E remove()

​ 　　　　獲取:

　　　　　　​ E getFirst()

​ 　　　　　　E peek();

​ 　　　　修改：

​ 　　　　　　Object set(index,Objcet)

ArrayList:

下面的代碼中的強轉問題，可能會涉及到自動裝箱問題，在這裏也是可以使用的

        ArrayList ar=new ArrayList();
        Person a=new Person(19,"lao1");
        Person b=new Person(16,"lao2");
        Person c=new Person(11,"lao3");
        ar.add(a);
        ar.add(b);
        ar.add(c);
        for(Iterator it=ar.iterator();it.hasNext();){
            //System.out.println(((Person)it.next()).getAge()+((Person)it.next()).getName());
            //輸出肯定是有問題的一直在next
            //所以解決方法如下
            Person d=(Person) it.next();//強轉的原因是，在Aar.add()添加的時候，是使用Object接收的，所以person已經變成了上帝
            System.out.println(d.getAge()+d.getName());
        }

Set:

​ 　　1.Set接口中的方法和Collection一致

　　​ 2.Set獲取元素的方法只有迭代器

​　　 3.常用實現子類HashSet，TreeSet

​ 　　4.元素不可重複，無序（但是可以做到有限的有序）

HashSet:

　　​ 1.內部數據結構是哈希表，不同步

　　​ 2.如何保證該集合的元素唯一性呢？

​ 　　　　a.通過對象的hashCode和equals方法來完成對象的唯一性

​　　　　 b.如果對象的hashCode值不同，那麼不用判斷equals方法，直接存儲到嘻哈表中（int hashCode();boolean equals(Object obj)）

​ 　　　　c.如果對象的hashCode值相同，那麼要再次判斷對象的equals方法是否爲true，true則視爲相同元素，不存。

​ 　　　　d.重點：如果元素要存儲到HashSet集合中，必須覆蓋hashCode方法和equals方法；一般情況下如果定義的類會產生很多對象，比如人，學生，書，通常都需要覆蓋這兩個方法，建立對象判斷是否相同的依據。

​ 　　　　e.擴展：Arraylist（如果要確保元素唯一的話）判斷的依據是equals，而HashSet判斷hashcode和equals

​

LinkedHashSet:

　　1.HashSet的直接已知實現子類

​ 　   2.可以在唯一的情況下排序，怎麼進就怎麼出

        HashSet/LinkedHashSet ha=new LinkedHashSet();
        ha.add("a");
        ha.add("d");
        ha.add("s");
        for(Iterator it=ha.iterator();it.hasNext();){
            System.out.println(it.next());
        }
//所以需要有序唯一的話可以直接使用LinkedHashSet類

TreeSet：

​　　 1.可以對set集合中的元素排序。是不同步的

​ 　　2.判斷元素唯一性的方式：就是根據比較方法返回結果是否爲0，如果爲0，就是相同元素，則不存儲（所以要實現Comparable接口，覆蓋compareTo方法元素和集合實現都可以；一般在做這一步的時候，也一起把排序給做了）

​ 　　3.排序的兩種方法

​ 　　　　a.讓元素自身具備比較功能

​ 　　　　b.讓集合自身具備比較功能（1.如果不按照對象具備的自然順序排序2.對象不具備自然順序；這兩種情況時使用該功能）

​ 　　4.比較器（即b）

​　　　　 定義一個類實現Comparator接口，覆蓋compare方法，將該類對象最爲參數傳遞給TreeSet集合的構造函數

 //比較器，按照名字
class ComparatorByName implements Comparator {
        public int compare(Object o1, Object o2) {
            Person p1 = (Person)o1;
            Person p2 = (Person)o2; 
            int temp = p1.getName().compareTo(p2.getName());    
         return temp==0?p1.getAge()-p2.getAge(): temp;
        }
}
​
//比較器，按照年齡
class ComparatorByLength implements Comparator {
    public int compare(Object o1, Object o2) {
        Person s1 = (Person)o1;
        Person s2 = (Person)o2;
        int temp = s1.getAge()-s2.getAge();
        return temp==0? s1.compareTo(s2): temp;
    }
​
}
        TreeSet tr=new TreeSet(new ComparatorByLength());//比較器的使用方法
        Person a=new Person("lao3",11);