java容器詳細解析（轉）

：在java開發中咱們確定會大量的使用集合，在這裏我將總結常見的集合類，每一個集合類的優勢和缺點，以便咱們能更好的使用集合。下面我用一幅圖來表示

其中淡綠色的表示接口，紅色的表示咱們常用的類。

1：基本概念

Java容器類類庫的用途是保存對象，能夠將其分爲2個概念。

1.1：Collection

一個獨立元素的序列，這些元素都服從一條或多條規則。其中List必須按照插入的順序保存元素、Set不能有重複的元素、Queue按照排隊規則來肯定對象的產生順序（一般也是和插入順序相同）

1.2：Map

一組成對的值鍵對對象，容許用鍵來查找值。ArrayList容許咱們用數字來查找值，它是將數字和對象聯繫在一塊兒。而Map容許咱們使用一個對象來查找某個對象，它也被稱爲關聯數組。或者叫作字典。

2：List

List承諾能夠將元素維護在特定的序列中。List接口在Collection的基礎上加入了大量的方法，使得能夠在List中間能夠插入和移除元素。下面主要介紹2種List

2.1：基本的ArrayList

它的優勢在於隨機訪問元素快，可是在中間插入和移除比較慢

那麼如今咱們就一塊兒來看看爲何ArrayList隨機訪問快，而插入移除比較慢。先說關於ArrayList的初始化。

ArrayList有三種方式進行初始化以下

private transient Object[] elementData;

public ArrayList() {
        this(10);
    }
  public ArrayList(int initialCapacity) {
        super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        this.elementData = new Object[initialCapacity];
    }
 public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        size = elementData.length;
        // c.toArray might (incorrectly) not return Object[] (see 6260652)
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    }

咱們能夠看出ArrayList其實就是採用的是數組（默認是長度爲10的數組）。全部ArrayList在讀取的時候是具備和數組同樣的效率，它的時間複雜度爲1。

插入尾部就是elementData[size++] = e;固然中間會進行擴容。如今主要說插入中間爲何相對來講比較慢源碼以下

 public void add(int index, E element) {
        rangeCheckForAdd(index);//驗證（能夠不考慮）

        ensureCapacityInternal(size + 1);  // Increments modCount!!（超過當前數組長度進行擴容）
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);(核心代碼)
        elementData[index] = element;
        size++;
    }

System.arraycopy(elementData, index, elementData, index + 1)第一個參數是源數組，源數組起始位置，目標數組，目標數組起始位置，複製數組元素數目。那麼這個意思就是從index索性處每一個元素向後移動一位，最後把索引爲index空出來，並將element賦值給它。這樣一來咱們並不知道要插入哪一個位置，因此會進行匹配那麼它的時間賦值度就爲n。

2.2：LinkedList

它是經過代價較低在List中間進行插入和移除，提供了優化的順序訪問，可是在隨機訪問方面相對較慢。可是他的特性功能要比ArrayList強大的多。支持Queue和Stack

ListedList採用的是鏈式存儲。鏈式存儲就會定一個節點Node。包括三部分前驅節點、後繼節點以及data值。因此存儲存儲的時候他的物理地址不必定是連續的。

咱們看下它的中間插入實現

從代碼咱們能夠看出先獲取插入索引元素的前驅節點，而後把這個元素做爲後繼節點，而後在建立新的節點，而新的節點前驅節點和獲取前驅節點相同，然後繼節點則等於要移動的這個元素。因此這裏是不須要循環的，從而在插入和刪除的時候效率比較高。

咱們在來看看查詢（咱們能夠分析出它的效率要比ArrayList低了很多）

3：Set

Set也是一個集合，可是他的特色是不能夠有重複的對象，因此Set最經常使用的就是測試歸屬性，很容易的詢問出某個對象是否存在Set中。而且Set是具備和Collection徹底同樣的接口，沒有額外的功能，只是表現的行爲不一樣。

3.1：HashSet

HashSet查詢速度比較快，可是存儲的元素是隨機的並無排序，下面我寫一段程序看一下

public static void main(String[] args){
        /**
         * 沒有順序可循，這是由於hashset採用的是散列（處於速度考慮）
         */
        Random random=new Random(47);
        Set<Integer> intset=new HashSet<Integer>();
        for (int i=0;i<10000;i++){
            intset.add(random.nextInt(30));
        }
        System.out.print(intset);
    }

