ArrayList、LinkedList、Vector、HashSet、Treeset、HashMap、TreeMap的区别和适用场景

ArrayList与LinkedList的区别和适用场景

Arraylist：

优点：ArrayList是实现了基于动态数组的数据结构,因为地址连续，一旦数据存储好了，查询操作效率会比较高（在内存里是连着放的）。

缺点：因为地址连续， ArrayList要移动数据,所以插入和删除操作效率比较低。   

LinkedList：

优点：LinkedList基于链表的数据结构,地址是任意的，所以在开辟内存空间的时候不需要等一个连续的地址，对于新增和删除操作add和remove，LinedList比较占优势。

缺点：因为LinkedList要移动指针,所以查询操作性能比较低。

适用场景分析：

 

当需要对数据进行对此访问的情况下选用ArrayList，当需要对数据进行多次增加删除修改时采用LinkedList。

 

ArrayList与Vector的区别和适用场景

ArrayList有三个构造方法：

 

Java代码  

1. public ArrayList(int initialCapacity)//构造一个具有指定初始容量的空列表。    
2. public ArrayList()//构造一个初始容量为10的空列表。    
3. public ArrayList(Collectionextends E> c)//构造一个包含指定 collection 的元素的列表   

 Vector有四个构造方法：

 

Java代码  

1. public Vector()//使用指定的初始容量和等于零的容量增量构造一个空向量。    
2. public Vector(int initialCapacity)//构造一个空向量，使其内部数据数组的大小，其标准容量增量为零。    
3. public Vector(Collectionextends E> c)//构造一个包含指定 collection 中的元素的向量    
4. public Vector(int initialCapacity,int capacityIncrement)//使用指定的初始容量和容量增量构造一个空的向量    

ArrayList和Vector都是用数组实现的，主要有这么三个区别：

 

 

1.Vector是多线程安全的，而ArrayList不是，这个可以从源码中看出，Vector类中的方法很多有synchronized进行修饰，这样就导致了Vector在效率上无法与ArrayList相比；

 

2.两个都是采用的线性连续空间存储元素，但是当空间不足的时候，两个类的增加方式是不同。

 

3.Vector可以设置增长因子，而ArrayList不可以。

 

适用场景分析：

1.Vector是线程同步的，所以它也是线程安全的，而ArrayList是线程异步的，是不安全的。如果不考虑到线程的安全因素，一般用ArrayList效率比较高。
2.如果集合中的元素的数目大于目前集合数组的长度时，在集合中使用数据量比较大的数据，用Vector有一定的优势。

HashSet与Treeset的适用场景

1.TreeSet 是二差树实现的,Treeset中的数据是自动排好序的，不允许放入null值 

2.HashSet 是哈希表实现的,HashSet中的数据是无序的，可以放入null，但只能放入一个null，两者中的值都不能重复，就如数据库中唯一约束 

3.HashSet要求放入的对象必须实现HashCode()方法，放入的对象，是以hashcode码作为标识的，而具有相同内容的String对象，hashcode是一样，所以放入的内容不能重复。但是同一个类的对象可以放入不同的实例

 

 

   适用场景分析:HashSet是基于Hash算法实现的，其性能通常都优于TreeSet。我们通常都应该使用HashSet，在我们需要排序的功能时，我们才使用TreeSet。

 

HashMap与TreeMap的适用场景

 

HashMap 非线程安全  

HashMap：基于哈希表实现。使用HashMap要求添加的键类明确定义了hashCode()和equals()[可以重写hashCode()和equals()]，为了优化HashMap空间的使用，您可以调优初始容量和负载因子。 

 

(1)HashMap(): 构建一个空的哈希映像 
(2)HashMap(Map m): 构建一个哈希映像，并且添加映像m的所有映射 
(3)HashMap(int initialCapacity): 构建一个拥有特定容量的空的哈希映像 
(4)HashMap(int initialCapacity, float loadFactor): 构建一个拥有特定容量和加载因子的空的哈希映像 
TreeMap：非线程安全基于红黑树实现。TreeMap没有调优选项，因为该树总处于平衡状态。 

