Java：集合，Array、Collection(List/Set/Queue)、Map的遍歷，比如：ArrayList,LinkedList,HashSet,HashMap

1. 概述

1.1 Set接口  

1. 存入Set的每個元素都必須是唯一的，Set接口不保證維護元素的次序；
2. HashSet類： 為快速查找設計的Set，存入HashSet的對象必須定義hashCode()，它不保證集合的迭代順序；  
3. LinkedHashSet類： 具有HashSet的查詢速度，且內部使用鏈表維護元素的順序(插入的次序)。

1.2 List接口

1.  List按對象進入的順序保存對象，不做排序等操作；
2.  ArrayList類：由數組實現的List，允許對元素進行快速隨機訪問，但是向List中間插入與移除元素的速度很慢；
3.  LinkedList類： 對順序訪問進行了優化，向List中間插入與刪除的開銷並不大，隨機訪問則相對較慢。

1.3 Queue接口

1. Queue用於模擬隊列這種數據結構，實現“FIFO”等數據結構。通常，隊列不允許隨機訪問隊列中的元素。
2. ArrayDeque類：為Queue子接口Deque的實現類，數組方式實現。
3. LinkedList類：是List接口的實現類，同時它也實現了Deque接口（Queue子接口）。因此它也可以當做一個雙端隊列來用，也可以當作“棧”來使用。

1.4 Map接口

1.  添加、刪除操作put/remove/putAll/clear
2.  查詢操作get/containsKey/containsValue/size/isEmpty
3.  視圖操作keySet/values/entrySet
4.  Map.Entry接口(Map的entrySet()方法返回一個實現Map.Entry接口的對象集合)  getKey/getValue/setValue

下面是一段代碼用來遍歷各種數組、集合、映射的。更多內容請參考：

Java：集合，Collection接口框架圖

Java：集合，Map接口框架圖

Java：concurrent包下面的Collection接口框架圖（ CopyOnWriteArraySet, CopyOnWriteArrayList,ConcurrentLinkedQueue,BlockingQueue）

Java：concurrent包下面的Map接口框架圖（ConcurrentMap接口、ConcurrentHashMap實現類）

2. 示范代碼

package com.clzhang.sample.collections;

import java.util.*;

import org.junit.Test;
import org.junit.Before;
import org.junit.After;

/**
 * 測試遍歷Array/Set/List/Queue/Map的類
 * @author acer
 *
 */
public class CollectionMapTest {
    private static final int TOTAL_COUNT = 100000;
    
    private String[] array;
    private Set<String> set;
    private List<String> list;
    private Queue<String> queue;
    private Map<String, String> map;

    @Before
    public void init() {
        // 准備測試數據
        array = new String[TOTAL_COUNT];
        set = new HashSet<String>();
        list = new ArrayList<String>();
        queue = new LinkedList<String>();
        map = new HashMap<String, String>();
        
        for (int i = 0; i < TOTAL_COUNT; i++) {
            String key = "user" + i;
            String value = "pass" + i;
            
            array[i] = key;
            set.add(key);
            list.add(key);
            queue.add(key);
            map.put(key, value);
        }
    }
    
    @After
    public void destory() {
    }

    @SuppressWarnings("unused")
    @Test
    public void testArray() {
        long startTime = Calendar.getInstance().getTimeInMillis();

        // 老款遍歷的方法
        for (int i = 0; i < array.length; i++) {
            String str = array[i];
        }

        // foreach遍歷：JDK1.5之后的方法
        for (String str : array) {
            // 直接用了
        }
        
        System.out.println("遍歷array各種方式總耗時：" + (Calendar.getInstance().getTimeInMillis() - startTime));
    }
    
    @SuppressWarnings("unused")
    @Test
    public void testSet() {
        long startTime = Calendar.getInstance().getTimeInMillis();

        // 迭代遍歷
        Iterator<String> it = set.iterator();
        while (it.hasNext()) {
            String str = it.next();
        }

        // 迭代遍歷的for方式；或者相對while循環而言，能夠避免變量名錯誤
        for (Iterator<String> iter = set.iterator(); iter.hasNext();) {
            String str = iter.next().toString();
        }

        // foreach遍歷：JDK1.5之后的方法
        for (String str : set) {
            // 直接用了，注意它是無序的
        }

        System.out.println("遍歷set各種方式總耗時：" + (Calendar.getInstance().getTimeInMillis() - startTime));
    }