3.2：TreeSet

TreeSet是將元素存儲紅-黑樹結構中，因此存儲的結果是有順序的（因此若是你想要本身存儲的集合有順序那麼選擇TreeSet）

public static void main(String[] args){
        Random random=new Random(47);
        Set<Integer> intset=new TreeSet<Integer>();
        for (int i=0;i<10000;i++){
            intset.add(random.nextInt(30));
        }
        System.out.print(intset);
    }

 關於LinkedHashSet後面再說。

4：Queue

Queue是隊列，隊列是典型的先進先出的容器，就是從容器的一端放入元素，從另外一端取出，而且元素放入容器的順序和取出的順序是相同的。LinkedList提供了對Queue的實現，LinkedList向上轉型爲Queue。其中Queue有offer、peek、element、pool、remove等方法

offer是將元素插入隊尾，返回false表示添加失敗。peek和element都將在不移除的狀況下返回對頭，可是peek在對頭爲null的時候返回null，而element會拋出NoSuchElementException異常。poll和remove方法將移除並返回對頭，可是poll在隊列爲null，而remove會拋出NoSuchElementException異常，如下是例子

  public static void main(String[] args){
        Queue<Integer> queue=new LinkedList<Integer>();
        Random rand=new Random();
        for (int i=0;i<10;i++){
            queue.offer(rand.nextInt(i+10));
        }
        printQ(queue);
        Queue<Character> qc=new LinkedList<Character>();
        for (char c:"HelloWorld".toCharArray()){
            qc.offer(c);
        }
        System.out.println(qc.peek());
        printQ(qc);
        List<String> mystrings=new LinkedList<String>();
        mystrings.add("1");
        mystrings.get(0);
        Set<String> a=new HashSet<String>();
        Set<String> set=new HashSet<String>();
        set.add("1");
    }
    public static void printQ(Queue queue){
        while (queue.peek

從上面的輸出的結果咱們能夠看出結果並非一個順序的，沒有規則的，這個時候若是想讓隊列按照規則輸出那麼這個時候咱們就要考慮優先級了，這個時候咱們就應該使用PriorityQueue，這個時候若是在調用offer方法插入一個對象的時候，這個對象就會按照優先級在對列中進行排序，默認的狀況是天然排序，固然咱們能夠經過Comparator來修改這個順序（在下一篇講解）。PriorityQueue能夠確保當你調用peek、pool、remove方法時，獲取的元素將是對列中優先級最高的元素。ok咱們再次經過代碼查看

 public static void main(String[] args) {
        PriorityQueue<Integer> priorityQueue = new PriorityQueue<Integer>();
        Random rand = new Random();
        for (int i = 0; i < 10; i++) {
            priorityQueue.offer(rand.nextInt(i + 10));
        }
        QueueDemo.printQ(priorityQueue);
        List<Integer>ints= Arrays.asList(25,22,20,18,14,9,3,1,1,2,3,9,14,18,21,23,25);
        priorityQueue=new PriorityQueue<Integer>(ints);
        QueueDemo.printQ(priorityQueue);
    }

從輸出能夠看到，重複是容許的，最小值擁有最高優先級（若是是String，空格也能夠算做值，而且比字母具備更高的優先級）若是你想消除重複，能夠採用Set進行存儲，而後把Set做爲priorityQueue對象的初始值便可。

5：Map

Map在實際開發中使用很是廣，特別是HashMap，想象一下咱們要保存一個對象中某些元素的值，若是咱們在建立一個對象顯得有點麻煩，這個時候咱們就能夠用上map了，HashMap採用是散列函數因此查詢的效率是比較高的，若是咱們須要一個有序的咱們就能夠考慮使用TreeMap。這裏主要介紹一下HashMap的方法，你們注意HashMap的鍵能夠是null，並且鍵值不能夠重複，若是重複了之後就會對第一個進行鍵值進行覆蓋。

put進行添加值鍵對，containsKey驗證主要是否存在、containsValue驗證值是否存在、keySet獲取全部的鍵集合、values獲取全部值集合、entrySet獲取鍵值對。

 public static void main(String[] args){
        //Map<String,String> pets=new HashMap<String, String>();
        Map<String,String> pets=new TreeMap<String, String>();
        pets.put("1","張三");
        pets.put("2","李四");
        pets.put("3","王五");
        if (pets.containsKey("1")){
            System.out.println("已存在鍵1");
        }
        if (pets.containsValue("張三")){
            System.out.println("已存在值張三");
        }
        Set<String> sets=pets.keySet();
        Set<Map.Entry<String , String>> entrySet= pets.entrySet();
        Collection<String> values=  pets.values();
        for (String value:values){
            System.out.println(value+";");
        }
       for (String key:sets){
           System.out.print(key+";");
       }
        for (Map.Entry entry:entrySet){
            System.out.println("鍵："+entry.getKey());
            System.out.println("值："+entry.getValue());
        }
    }

6：Iterator和Foreach

如今foreach語法主要做用於數組，可是他也能夠應用於全部的Collection對象。Collection之因此可以使用foreach是因爲繼承了Iterator這個接口。下面我寫段代碼供你們查看

public class IteratorClass {
    public Iterator<String> iterator(){
      return new Itr();
    }
    private class Itr implements Iterator<String>{
        protected String[] words=("Hello Java").split(" ");
        private int index=0;
        public boolean hasNext() {
            return index<words.length;
        }
        public String next() {
            return words[index++];
        }
        public void remove() {
        }
    }
}

 Iterator iterators=new IteratorClass().iterator();
        for (Iterator it=iterator;iterators.hasNext();) {
            System.out.println(iterators.next());
        }
        while (iterators.hasNext()){
            System.out.println(iterators.next());
        }

從中咱們能夠看出foreach循環最終是轉換成 for (Iterator it=iterator;iterators.hasNext();)只不過jdk幫咱們隱藏咱們沒法查看。下面咱們在來分析一個問題，關於List刪除問題。咱們大多確定使用過for循環或者foreach循環去刪除，可是結果很明顯會出現錯誤，那麼如今咱們一塊兒分析爲啥會出現錯誤。

1：使用for循環刪除（出現錯誤分析）

2：foreach循環刪除（錯誤分析）

從上面咱們得知foreach最終是會轉成Iterator的因此它首先會經過next來獲取元素，咱們看代碼

 請看for循環刪除那段代碼，沒刪除一次modCount會++，因此第二次在次刪除的時候modCount因爲增長和expectedModCount不等因此沒法獲取元素也就沒法刪除。

3：正確的刪除方式

採用迭代器代碼以下

 Iterator<String> iterator=userList.iterator();
        while (iterator.hasNext()){
            iterator.next();
            iterator.remove();
        }

請記住必定要加上iterator.next();這是由於在源碼中有一個lastRed，經過它來記錄是不是最後一個元素，若是不加上iterator.next()那麼lastRed=-1,在刪除驗證的時候有這麼一段代碼if (lastRet < 0)throw new IllegalStateException();因此就會拋出異常。

 

7：Collections和Arrays

這裏只介紹2個經常使用的Collections.addAll和Arrays.asList

addAll：

asList採用的是數組

能夠看出最終轉換成ArrayList。

 8：總結

1）：數組是將數字和對象聯繫起來，它保存明確的對象，查詢對象時候不須要對查詢結果進行轉換，它能夠是多維的，能夠保存基本類型的數據，可是數組一旦生成，其容量不能改變。因此數組是不能夠直接刪除和添加元素。

2）：Collection保存單一的元素，而Map保存相關聯的值鍵對，有了Java泛型，能夠指定容器存放對象類型，不會將錯誤類型的對象放在容器中，取元素時候也不須要轉型。並且Collection和Map均可以自動調整其尺寸。容器不能夠持有基本類型。

3）：像數組同樣，List也創建數字索性和對象的關聯，所以，數組和List都是排好序的容器，List能夠自動擴容

4）：若是須要大量的隨機訪問就要使用ArrayList，若是要常常從中間插入和刪除就要使用LinkedList。

5）：各類Queue和Stack由LinkedList支持

6）：Map是一種將對象（而非數字）與對象相關聯的設計。HashMap用於快速訪問，TreeMap保持鍵始終處於排序狀態，因此不如HashMap快，而LinkedHashMap保持元素插入的順序，可是也經過散列提供了快速訪問的能力

7）：Set不接受重複的元素，HashSet提供最快的訪問能力，TreeSet保持元素排序狀態，LinkedHashSet以插入順序保存元素。