(1)TreeMap():构建一个空的映像树 
(2)TreeMap(Map m): 构建一个映像树，并且添加映像m中所有元素 
(3)TreeMap(Comparator c): 构建一个映像树，并且使用特定的比较器对关键字进行排序 
(4)TreeMap(SortedMap s): 构建一个映像树，添加映像树s中所有映射，并且使用与有序映像s相同的比较器排序 

适用场景分析：

 

HashMap：适用于在Map中插入、删除和定位元素。 
Treemap：适用于按自然顺序或自定义顺序遍历键(key)。 

测试代码如下（部分代码来源于teye博客及论坛）

 

Java代码  

1.    
2. import java.util.HashMap;   
3. import java.util.Hashtable;   
4. import java.util.Iterator;   
5. import java.util.Map;   
6. import java.util.TreeMap;   
7. public class HashMaps {   
8. public static void main(String[] args) {   
9. Map map = new HashMap();   
10. map.put("a", "aaa");   
11. map.put("b", "bbb");   
12. map.put("c", "ccc");   
13. map.put("d", "ddd");   
14. Iterator iterator = map.keySet().iterator();   
15. while (iterator.hasNext()) {   
16. Object key = iterator.next();   
17. System.out.println("map.get(key) is :" + map.get(key));   
18. }   
19. // 定义HashTable,用来测试   
20. Hashtable tab = new Hashtable();   
21. tab.put("a", "aaa");   
22. tab.put("b", "bbb");   
23. tab.put("c", "ccc");   
24. tab.put("d", "ddd");   
25. Iterator iterator_1 = tab.keySet().iterator();   
26. while (iterator_1.hasNext()) {   
27. Object key = iterator_1.next();   
28. System.out.println("tab.get(key) is :" + tab.get(key));   
29. }   
30. TreeMap tmp = new TreeMap();   
31. tmp.put("a", "aaa");   
32. tmp.put("b", "bbb");   
33. tmp.put("c", "ccc");   
34. tmp.put("d", "cdc");   
35. Iterator iterator_2 = tmp.keySet().iterator();   
36. while (iterator_2.hasNext()) {   
37. Object key = iterator_2.next();   
38. System.out.println("tmp.get(key) is :" + tmp.get(key));   
39. }   
40. }   
41. }   
42.   

 运行结果如下： 

 

map.get(key) is :ddd 
map.get(key) is :bbb 
map.get(key) is :ccc 
map.get(key) is :aaa 
tab.get(key) is :bbb 
tab.get(key) is :aaa 
tab.get(key) is :ddd 
tab.get(key) is :ccc 
tmp.get(key) is :aaa 
tmp.get(key) is :bbb 
tmp.get(key) is :ccc 
tmp.get(key) is :cdc 
HashMap的结果是没有排序的，而TreeMap输出的结果是排好序的。 
下面就要进入本文的主题了。先举个例子说明一下怎样使用HashMap: 

 

Java代码  

1.    
2. import java.util.*;   
3. public class Exp1 {   
4. public static void main(String[] args){   
5. HashMap h1=new HashMap();   
6. Random r1=new Random();   
7. for (int i=0;i<1000;i++){   
8. Integer t=new Integer(r1.nextInt(20));   
9. if (h1.containsKey(t))   
10. ((Ctime)h1.get(t)).count++;   
11. else   
12. h1.put(t, new Ctime());   
13. }   
14. System.out.println(h1);   
15. }   
16. }   
17. class Ctime{   
18. int count=1;   
19. public String toString(){   
20. return Integer.toString(count);   
21. }   
22. }   

 在HashMap中通过get()来获取value，通过put()来插入value，ContainsKey()则用来检验对象是否已经存在。可以看出，和ArrayList的操作相比，HashMap除了通过key索引其内容之外，别的方面差异并不大。 

 

前面介绍了，HashMap是基于HashCode的，在所有对象的超类Object中有一个HashCode()方法，但是它和equals方法一样，并不能适用于所有的情况，这样我们就需要重写自己的HashCode()方法。下面就举这样一个例子： 

 

Java代码  

