Collection：
    set(接口)
    AbstractCollection(抽象類)
        AbstractList->List
            AbstractSequentialList
                LinkedList(實現了Deque雙端隊列接口)
            Vetor<-Stack
            ArrayList
        AbstractSet(實現了Set接口)
            TreeSet:實現了NavigableSet->SortedSet->Set
    List(接口)
    Queue(接口)   
接口
    Collection  Set List    Queue   SortedSet   NavigableSet
    分析：
        1:所有的類或接口都是實現了Collection接口
        2:TreeSet，HashSet，LinkedHashSet實現了Set接口，其中TreeSet實現了SortedSet
        3:ArrayList,Vector,LinkedList實現了List接口
java.util.Collection
    所有集合的根接口
    增加：
        add(o:E):boolean
        addAll(c:Collection<? extends E>):boolean
    刪除
        remove(o:E):boolean
        removeAll(c:Collection<?>):boolean
        clear():boolean
    修改：
    查：
        contains(o:Object):boolean
        containsAll(c:Collection<?>):boolean
    其他：
        equal(o:Object)
        hashCode();int  //返回集合的散列碼
        size():int  
        toArray():Object[]  //返回集合的數組情勢
        isEmpty()
        iterator():Interator<E>     //返回1個迭代器
    備注：Iterator接口
        hasNext()
        Next()
Set集合
    Set接口擴大了Collection接口。它沒有引入新的方法或常量，只是規定set的實例不包括重復的元素
        1,Set接口依托hashCode和equals()完成重復元素的判斷，關注這點在往后的map接口中也有體現
        2,TreeSet依托Comparable接口來完成排序的操作
        3,Set方法使用時，元素為自定義類時，自定義類要腹瀉Object類中的equals(),hashCode(),toString()方法
        4,具體實現類HashSet，TreeSet，LinkedHashSet
        5,特別注意，規則集中不存在重復元素，所以添加重復元素時會返回false，但是不會有異常
散列集java.util.HashSet    
    初始容量為16，客座率為0.75
    當元素個數超過容量*客座率的乘積，容量就會自動翻倍
    初始化
        HashSet()
        HashSet(c:Collection<? extends E>)
        HashSet(initialCapacity:int)
        HashSet(initialCapacity:int,loadFactor:float)   
    方法：
        實現了Collection接口中的方法
鏈式散列表LinkedHashSet
    用1個鏈表來擴大HashSet，支持對規則集內的元素排序（所謂的排序就是依照添加的順序存儲，訪問的時候也是依照添加的順序）。HashSet中的元素是沒有被排序的，而LinkedHashSet中的元素可以依照他們插入規則集的順序提取。
    初始化：
        LinkedHashSet()
        LinkedHashSet(c:Collection<? extends E>)
        LinkedHashSet(initialCapacity:int)
        LinkedHashSet(initialCapacity:int,loadFactor:float)
    方法：
        實現了Collection中的方法
    Set方法沒有訪問索引的方法，只有add，remove，contains類方法
