java集合精解

面试常见问题
 ArrayList和LinkedList的联系和区别

                 1. ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。
                 2. 对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。 
                 3. 对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据
        Vector和ArrayList的联系和区别 

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

                 2、两个都是采用的线性连续空间存储元素，但是当空间不足的时候，两个类的增加方式是不同的，很多网友说Vector增加原来空间的一倍，ArrayList增加原来空间的50%，其实也差不多是这个意思，不过还有一点点问题可以从源码中看出，一会儿从源码中分析。

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

在说集合前我们不得不说一下数组
数组的作用：存放一组相同的数据类型(基本或对象)的数据，从而实现对数据的管理
优势：可以快速的通过下标对数组元素进行访问，效率高
劣势：容量实现定义好了，不能随着需求变化而扩容
因此出现了更好的集合框架
一、数组和集合的比较
数组不是面向对象的，存在明显的缺陷，集合弥补了数组的缺点，比数组更灵活更实用，而且不同的集合框架类可适用不同场合。如下：
·1：数组能存放基本数据类型和对象，而集合类存放的都是对象的引用，而非对象本身！
·2：数组容易固定无法动态改变，集合类容量动态改变。 
·3：数组无法判断其中实际存有多少元素，length只告诉了数组的容量，而集合的size()可以确切知道元素的个数 
·4：集合有多种实现方式和不同适用场合，不像数组仅采用顺序表方式 
·5：集合以类的形式存在，具有封装、继承、多态等类的特性，通过简单的方法和属性即可实现各种复杂操作，大大提高了软件的开发效率
二、java集合主要由两个接口派生：Collection和Map，是集合框架的根接口。
collection的子接口：Set:接口 ---实现类： HashSet、LinkedHashSet
   set的子接口SortedSet接口---实现类：TreeSet
  List:接口---实现类： LinkedList,Vector,ArrayList 


List:有序列表，允许存放重复的元素； 
实现类： 
ArrayList：数组实现，查询快，增删慢，轻量级；(线程不安全)
LinkedList：双向链表实现，增删快，查询慢 (线程不安全)
Vector：数组实现，重量级  (线程安全、使用少)


Set:无序集合，不允许存放重复的元素；允许使用null元素
HashSet 的后台有一个HashMap;初始化后台容量；只不过生成一个HashSet的话，系统只提供key的访问； 如果有两个Key重复，那么会覆盖之前的； 
实现类 
HashSet：equals返回true，hashCode返回相同的整数；哈希表；存储的数据是无序的。
LinkedHashSet：此实现与 HashSet 的不同之外在于，后者维护着一个运行于所有条目的双重链接列表。存储的数据是有序的。
哈希表详解http://www.bianceng.cn/Programming/sjjg/200705/1126.htm 
http://blog.csdn.net/feixiaoxing/article/details/6885657
http://blog.csdn.net/jdh99/article/details/8490704


子接口SortedSet,对Set排序实现类 :TreeSet：使用元素的自然顺序对元素进行排序，或者根据创建 set 时提供的 Comparator 进行排序；二叉树实现的； 
二叉树详解：http://blog.csdn.net/luckyxiaoqiang/article/details/7518888/
http://blog.csdn.net/pony_maggie/article/details/38390513


Map的实现类：HashMap、TreeMap、LinkedHashMap、Hashtable等
HashMap：键值对，key不能重复，但是value可以重复；key的实现就是HashSet；value对应着放；允许null的键或值；
Hashtable：线程安全的，不允许null的键或值；
Properties:：key和value都是String类型，用来读配置文件；
TreeMap：对key排好序的Map; key 就是TreeSet, value对应每个key; key要实现Comparable接口或TreeMap有自己的构造器； 
LinkedHashMap： 此实现与 HashMap 的不同之处在于，后者维护着一个运行于所有条目的双重链接列表。存储的数
据是有序的。

接口

简述

实现

操作特性

成员要求

Set

成员不能重复

HashSet

外部无序地遍历成员

成员可为任意Object子类的对象，但如果覆盖了equals方法，同时注意修改hashCode方法。

TreeSet

外部有序地遍历成员；附加实现了SortedSet, 支持子集等要求顺序的操作