1.    
2. import java.util.*;   
3. public class Exp2 {   
4. public static void main(String[] args){   
5. HashMap h2=new HashMap();   
6. for (int i=0;i<10;i++)   
7. h2.put(new Element(i), new Figureout());   
8. System.out.println("h2:");   
9. System.out.println("Get the result for Element:");   
10. Element test=new Element(5);   
11. if (h2.containsKey(test))   
12. System.out.println((Figureout)h2.get(test));   
13. else   
14. System.out.println("Not found");   
15. }   
16. }   
17. class Element{   
18. int number;   
19. public Element(int n){   
20. number=n;   
21. }   
22. }   
23. class Figureout{   
24. Random r=new Random();   
25. boolean possible=r.nextDouble()>0.5;   
26. public String toString(){   
27. if (possible)   
28. return "OK!";   
29. else   
30. return "Impossible!";   
31. }   
32. }   

 在这个例子中，Element用来索引对象Figureout,也即Element为key，Figureout为value。在Figureout中随机生成一个浮点数，如果它比0.5大，打印"OK!"，否则打印"Impossible!"。之后查看Element(3)对应的Figureout结果如何。 

 

结果却发现，无论你运行多少次，得到的结果都是"Not found"。也就是说索引Element(3)并不在HashMap中。这怎么可能呢？ 
原因得慢慢来说：Element的HashCode方法继承自Object，而Object中的HashCode方法返回的HashCode对应于当前的地址，也就是说对于不同的对象，即使它们的内容完全相同，用HashCode（）返回的值也会不同。这样实际上违背了我们的意图。因为我们在使用 HashMap时，希望利用相同内容的对象索引得到相同的目标对象，这就需要HashCode()在此时能够返回相同的值。在上面的例子中，我们期望 new Element(i) (i=5)与 Elementtest=newElement(5)是相同的，而实际上这是两个不同的对象，尽管它们的内容相同，但它们在内存中的地址不同。因此很自然的，上面的程序得不到我们设想的结果。下面对Element类更改如下：

 

Java代码  

1.    
2. class Element{   
3. int number;   
4. public Element(int n){   
5. number=n;   
6. }   
7. public int hashCode(){   
8. return number;   
9. }   
10. public boolean equals(Object o){   
11. return (o instanceof Element) && (number==((Element)o).number);   
12. }   
13. }   

 在这里Element覆盖了Object中的hashCode()和equals()方法。覆盖hashCode()使其以number的值作为 hashcode返回，这样对于相同内容的对象来说它们的hashcode也就相同了。而覆盖equals()是为了在HashMap判断两个key是否相等时使结果有意义修改后的程序运行结果如下： 

 

h2: 
Get the result for Element: 
Impossible! 
请记住：如果你想有效的使用HashMap，你就必须重写在其的HashCode()。 
还有两条重写HashCode()的原则： 
[list=1] 
不必对每个不同的对象都产生一个唯一的hashcode，只要你的HashCode方法使get()能够得到put()放进去的内容就可以了。即"不为一原则"。 

生成hashcode的算法尽量使hashcode的值分散一些，不要很多hashcode都集中在一个范围内，这样有利于提高HashMap的性能。即"分散原则"。至于第二条原则的具体原因，有兴趣者可以参考Bruce Eckel的《Thinking in Java》，在那里有对HashMap内部实现原理的介绍，这里就不赘述了。 
掌握了这两条原则，你就能够用好HashMap编写自己的程序了。不知道大家注意没有，java.lang.Object中提供的三个方法：clone()，equals()和hashCode()虽然很典型，但在很多情况下都不能够适用，它们只是简单的由对象的地址得出结果。这就需要我们在自己的程序中重写它们，其实java类库中也重写了千千万万个这样的方法。利用面向对象的多态性——覆盖，Java的设计者很优雅的构建了Java的结构，也更加体现了Java是一门纯OOP语言的特性。

细节注意：

时间测试方法：System.currentTimeMillis()

遍历方法：Iterator迭代器

超级for

TreeSet xx = new TreeSet();

         for(Object obj:xx){

         System.out.println(obj);

         }

 

 

Java中的泛型：泛型是程序设计语言的一种特性。允许程序员在强类型程序设计语言中编写代码时定义一些可变部分，那些部分在使用前必须作出指明。

Java 泛型的参数只可以代表类，不能代表个别对象。由于 Java 泛型的类型参数之实际类型在编译时会被消除，所以无法在运行时得知其类型参数的类型。Java 编译器在编译泛型时会自动加入类型转换的编码，故运行速度不会因为使用泛型而加快。