樹形集TreeSet
    SortedSet是Set的1個子接口，可以確保規則集中的元素時有序的。另外，它還提供方法first，last方法以返回規則集中的第1個和最后1個，和方法headSet((toElement))和tail(fromElement)返回規則集中小于toElement或大于等于fromElement的部份
    NavigableSet擴大了SortedSet，并提供導航方法lower(e),floor(e),ceiling(e),higher(e)以分別返回小于，小于等于，大于等于和大于給定元素的元素。如果沒有就返回null。pollFirst，pollLast會分別刪除和返回樹形集中的第1個元素和最后1個元素
    TreeSet是SortedSet的1個具體類，元素必須是可比較的，即元素實現了comparable接口或被指定了比較器
    總結1下方法
    TreeSet普通方法：
        Set自我感覺提供的是1種存儲的服務，其實不善于找出這個位置，所以他的存儲是無序的，因此方法上與list就不1樣了，不需要有index參數
        初始化
            TreeSet()
            TreeSet(c:Collection<? extends E>)
            TreeSet(comparator:Comparator<? super E>)
            TreeSet(s:SortedSet<E>)
        增加：
            add()
            addAll()
        刪除：
            remove()
            removeAll()
            clear()
        修改：
        查找：
            contains()
            containsAll()
        其他（長度，迭代器，哈希code等）：
            size();
            toArray()
            isEmpty()
            iterator()
            equals()
            hashCode()
    TreeSet的特殊方法(實現了接口SortedSet和NavigableSet的方法)：
        注意：使用這些方法時，定義對象的類型必須是SortedSet
        增加：
            無
        刪除：
            pollFirst()
            pollLast()
        查找：
            導航方法
            首個元素：   first() //空集和時會引發異常
            尾元素：    last()
            小于e的集合  headSet():SortedSet<E> //不存在返回空集
            大于等于e的集合    tailSet():SotedSet<E> //不存在返回空集
            大于e     higher(e)   //不存在返回null
            大于等于    ceiling(e)  //不存在返回null
            小于      lower(e)    //不存在返回null
            小于等于    floor(e)    //不存在返回null     
        修改：
        其他：     
        小技能：
            1、當定義hashset時可使用Set<E> set = new HashSet<E>()定義
            2、定義TreeSet時，最后直接使用TreeSet<E> set = new TreeSet<E>() 
Comparable接口
    位于java.lang
    public interface Companrable<T>{
        public int compareTo(T o);
    }
Comparator接口
    有時候希望將元素插入1個樹集合中，這些元素可能不是java.lang.comparable的實例，這時候可以定義1個比較器來比較這些元素。要做到這1點創建1個java.util.Comparator接口的類。
    comparator接口有兩個方法：
        public int compare(Object e1,Object e2)
        public boolean equals(Object e)




線性表
    規則集中只能存儲不重復的值，為了存儲重復的值需要使員工線性表。
    List接口擴大了Collection接口，以定義1個允許重復的有序集合。List接口增加了面向位置的操作，并且增加了1個能夠雙向遍歷線性表的迭代器
    方法：
        1、可使用Collection中的方法
        2、操作中分為面向元素和面向位置兩種方式
        增加：
            add(index:int):boolean
            add(index:int,c:Collection<? extends E>)
            add(E)  //末尾添加
            addAll(c:Collection<? extends E>);  //末尾添加
        刪除：
            remove(index:int)
            remove(o)
            removeAll(c)
        修改：
            set(index:int,e):E
        查找：
            //查找元素
            get(index:int):E
            contains(o):boolean
            contains(c):boolean
            //面向索引
            indexOf(e)
            lastIndexOf(e)
        其他
            listIterator():ListIterator<E>
            listIterator(startIndex:int):ListIterator<E>
            subList(fromIndex:int,toIndex:int):List<E>  //返回從fromIndex到toIndex⑴的子列表
java.util.ListIterator
        add(o:E):void
        向后：
            hasNext():boolean
            Next():E
            nextIndex():int     //返回下1個元素的下標
            remove():void
        向前：
            hasPrevious()
            previous()
            previousIndex():index   //返回前1個元素的下標
            set(E):void //使用指定的元素替換previous或next返回的最后1個元素
數組線性表ArrayList
java.util.ArrayList<E>:
    初始化:
        List<E> list = new ArrayList<E>();
        ArrayList<E>()
        ArrayList<E>(c:Collection<? extends E>)
        ArrayList<E>(capacity:int)
    增加：
        add(o:E):void
        add(index:int,o:E):void//插入元素
    刪除：
        remove(o:E):boolean
        remove(index:int):boolean//索引必須公道，否則有異常出現
        clear()
    修改：
        set(index:int,o:E):E    //索引必須公道，否則有異常出現
    查：
        get(index:int):E
        indexOf(o:E):int    //不存在返回⑴
        lastIndexOf(o:E):int    //不存在返回⑴
        contains(o:E):boolean
        isEmpty():boolean
    長度：
        size()
    自動減小
        線性表不會自動減小，只會自動增加
        trimToSize()    //容量減小到這個列表確當前大小