    @SuppressWarnings("unused")
    @Test
    public void testList() {
        long startTime = Calendar.getInstance().getTimeInMillis();

        // 老款遍歷的方法
        for (int i = 0; i < list.size(); i++) {
            String str = list.get(i);
        }

        // 迭代遍歷
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            String str = iterator.next();
        }

        // 迭代遍歷的for方式；相對while循環而言，能夠避免變量名錯誤
        for (Iterator<String> iter = list.iterator(); iter.hasNext();) {
            String str = iter.next().toString();
        }

        // foreach遍歷：JDK1.5之后的方法
        for (String str : list) {
            // 直接用了
        }

        System.out.println("遍歷list各種方式總耗時：" + (Calendar.getInstance().getTimeInMillis() - startTime));
    }

    @SuppressWarnings("unused")
    @Test
    public void testQueue() {
        long startTime = Calendar.getInstance().getTimeInMillis();

        // 老款遍歷的方法
        for (int i = 0; i < queue.size(); i++) {
            String str = list.get(i);
        }

        // 迭代遍歷
        Iterator<String> iterator = queue.iterator();
        while (iterator.hasNext()) {
            String str = iterator.next();
        }

        // 迭代遍歷的for方式；或者相對while循環而言，能夠避免變量名錯誤
        for (Iterator<String> iter = queue.iterator(); iter.hasNext();) {
            String str = iter.next().toString();
        }
        
        // foreach遍歷：JDK1.5之后的方法
        for (String str : queue) {
            // 直接用了
        }

        System.out.println("遍歷queue各種方式總耗時：" + (Calendar.getInstance().getTimeInMillis() - startTime));
    }

    @SuppressWarnings("unused")
    @Test
    public void testMap() {
        long startTime = 0;
        
        // Entry方式的迭代遍歷（Entry方式遍歷時間短）
        startTime = Calendar.getInstance().getTimeInMillis();
        Iterator<Map.Entry<String, String>> iter1 = map.entrySet().iterator();
        while(iter1.hasNext()) {
            Map.Entry<String, String> entry = (Map.Entry<String, String>) iter1.next();
            
            String key = (String)entry.getKey();
            String value = (String)entry.getValue();
        }
        System.out.println("Map之Entry方式遍歷耗時：" + (Calendar.getInstance().getTimeInMillis() - startTime));

        // Entry方式的foreach遍歷，簡單多了是不是，速度還賊快
        for (Map.Entry<String, String> entry : map.entrySet()) {
            String key = entry.getKey();
            String value = entry.getValue();
        }

        // keySet方式的迭代遍歷（keySet方式遍歷耗時多）
        startTime = Calendar.getInstance().getTimeInMillis();
        Iterator<String> iter2 = map.keySet().iterator();
        while (iter2.hasNext()) {
            String key = (String)iter2.next();
            String value = (String)map.get(key);
        }
        System.out.println("Map之keySet方式遍歷耗時：" + (Calendar.getInstance().getTimeInMillis() - startTime));
        
        // keySet方式的foreach遍歷，更簡單，但速度慢
        for(String key: map.keySet()) {
            String value = (String)map.get(key);
        }
    }
}

輸出：

遍歷set各種方式總耗時：31
遍歷list各種方式總耗時：47
遍歷queue各種方式總耗時：47
遍歷array各種方式總耗時：0
Map之Entry方式遍歷耗時：15
Map之keySet方式遍歷耗時：31

3. 總結

 1.遍歷數組速度最快；
 2.Map在Entry方式與keySet方式遍歷時，耗時有着非常大的區別，原因應該是keySet方式遍歷時再次調用map.get(key)方法造成的，當數據量大時，需要特別考慮。