ArrayList与LinkedList的区别和适用场景

Arraylist：

优点：ArrayList是实现了基于动态数组的数据结构,因为地址连续，一旦数据存储好了，查询操作效率会比较高（在内存里是连着放的）。

缺点：因为地址连续， ArrayList要移动数据,所以插入和删除操作效率比较低。   

LinkedList：

优点：LinkedList基于链表的数据结构,地址是任意的，所以在开辟内存空间的时候不需要等一个连续的地址，对于新增和删除操作add和remove，LinedList比较占优势。

缺点：因为LinkedList要移动指针,所以查询操作性能比较低。

适用场景分析：

 

当需要对数据进行对此访问的情况下选用ArrayList，当需要对数据进行多次增加删除修改时采用LinkedList。

 

ArrayList与Vector的区别和适用场景

ArrayList有三个构造方法：

 

Java代码  

1. public ArrayList(int initialCapacity)//构造一个具有指定初始容量的空列表。    
2. public ArrayList()//构造一个初始容量为10的空列表。    
3. public ArrayList(Collectionextends E> c)//构造一个包含指定 collection 的元素的列表   

 Vector有四个构造方法：

 

Java代码  

1. public Vector()//使用指定的初始容量和等于零的容量增量构造一个空向量。    
2. public Vector(int initialCapacity)//构造一个空向量，使其内部数据数组的大小，其标准容量增量为零。    
3. public Vector(Collectionextends E> c)//构造一个包含指定 collection 中的元素的向量    
4. public Vector(int initialCapacity,int capacityIncrement)//使用指定的初始容量和容量增量构造一个空的向量    

ArrayList和Vector都是用数组实现的，主要有这么三个区别：

 

 

1.Vector是多线程安全的，而ArrayList不是，这个可以从源码中看出，Vector类中的方法很多有synchronized进行修饰，这样就导致了Vector在效率上无法与ArrayList相比；

 

2.两个都是采用的线性连续空间存储元素，但是当空间不足的时候，两个类的增加方式是不同。

 

3.Vector可以设置增长因子，而ArrayList不可以。

 

适用场景分析：

1.Vector是线程同步的，所以它也是线程安全的，而ArrayList是线程异步的，是不安全的。如果不考虑到线程的安全因素，一般用ArrayList效率比较高。
2.如果集合中的元素的数目大于目前集合数组的长度时，在集合中使用数据量比较大的数据，用Vector有一定的优势。

HashSet与Treeset的适用场景

1.TreeSet 是二差树实现的,Treeset中的数据是自动排好序的，不允许放入null值 

2.HashSet 是哈希表实现的,HashSet中的数据是无序的，可以放入null，但只能放入一个null，两者中的值都不能重复，就如数据库中唯一约束 

3.HashSet要求放入的对象必须实现HashCode()方法，放入的对象，是以hashcode码作为标识的，而具有相同内容的String对象，hashcode是一样，所以放入的内容不能重复。但是同一个类的对象可以放入不同的实例

 

 

   适用场景分析:HashSet是基于Hash算法实现的，其性能通常都优于TreeSet。我们通常都应该使用HashSet，在我们需要排序的功能时，我们才使用TreeSet。

 

HashMap与TreeMap的适用场景

 

HashMap 非线程安全  

HashMap：基于哈希表实现。使用HashMap要求添加的键类明确定义了hashCode()和equals()[可以重写hashCode()和equals()]，为了优化HashMap空间的使用，您可以调优初始容量和负载因子。 

 

(1)HashMap(): 构建一个空的哈希映像 
(2)HashMap(Map m): 构建一个哈希映像，并且添加映像m的所有映射 
(3)HashMap(int initialCapacity): 构建一个拥有特定容量的空的哈希映像 
(4)HashMap(int initialCapacity, float loadFactor): 构建一个拥有特定容量和加载因子的空的哈希映像 
TreeMap：非线程安全基于红黑树实现。TreeMap没有调优选项，因为该树总处于平衡状态。 