鏈表線性表LinkedList
    實現了List的接口和Queue接口
    初始化
        LinkedList()
        LinkedList(c:Collection<? extends E>)
    增加：
        addFist(o:E)    //添加到列表頭
        addLast(o:E)    //添加到列表尾
        //List中的方法
        add(index)
        add(index,e)
        addAll(c)
    刪除
        removeFirst()
        removeLast()
        //List
        remove(index)
    查找
        getFirst()
        getLast()
        //List
        get(index)
        indexOf(e)
        lastIndexOf(e)
    其他
        //List
        listIterator():ListIterator<E>
        listIterator(index):ListIterator<E>()
        subList(start,end);     //start~end⑴
Collection靜態方法
    排序(改進歸并排序)
        sort(list:List):void
        sort(list:List,c:Comparator):void
    查找
        binarySearch(list,key)
        binarySearch(list,key,comparator)
    顛倒
        reverse(list)
    倒序
        reverseOrder();//返回逆序的比較器
    隨機打亂
        shuffle(list)
        shuffle(list,random) //用隨機對象打亂
    復制
        copy(des:List,src:List):void
        nCopies(n:int,o:Object):List    //返回o的n個副本的列表
    填充
        fill(list,o)    //用指定元素替換線性表中的所有元素
    最大值
        max(c:Collection):Object
        max(c:Collection,c:comparator):Object
    最小值
        min(c):Object
        min(c1,c2):Object
    某元素出現次數
        frequency(c:Collection,o:Object):int    
向量類Vector
    與ArrayList幾近1樣，只是添加了同步方法    
    實現了List方法
    初始化
        Vector()
        Vector(c:Collection<? extends E>)
        Vector(initialCapacity:int);
        Vector(initialCapacity:int,CapacityIncr:int)
    增加：
        addElement(o:E)
        insertElementAt(o:E,index:int)
    刪除
        removeAllElements()
        removeElement(o)
        removeElementAt(index)
    修改：
        setElementAt(o,index)
    查找
        firstElement()
        lastElement()
        ElementAt(index)
Stack
    Stack()
    empty()
    pop()
    push()
    peek():返回棧頂元素
    search(o): 返回棧中指定元素的位置
Queue
    offer(e):向隊列中插入1個元素
    poll(): 出隊，空時返回null
    remove():出隊，空時出現異常
    peek(): 獲得隊首元素，為空時返回null
    element():獲得隊首元素，為空時出現異常
Deque   雙端隊列
    LinkedList 實現了Deque接口，因此可使用LinkedList創建1個雙端隊列
    addFirst()
    addLast()
    removeFirst()
    removeLast()
    getFirst()
    getLast()


Map
    用于存儲鍵值對情勢的數據
    map接口提供的方法
        查詢
            get(key):V
            values():Collection<V>
            keySet():Set<K>
            entrySet():Set<Map.Entry<K,V>>
            containsKey(key):boolean
            containsValue(value):boolean
            isEmpty()
            size()
        增加
            put(key,value)
            put(map)
        刪除
            remove(key)
            clear()
        修改
HashMap

LinkedHashMap
    使用linked list實現來擴大HashMap
TreeMap         
    在遍歷排好序的鍵值時高效
    有新的導航方法
        firstKey()
        lastKey()
        headMap(toKey)
        tailMap(fromKey)

        floorKey(key)
        ceillingKey(key)
        lowerKey(key)
        higherKey(key)
    附：map的遍歷方法
        Set<Map.Entry<K,V>> set = map.entrySet();
        for(Map.Entry<K,V> m : set){
            key=m.getKey();
            value=m.getValue();
        }