Collection总结：
关于集合中比较重要的HashSet，HashMap，HashTable，ArrayList，LinkedList，Vector的区别和用法，
这些概念很容易混淆，内部的原理也不是了解的特别深入。
java面试的过程中常考类型，也是我们平时堆代码时要特别注意的地方。



1./**

2.      * HashSet：底层是用哈希算法实现的，里面没有重复的元素

3.     * Map中的元素是“键－值”对，其中“键”必须是唯一的，它把set中的元素作为Map中的“键”，从而保持元素的唯一性。

4.     * HashSet中是采用了比较元素hashCode的方法来判断元素是否相同（duplicate），而不是采用其他类似equals之类的东东来判断

5.     */

6.     public void setTest() {

7.         HashSet<String> set=new HashSet<String>();

8.         set.add("abc");

9.         set.add("abc");

10.         System.out.println(set);

11.         for(Iterator<String> it=set.iterator();it.hasNext();) {

12.             System.out.println(it.next());

13.         }

14.     }

15.     

16.     /**

17.      * 轻量级，线程不安全，键和值都可以为空。

18.     */

19.     public void mapTest() {

20.         HashMap<String, String> map=new HashMap<>();

21.         map.put("a", "1");

22.         map.put("b", "2");

23.         map.put(null, null);

24.         for(Entry<String, String> entry:map.entrySet()) {

25.             System.out.println(entry.getKey()+entry.getValue());

26.         }

27.         

28.         for(Object obj:map.keySet()) {

29.             Object value=map.get(obj);

30.             System.out.println(value);

31.         }

32.     }

33.     

34.     /**

35.      * 重量级，线程安全，键和值不能为空，如果传入的键或值为空的话，就会报空指针异常。

36.     */

37.     public void tableTest() {

38.         Hashtable<String, String> table=new Hashtable<>();

39.         table.put("c", "3");

40.         table.put("d", "4");

41.//        table.put(null, null);

42.         Enumeration<String> en=table.keys();

43.         while(en.hasMoreElements()) {

44.             System.out.println(en.nextElement());

45.         }

46.         en=table.elements();

47.         while(en.hasMoreElements()) {

48.             System.out.println(en.nextElement());

49.         }

50.     }

51.     

52.     /**

53.      * ArrayList:底层是用数组实现的，查询快，增删慢，线程不安全，轻量级。

54.     */

55.     public void arrayTest() {

56.         ArrayList<String> arrays=new ArrayList<>();

57.         arrays.add("liuliu");

58.         arrays.add("fanfan");

59.         arrays.add(0, "mige");

60.         for (Iterator<String> iterator = arrays.iterator(); iterator.hasNext();) {

61.             String arr = (String) iterator.next();

62.             System.out.println(arr);

63.         }

64.     }

65.     

66.     /**

67.      * LinkedList:底层用双向循环链表，查询慢，增删效率快

68.     */

69.     public void linkedTest() {

70.         LinkedList<String> linked=new LinkedList<>();

71.         linked.add("zt");

72.         linked.add("taotao");

73.         linked.add(0, "zhuzhu");

74.         for (String lin : linked) {

75.             System.out.println(lin);

76.         }

77.     }

78.     

79.     /**

80.      * Vector:重量级，线程安全，底层用数组实现，占据更多的系统开销，如果涉及到多线程，可以选用这个

81.     */

82.     public void vetorTest() {

83.         Vector<String> vector=new Vector<>();

84.         vector.add("qin");

85.         vector.add("ai");

86.         vector.add(0, null);

87.         for (String ve : vector) {

88.             System.out.println(ve);

89.         }

90.     }

谢谢分享