(1)TreeMap():构建一个空的映像树 
(2)TreeMap(Map m): 构建一个映像树，并且添加映像m中所有元素 
(3)TreeMap(Comparator c): 构建一个映像树，并且使用特定的比较器对关键字进行排序 
(4)TreeMap(SortedMap s): 构建一个映像树，添加映像树s中所有映射，并且使用与有序映像s相同的比较器排序 

适用场景分析：

 

HashMap：适用于在Map中插入、删除和定位元素。 
Treemap：适用于按自然顺序或自定义顺序遍历键(key)。 

测试代码如下（部分代码来源于teye博客及论坛）

 

Java代码  

1.    
2. import java.util.HashMap;   
3. import java.util.Hashtable;   
4. import java.util.Iterator;   
5. import java.util.Map;   
6. import java.util.TreeMap;   
7. public class HashMaps {   
8. public static void main(String[] args) {   
9. Map map = new HashMap();   
10. map.put("a", "aaa");   
11. map.put("b", "bbb");   
12. map.put("c", "ccc");   
13. map.put("d", "ddd");   
14. Iterator iterator = map.keySet().iterator();   
15. while (iterator.hasNext()) {   
16. Object key = iterator.next();   
17. System.out.println("map.get(key) is :" + map.get(key));   
18. }   
19. // 定义HashTable,用来测试   
20. Hashtable tab = new Hashtable();   
21. tab.put("a", "aaa");   
22. tab.put("b", "bbb");   
23. tab.put("c", "ccc");   
24. tab.put("d", "ddd");   
25. Iterator iterator_1 = tab.keySet().iterator();   
26. while (iterator_1.hasNext()) {   
27. Object key = iterator_1.next();   
28. System.out.println("tab.get(key) is :" + tab.get(key));   
29. }   
30. TreeMap tmp = new TreeMap();   
31. tmp.put("a", "aaa");   
32. tmp.put("b", "bbb");   
33. tmp.put("c", "ccc");   
34. tmp.put("d", "cdc");   
35. Iterator iterator_2 = tmp.keySet().iterator();   
36. while (iterator_2.hasNext()) {   
37. Object key = iterator_2.next();   
38. System.out.println("tmp.get(key) is :" + tmp.get(key));   
39. }   
40. }   
41. }   
42.   

 运行结果如下： 

 

map.get(key) is :ddd 
map.get(key) is :bbb 
map.get(key) is :ccc 
map.get(key) is :aaa 
tab.get(key) is :bbb 
tab.get(key) is :aaa 
tab.get(key) is :ddd 
tab.get(key) is :ccc 
tmp.get(key) is :aaa 
tmp.get(key) is :bbb 
tmp.get(key) is :ccc 
tmp.get(key) is :cdc 
HashMap的结果是没有排序的，而TreeMap输出的结果是排好序的。 
下面就要进入本文的主题了。先举个例子说明一下怎样使用HashMap: 

 

Java代码  

1.    
2. import java.util.*;   
3. public class Exp1 {   
4. public static void main(String[] args){   
5. HashMap h1=new HashMap();   
6. Random r1=new Random();   
7. for (int i=0;i<1000;i++){   
8. Integer t=new Integer(r1.nextInt(20));   
9. if (h1.containsKey(t))   
10. ((Ctime)h1.get(t)).count++;   
11. else   
12. h1.put(t, new Ctime());   
13. }   
14. System.out.println(h1);   
15. }   
16. }   
17. class Ctime{   
18. int count=1;   
19. public String toString(){   
20. return Integer.toString(count);   
21. }   
22. }   

 在HashMap中通过get()来获取value，通过put()来插入value，ContainsKey()则用来检验对象是否已经存在。可以看出，和ArrayList的操作相比，HashMap除了通过key索引其内容之外，别的方面差异并不大。 

 

前面介绍了，HashMap是基于HashCode的，在所有对象的超类Object中有一个HashCode()方法，但是它和equals方法一样，并不能适用于所有的情况，这样我们就需要重写自己的HashCode()方法。下面就举这样一个例子： 

 

Java代码  