成员要求实现caparable接口，或者使用 Comparator构造TreeSet。成员一般为同一类型。

LinkedHashSet

外部按成员的插入顺序遍历成员

成员与HashSet成员类似

List

提供基于索引的对成员的随机访问

ArrayList

提供快速的基于索引的成员访问，对尾部成员的增加和删除支持较好

成员可为任意Object子类的对象

LinkedList

对列表中任何位置的成员的增加和删除支持较好，但对基于索引的成员访问支持性能较差

成员可为任意Object子类的对象

Map

保存键值对成员，基于键找值操作，compareTo或compare方法对键排序

HashMap

能满足用户对Map的通用需求

键成员可为任意Object子类的对象，但如果覆盖了equals方法，同时注意修改hashCode方法。

TreeMap

支持对键有序地遍历，使用时建议先用HashMap增加和删除成员，最后从HashMap生成TreeMap；附加实现了SortedMap接口，支持子Map等要求顺序的操作

键成员要求实现caparable接口，或者使用Comparator构造TreeMap。键成员一般为同一类型。

LinkedHashMap

保留键的插入顺序，用equals 方法检查键和值的相等性

成员可为任意Object子类的对象，但如果覆盖了equals方法，同时注意修改hashCode方法。

IdentityHashMap

使用== 来检查键和值的相等性。

成员使用的是严格相等

WeakHashMap

其行为依赖于垃圾回收线程，没有绝对理由则少用

 

三、Collection常见方法
add(E e); addAll(Collection c);clear();contains(Obj o);返回是否包含指定的元素(true false) 


containsAll(Collection c)是否包含c中所有元素 isEmpty(); iterator();remove();size();toArray();返回


collection中所有元素的数组
四、集合的遍历
     1、增强for循环 for(Obj o:c){syso(o)}
     2、使用iterator ， Iterator it=c.iterator;
          while(it.hasNext()){Object o = it.next()}
     3、普通循环：for(Iterator it=c.iterator();it.hasNext();){it.next() }

五、代码实例

[java] view plain copy

print?

