Java中什么集合查询最快

上一篇文章中，我们了解了ArrayList的的遍历速度比LinkedList快7000多倍。

下面我们看一下什么结合中查询对象最快。呵呵

代码如下：

1. package dbtransfer;
3. import java.util.ArrayList;
4. import java.util.LinkedList;
5. import java.util.Random;
6. import java.util.HashMap;
7. import java.util.HashSet;
9. public class ListTest {
10.     private static Random random = new Random();
11.     public static void main(String[] args){
12.         ArrayList<String> arraylist = new ArrayList();
13.         LinkedList<String> linkedlist = new LinkedList();
14.         HashMap<String,Object> map = new HashMap();
15.         HashSet<String> set = new HashSet();
16.         for(int i=0;i<50000;i++){
17.             String r = randomString();
18.             arraylist.add(r);
19.             linkedlist.add(r);
20.             map.put(r, r);
21.             set.add(r);
22.         }
23.         
24.         System.out.println("arraylist size "+arraylist.size());
25.         System.out.println("linkedlist size "+linkedlist.size());
26.         System.out.println("map size "+map.size());
27.         System.out.println("set size "+set.size());
28.         
29.         
30.         System.out.println("------");
31.         long begin = System.currentTimeMillis();
32.         for(int j=0;j<arraylist.size();j++){
33.             arraylist.contains(arraylist.get(j));
34.         }
35.         System.out.println("arraylist time "+(System.currentTimeMillis()-begin));
36.         
37.         
38.         begin = System.currentTimeMillis();
39.         for(int j=0;j<arraylist.size();j++){
40.             linkedlist.contains(arraylist.get(j));
41.         }
42.         System.out.println("linkedlist time "+(System.currentTimeMillis()-begin));
43.         
44.         begin = System.currentTimeMillis();
45.         for(int i=0;i<100;i++){
46.             for(int j=0;j<arraylist.size();j++){
47.                 map.containsKey(arraylist.get(j));
48.             }
49.         }
50.         System.out.println("map time "+(System.currentTimeMillis()-begin));
51.         
52.         begin = System.currentTimeMillis();
53.         for(int i=0;i<100;i++){
54.             for(int j=0;j<arraylist.size();j++){
55.                 set.contains(arraylist.get(j));
56.             }
57.         }
58.         System.out.println("set time "+(System.currentTimeMillis()-begin));
59.         
60.     }
61.     protected static String randomString() {
62.         return Long.toString(random.nextLong(), 36);
63.     }
64. }

在我的机器上，结果如下：

arraylist size 50000

linkedlist size 50000

map size 50000

set size 50000

------

arraylist time 49328

linkedlist time 57641

map time 625

set time 578

可见呀，如果是在集合中查询某个对象是否存在，是HashSet的速度最快，而且比List快将近1万倍。

再次证明了：Java集合不可以乱用呀！