1.    
2. import java.util.*;   
3. public class Exp2 {   
4. public static void main(String[] args){   
5. HashMap h2=new HashMap();   
6. for (int i=0;i<10;i++)   
7. h2.put(new Element(i), new Figureout());   
8. System.out.println("h2:");   
9. System.out.println("Get the result for Element:");   
10. Element test=new Element(5);   
11. if (h2.containsKey(test))   
12. System.out.println((Figureout)h2.get(test));   
13. else   
14. System.out.println("Not found");   
15. }   
16. }   
17. class Element{   
18. int number;   
19. public Element(int n){   
20. number=n;   
21. }   
22. }   
23. class Figureout{   
24. Random r=new Random();   
25. boolean possible=r.nextDouble()>0.5;   
26. public String toString(){   
27. if (possible)   
28. return "OK!";   
29. else   
30. return "Impossible!";   
31. }   
32. }   

 在这个例子中，Element用来索引对象Figureout,也即Element为key，Figureout为value。在Figureout中随机生成一个浮点数，如果它比0.5大，打印"OK!"，否则打印"Impossible!"。之后查看Element(3)对应的Figureout结果如何。 

 

结果却发现，无论你运行多少次，得到的结果都是"Not found"。也就是说索引Element(3)并不在HashMap中。这怎么可能呢？ 
原因得慢慢来说：Element的HashCode方法继承自Object，而Object中的HashCode方法返回的HashCode对应于当前的地址，也就是说对于不同的对象，即使它们的内容完全相同，用HashCode（）返回的值也会不同。这样实际上违背了我们的意图。因为我们在使用 HashMap时，希望利用相同内容的对象索引得到相同的目标对象，这就需要HashCode()在此时能够返回相同的值。在上面的例子中，我们期望 new Element(i) (i=5)与 Elementtest=newElement(5)是相同的，而实际上这是两个不同的对象，尽管它们的内容相同，但它们在内存中的地址不同。因此很自然的，上面的程序得不到我们设想的结果。下面对Element类更改如下：

 

Java代码  

1.    
2. class Element{   
3. int number;   
4. public Element(int n){   
5. number=n;   
6. }   
7. public int hashCode(){   
8. return number;   
9. }   
10. public boolean equals(Object o){   
11. return (o instanceof Element) && (number==((Element)o).number);   
12. }   
13. }   

 在这里Element覆盖了Object中的hashCode()和equals()方法。覆盖hashCode()使其以number的值作为 hashcode返回，这样对于相同内容的对象来说它们的hashcode也就相同了。而覆盖equals()是为了在HashMap判断两个key是否相等时使结果有意义修改后的程序运行结果如下： 

 

h2: 
Get the result for Element: 
Impossible! 
请记住：如果你想有效的使用HashMap，你就必须重写在其的HashCode()。 
还有两条重写HashCode()的原则： 
[list=1] 
不必对每个不同的对象都产生一个唯一的hashcode，只要你的HashCode方法使get()能够得到put()放进去的内容就可以了。即"不为一原则"。 

生成hashcode的算法尽量使hashcode的值分散一些，不要很多hashcode都集中在一个范围内，这样有利于提高HashMap的性能。即"分散原则"。至于第二条原则的具体原因，有兴趣者可以参考Bruce Eckel的《Thinking in Java》，在那里有对HashMap内部实现原理的介绍，这里就不赘述了。 
掌握了这两条原则，你就能够用好HashMap编写自己的程序了。不知道大家注意没有，java.lang.Object中提供的三个方法：clone()，equals()和hashCode()虽然很典型，但在很多情况下都不能够适用，它们只是简单的由对象的地址得出结果。这就需要我们在自己的程序中重写它们，其实java类库中也重写了千千万万个这样的方法。利用面向对象的多态性——覆盖，Java的设计者很优雅的构建了Java的结构，也更加体现了Java是一门纯OOP语言的特性。

细节注意：

时间测试方法：System.currentTimeMillis()

遍历方法：Iterator迭代器

超级for

TreeSet xx = new TreeSet();

         for(Object obj:xx){

         System.out.println(obj);

         }

 

 

Java中的泛型：泛型是程序设计语言的一种特性。允许程序员在强类型程序设计语言中编写代码时定义一些可变部分，那些部分在使用前必须作出指明。

Java 泛型的参数只可以代表类，不能代表个别对象。由于 Java 泛型的类型参数之实际类型在编译时会被消除，所以无法在运行时得知其类型参数的类型。Java 编译器在编译泛型时会自动加入类型转换的编码，故运行速度不会因为使用泛型而加快。