1.  1、 ArrayList  
2. import java.util.ArrayList;    
3.     
4. /**  
5.  *   
6.  * 关于ArrayList的基本操作   
7.  * 其它操作感兴趣的读者可以自己结合源码实现一下  
8.  *  * @author erqing  
9.  *   
10.  */    
11. public class ListTest {    
12.     
13.     public static void main(String[] args) {    
14.     
15.         /* 新建一个ArrayList */    
16.         ArrayList<String> list = new ArrayList<String>();    
17.         System.out.println("初始化大小:" + list.size());    
18.     
19.         /* 添加元素 */    
20.         list.add("zzz");    
21.         list.add("egg");    
22.         list.add("hell");    
23.         list.add("child");    
24.         System.out.println("当前容量:" + list.size());    
25.     
26.         /* 将ArrayList的大小和实际所含元素的大小设置一致 */    
27.         list.trimToSize();    
28.     
29.         /* 遍历 */    
30.         for (String string : list) {    
31.             System.out.println(string);    
32.         }    
33.     
34.         /* 在指定位置插入元素 */    
35.         list.add(2, "zhu");    
36.     
37.         for (String string : list) {    
38.             System.out.println(string);    
39.         }    
40.     
41.         System.out.println("--------------");    
42.     
43.         /* 清空list */    
44.         list.clear();    
45.     
46.         /* 遍历 */    
47.         for (String string : list) {    
48.             System.out.println(string);    
49.         }    
50.         System.out.println("--------------");    
51.     }    
52. }    
53.   2、LinkedList  
54. import java.util.LinkedList;    
55.     
56. public class LinkedListTest {    
57.         
58.     public static void main(String[] args) {    
59.     
60.         /* 新建一个list */    
61.         LinkedList<Integer> list = new LinkedList<Integer>();    
62.         System.out.println(list.size());    
63.     
64.         /* 向list中添加元素 */    
65.         list.add(222);    
66.         list.add(111);    
67.         list.add(0);    
68.         list.add(3333);    
69.         list.add(8888);    
70.             
71.         System.out.println(list.size());    
72.     
73.         /* 遍历list */    
74.         for (Integer integer : list) {    
75.             System.out.println(integer);    
76.         }    
77.     
78.         /* 获取第一个元素 ,即header的next域*/    
79.         System.out.println("第一个元素是:" + list.getFirst());    
80.             
81.         /*获取最后一个元素,即header的previous域*/    
82.         System.out.println("最后一个元素是:"+list.getLast());    
83.     }    
84. }    
85.   
86. 3、hashset  
87.     public static void main(String[] args) {  
88.         Set set = new HashSet();  
89.         set.add("a");  
90.         set.add("b");  
91.         System.out.println(set);  
92.         Student stu= new Student(18, "小名", 60);  
93.         set.add(stu);//调用第一个对象的hashcode方法  调  equals  
94.         set.add(new Student(19, "小明", 60));  
95.         set.add(new Student(19, "小明", 60));  
96.         set.add(new Student(20, "小明", 61));  
97.         System.out.println(set);  
98.     }  
99. 4、treeset  
100. import java.util.ArrayList;  
101. import java.util.HashSet;  
102. import java.util.TreeSet;  
103.   
104. /** 
105.  * 使用treeset存放一组学生成绩 
106.  *  1、可以自动排序(系统类  自然排序) 
107.  *  2、不可重复(去重) 
108.  *  3、只能存放一种数据类型 
109.  *  ---存放到 treeset中的元素必须要具有比较能力 
110.  *      调用compareTo() 如果得到的结果为0 ， 两个元素相等 
111.  *      1 ---》排到后面 
112.  *      -1 --->排到前面 
113.  *       
114.  *  hashset:-->hashtable(哈希表) 
115.  *  treeset:-->二叉树，红黑树算法 
116.  *  每存入一个元素就会调用一次compareTo方法 
117.  * @author Administrator 
118.  * 
119.  */  
120. import java.util.Comparator;  
121. /** 
122.  * 外部比较器，当系统类提供的比较规则满足不了需求时使用 
123.  *   1、自己创建一个比较器  实现  Comprator接口 ，添加一个泛型（需要比较的数据类型） 
124.  *   2、重写comprae方法,用来比较，参数是两个需要比较的对象 
125.  * @author Administrator 
126.  * 
127.  */  
128. public class MyStrCompartor implements Comparator<String>{  
129.   
130.     @Override  
131.     public int compare(String o1, String o2) {  
132.         //按照字符串长度排序  
133.           
134.         return o1.length() - o2.length();  
135.     }  
136.   
137. }  
138.   
139.   
140. public class TestTreeSet02 {  
141.   
142.     public static void main(String[] args) {  
143.         //使用外部比较器，  
144.         //1 拿到比较器的对象  
145.         MyStrCompartor mcom = new MyStrCompartor();  
146.         //2在创建集合时，调用有参的构造方法，把比较器传进去  
147.         //3、在treeset中添加元素时，会优先调用自定义比较器的方法  
148.         //treeset专用  
149.         TreeSet ts = new TreeSet(mcom);  
150. //      ts.add(20);//自动装箱  
151. //      ts.add(1);  
152. //      ts.add(100);  
153. //      ts.add(7);  
154. //      ts.add(8);  
155. //      ts.add(100);  
156.         System.out.println(ts);  
157.         //需求：不希望按照系统的排序来排列  
158.         //自己创建一个比较规则  
159.         ts.add("xiaomi32313");  
160.         ts.add("zhangliguo5");  
161.         ts.add("asima1");  
162.         ts.add("baibaibai4");  
163.         ts.add("sansan2");  
164. //      ts.add(new Student("yushen", 19, 19));  
165. //      ts.add(new Student("xiaoming", 19, 19));  
166. //      ts.add(new Student("axiaoming1", 19, 18));  
167.         System.out.println(ts);  
168.     }  
169.   
170. }  
171.   
172. 5、hashmap  
173. import java.util.HashMap;    
174. import java.util.Map;    
175. import java.util.Set;    
176.     
177. /**  
178.  * HashMap的使用  
179.  * @author erqing  
180.  *   
181.  */    
182. public class MapTest {    
183.     
184.     public static void main(String[] args) {    
185.     
186.         /* 初始化map */    
187.         Map<String, Integer> map = new HashMap<String, Integer>();    
188.         System.out.println("HashMap的初始值:" + map.size());    
189.         System.out.println("HashMap是否为空:" + (map.isEmpty() ? "是" : "否"));    
190.     
191.         /* 想map中添加元素 */    
192.         map.put("erqing", 1);    
193.         map.put("niuniu", 2);    
194.         map.put("egg", 3);    
195.         System.out.println(map.size());    
196.         ;    
197.         System.out.println("HashMap是否为空:" + (map.isEmpty() ? "是" : "否"));    
198.     
199.         /* 遍历HashMap中的元素 */    
200.         Set<String> set = map.keySet();    
201.         for (String s : set) {    
202.             System.out.println(s + " " + map.get(s) + " " + "hashcode:"    
203.                     + s.hashCode());    
204.         }    
205.     
206.         /*检测是否含有某个Key*/    
207.         System.out.println(map.containsKey("egg"));    
208.             
209.         /*检测是否含有某个Value*/    
210.         System.out.println(map.containsValue(2));    
211.             
212.         /*打印hashCode*/    
213.         System.out.println(map.hashCode());    
214.     }    
215. }    
216. /* 
217. 输出： 
218. HashMap的初始值:0 
219. HashMap是否为空:是 
220. 3 
221. HashMap是否为空:否 
222. niuniu 2 hashcode:-1045196352 
223. egg 3 hashcode:100357 
224. erqing 1 hashcode:-1294670850 
225. true 
226. true 
227. 1955200455 
228. */  
229.   
230. 6、treemap  
231. public static void main(String[] args) {    
232.             
233.         SortedMap<String, Integer> map = new TreeMap<String, Integer>();    
234.         map.put("zgg", 1);    
235.         map.put("erqing", 3);    
236.         map.put("niu", 0);    
237.         map.put("abc", 2);    
238.         map.put("aaa", 5);    
239. //  map.put(1004, new Student("04",18 ,1004));  
240. //  map.put(1005, new Student("05",18 ,1005));    也能存new  
241.         Set<String> keySet = map.keySet();    
242.         for (String string : keySet) {    
243.             System.out.print(map.get(string)+" ");    
244.         }    
245.     }    
246. //输出：5 2 3 0 1  

 1、 ArrayListimport java.util.ArrayList;    /**  *   * 关于ArrayList的基本操作   * 其它操作感兴趣的读者可以自己结合源码实现一下  *  * @author erqing  *   */  public class ListTest {        public static void main(String[] args) {            /* 新建一个ArrayList */          ArrayList<String> list = new ArrayList<String>();          System.out.println("初始化大小:" + list.size());            /* 添加元素 */          list.add("zzz");          list.add("egg");          list.add("hell");          list.add("child");          System.out.println("当前容量:" + list.size());            /* 将ArrayList的大小和实际所含元素的大小设置一致 */          list.trimToSize();            /* 遍历 */          for (String string : list) {              System.out.println(string);          }            /* 在指定位置插入元素 */          list.add(2, "zhu");            for (String string : list) {              System.out.println(string);          }            System.out.println("--------------");            /* 清空list */          list.clear();            /* 遍历 */          for (String string : list) {              System.out.println(string);          }          System.out.println("--------------");      }  }    2、LinkedListimport java.util.LinkedList;    public class LinkedListTest {            public static void main(String[] args) {            /* 新建一个list */          LinkedList<Integer> list = new LinkedList<Integer>();          System.out.println(list.size());            /* 向list中添加元素 */          list.add(222);          list.add(111);          list.add(0);          list.add(3333);          list.add(8888);                    System.out.println(list.size());            /* 遍历list */          for (Integer integer : list) {              System.out.println(integer);          }            /* 获取第一个元素 ,即header的next域*/          System.out.println("第一个元素是:" + list.getFirst());                    /*获取最后一个元素,即header的previous域*/          System.out.println("最后一个元素是:"+list.getLast());      }  }  3、hashsetpublic static void main(String[] args) {Set set = new HashSet();set.add("a");set.add("b");System.out.println(set);Student stu= new Student(18, "小名", 60);set.add(stu);//调用第一个对象的hashcode方法  调  equalsset.add(new Student(19, "小明", 60));set.add(new Student(19, "小明", 60));set.add(new Student(20, "小明", 61));System.out.println(set);}4、treesetimport java.util.ArrayList;import java.util.HashSet;import java.util.TreeSet;/** * 使用treeset存放一组学生成绩 * 1、可以自动排序(系统类  自然排序) *  2、不可重复(去重) *  3、只能存放一种数据类型 *  ---存放到 treeset中的元素必须要具有比较能力 *  调用compareTo() 如果得到的结果为0 ， 两个元素相等 *      1 ---》排到后面 *      -1 --->排到前面 *       *  hashset:-->hashtable(哈希表) *  treeset:-->二叉树，红黑树算法 *  每存入一个元素就会调用一次compareTo方法 * @author Administrator * */import java.util.Comparator;/** * 外部比较器，当系统类提供的比较规则满足不了需求时使用 *   1、自己创建一个比较器  实现  Comprator接口 ，添加一个泛型（需要比较的数据类型） *   2、重写comprae方法,用来比较，参数是两个需要比较的对象 * @author Administrator * */public class MyStrCompartor implements Comparator<String>{@Overridepublic int compare(String o1, String o2) {//按照字符串长度排序return o1.length() - o2.length();}}public class TestTreeSet02 {public static void main(String[] args) {//使用外部比较器，//1 拿到比较器的对象MyStrCompartor mcom = new MyStrCompartor();//2在创建集合时，调用有参的构造方法，把比较器传进去//3、在treeset中添加元素时，会优先调用自定义比较器的方法//treeset专用TreeSet ts = new TreeSet(mcom);//ts.add(20);//自动装箱//ts.add(1);//ts.add(100);//ts.add(7);//ts.add(8);//ts.add(100);System.out.println(ts);//需求：不希望按照系统的排序来排列//自己创建一个比较规则ts.add("xiaomi32313");ts.add("zhangliguo5");ts.add("asima1");ts.add("baibaibai4");ts.add("sansan2");//ts.add(new Student("yushen", 19, 19));//ts.add(new Student("xiaoming", 19, 19));//ts.add(new Student("axiaoming1", 19, 18));System.out.println(ts);}}5、hashmapimport java.util.HashMap;  import java.util.Map;  import java.util.Set;    /**  * HashMap的使用  * @author erqing  *   */  public class MapTest {        public static void main(String[] args) {            /* 初始化map */          Map<String, Integer> map = new HashMap<String, Integer>();          System.out.println("HashMap的初始值:" + map.size());          System.out.println("HashMap是否为空:" + (map.isEmpty() ? "是" : "否"));            /* 想map中添加元素 */          map.put("erqing", 1);          map.put("niuniu", 2);          map.put("egg", 3);          System.out.println(map.size());          ;          System.out.println("HashMap是否为空:" + (map.isEmpty() ? "是" : "否"));            /* 遍历HashMap中的元素 */          Set<String> set = map.keySet();          for (String s : set) {              System.out.println(s + " " + map.get(s) + " " + "hashcode:"                      + s.hashCode());          }            /*检测是否含有某个Key*/          System.out.println(map.containsKey("egg"));                    /*检测是否含有某个Value*/          System.out.println(map.containsValue(2));                    /*打印hashCode*/          System.out.println(map.hashCode());      }  }  /*输出：HashMap的初始值:0HashMap是否为空:是3HashMap是否为空:否niuniu 2 hashcode:-1045196352egg 3 hashcode:100357erqing 1 hashcode:-1294670850truetrue1955200455*/6、treemappublic static void main(String[] args) {                    SortedMap<String, Integer> map = new TreeMap<String, Integer>();          map.put("zgg", 1);          map.put("erqing", 3);          map.put("niu", 0);          map.put("abc", 2);          map.put("aaa", 5);  //map.put(1004, new Student("04",18 ,1004));//map.put(1005, new Student("05",18 ,1005));    也能存new        Set<String> keySet = map.keySet();          for (String string : keySet) {              System.out.print(map.get(string)+" ");          }      }  //输出：5 2 3 0 1

更多内容：http://blog.csdn.net/zhangerqing/article/details/8122075


持续更新，欢迎大家一起交流
邮箱：[e-mail]
未完，待续