本人深圳黑马学员,刚学到集合,不知道这个章节怎么学,需不需要做一些笔记之类的东西.或者是只要完成老师的任务就可以了.希望各位能给个建议,感激不尽.

把一些笔记给楼主分享一下：
【一】
1.集合
        作用:
                是一个容器,用于持有对象.
        优点:
                可以存储任意类型的对象. ->集合中存储的元素的数据类型可以是任意的.
                add(Object obj); 正是多态的机制,多态作为方法的形参可以接收范围更广的实际参数.
                可以存储任意多个对象.  ->集合的长度可变
        注意:
                集合持有的只是对象的引用,非对象本身.
                集合存储的元素的类型必须是类类型.集合只能存储对象,不能直接存储基本数据类型(存在了自动装箱) 1.5只有出现的自动装箱.
2.集合体系值_Collection
        为什么要先了解接口,不去直接学习集合 类ArrayList  
        ArrayList list=new ArrayList(); ->
        Collection coll=new ArrayList(); ->
        由于集合时一个体系,集合中最为共享的行为,都定义在了Collection 中, 如果先学习了解Collection,就了解了集合具备的最为基本的行为.
        学完集合共性的行为,可以继续研究的该体系的更为具体的实现类.
        |---Collection
                接口, 定义集合体系最为基本的行为(方法)
3.集合体系之_List
        |---Collection 接口
                |---List 接口
                        继承了Collection接口. 该List 接口是一个子接口,向对于父,有着更多的功能.
                        特点:
                                有序:
                                        元素存在在改集合体系中是有序的,按照添加的顺序,决定了元素在集合中的位置.
                                有角标:
                                        操作该体系的集合时,可以根据角标操作元素.
                                元素可以重复:
                                        该集合体系可以添加重复的元素.
                        验证:
                                验证通过.
                        总结:
                                List 体系中的集合具备:有角标,有序,元素可以重复
                        图书管理系统的时候:
                                增加的图书,按照顺序存放...
        List接口中定义的特有的方法(规范)
                增加:       
                         void add(int index, E element)
                         boolean addAll(int index, Collection<? extends E> c)
                删除:
                        remove(int index)
                修改:
                        set(int index, E element)
                查找:
                        E get(int index)
                        int indexOf(Object o)
                        int lastIndexOf(Object o)
                其他方法:
                        subList(int fromIndex, int toIndex)
                测试集合:
                        测试通过,总结List 集合中的特有方法,都是通过角标实现操作.
4.集合实现类_ArrayList
        要求自定义集合类:
                类似 与ArrayList 的一个集合类,能够增,删,查,改元素.
        |---Collection
                接口,定义了集合体系的共性的方法.
                |---List
                        接口 特点: 有序,有角标,元素可重复.
                        |---ArrayList
                                实现类, ArrayList 类内部维护了一个数组,数组的元素是Object 类型,保证可以添加任意类型对象.
                                ArrayList 内部有专业的方法,检测数组,如果数组已满,创建一个新数组,将旧数组的元素拷贝到新数组,使用新数组作为存储的容器.继续添加新元素.
                                数组实现内存地址连续:
                                        好处: 内存地址连续,有角标,可以通过角标快速的查找. ->查找快.
                                        弊端:增加: 使用的角标 add(0,元素) 新元素添加到集合中该该位置的旧元素需要整体往后移动.
                                                增加时,如果数组满了,需要创建新数组,拷贝数组元素, 增加时速度很慢 ->增加慢
                                                       删除: 删除指定位置的元素,该元素后的所有元素都要整体往前移动.
                                                增删是很慢的.
                                        总计: ArrayList 数组实现,内存地址连续,通过角标快速的查找->查找块
                                                      增加,删除元素时,设计到了元素的拷贝,和数组的扩容. 增删慢.  
                        注意:
                                调用ArrayList 默认无参数构造,底层维护的数组长度是10.
                                当明确存储的元素的个数,可以直通通过有参数构造,指定集合的长度(数组的长度)
                                ArrayList数组扩容时,新数组的长度是老数组的长度的1.5倍.  old*3/2+1
                        简答总结:
                                ArrayList 数组实现,内存地址连续, 查找快,增删慢
5.课堂练习:
        ArrayList 可以存储重复元素.
        编写程序,去除ArrayList 重复元素.
        测试: 重复的String
                      重复的自定义对象. Person   
                      什么是重复的人, 人中有姓名和年龄. 逻辑需求: 姓名相同年龄相同,视为同一个人. 把ArrayList程序中姓名相同的年龄相同的的去除
         实现:
                  去除ArrayList 重复元素, 定义一个新的ArrayList 集合,遍历旧的ArrayList 集合. 取出ArrayList 中的每一个元素.添加到新的ArrayList中.
                  使用新集合添加元素时,一定要检测新集合中是否包含了该元素,如果包含,就不再添加.
                 核心的代码: 使用ArrayList 集合的contains 方法,检测集合中是否包含指定元素.
                 注意: 使用ArrayList的contains 方法,无法检测出自定义对象的重复元素.查看源代码  原因-> contains 方法使用的是indexOf 方法
                       ->indexOf(Object e) 方法 是集合用于查找指定元素在集合中的位置.  
                       -> indexOf 方法内部: 遍历集合维护的数组,取出每一个元素, 和要查找的元素进行对比(元素的equals)
                 ArrayList 的方法
                         Object[] elemetData;
                         int size;
                         public boolean contains(Object e){
                                 return indexOf(e)>=0;
                         }
                         public int indexOf(Object e){
                                 for(int i=0;i<size;i++){
                                         if(o.equals(this.elementData[i])){
                                                 return i;
                                         }
                                 }
                                 return -1;
                         }
                        
                         注意: 使用ArrayList 存储自定义对象时,需要重写对象的equals 方法,建立对象的特有的比较方式...
                          否则ArrayList中contains 方法,indexOf 方法无法正常工作
                总结:
                         ArrayList 是实际开发中使用最为频繁的一个集合.
6.List 集合的遍历方式:
        一: toArray 方法,集合变数组
        二: get(int index)  取出每一个.
7.集合实现类_LinkedList
        |---Collection
                接口
                |---List 接口, 有序,有角标,元素可重复.
                        |---ArrayList
                                数组实现,查找快,增删慢.
                        |---LinkedList
                                双向链表实现, 链表内部使用节点对象(Node)对象,存储元素. 使用LinkedList 增加一个元素, 在LinkedList 就创建一个Node 节点对象.
                                节点对象保存元素.  节点和节点之间 内存地址是不连续的. 节点和节点之间需要记录他们之间的引用.上一个节点需要记录下一个节点.
                                简单总结: 内部地址不连续查找慢,增删快.  
                                class LinkedList{
                                        class Node{
                                                Node next;
                                                Node(Object obj){
                                                       
                                                }
                                        }
                                        Node head;
                                        Node tail;
                                        public boolean add(Object obj){
                                                Node n=new Node(obj);
                                                if(head==null&&tail==null){
                                                        head=tail=n;
                                                }else{
                                                        ...
                                                }
                                        }
                                }
                LinkedList特有方法:
                        由于双向链表实现,提供了操作头和尾的方法.
                        addFirst(E e)
                        addLast(E e)
                        getFirst()
                        getLast()
                        removeFirst()
                        removeLast()
                        由于LinkedList 在JDK1.5 后实现了Deque 接口. 具备了实现堆栈和队列的数据结构
                                堆栈: ->先进后出    子弹夹
                                        压栈: push();
                                        弹栈: pop)();
                                        注意: 弹栈后,集合中没有元素.
                                队列: ->先进先出.  排队.
                                        进队  offer()
                                        出队:poll()
8. 学习:
        第一步: 练习List 中的方法. ArrayList中方法,LinkedList 中的方法.
                        必须掌握基本的方法, List  全部都会. 一个亲自测试... 每一个方法记好笔记.
                        集合的基本使用...  图书管理系统...
        第二步: 掌握List 的特性, ArrayList 实现原理,LinkedList 的实现原理, 各自的优缺点.
                  原理.
        第三步: 自定类实现ArrayList LinkedList Stack 类的效果...        
9.集合体系
        |---Collection 接口 1.2 出现
                |---List 接口1.2 出现.
                        有序,有角标,元素可重复
                        |---ArrayList 实现类
                                1.2出现 ,        数组实现,内存地址连续,查找快增删慢.  不同步的. 大部分的集合操作,都是在单线程下... 如果是多线程操作集合?
                        |---LinkedList
                                1.2出现, 双向链表,内存地址不连续, 查找慢(中间的慢,头和尾其实不瞒),增删快
                        |---Vector
                                1.0出现,数组实现, 同步的(多线程下,线程安全.)  单线程下,还 需要同步,性能低.
                                有自己的特有的操作元素的方法,但是方法名过长, 在1.2 被ArrayList 替代.
                                特有方法:
                                        增加一个元素:
                                                addElement(E obj)   add()
                                                elementAt(int index)  get()
                                                insertElementAt(E obj, int index)   set()
                                                removeAllElements()  clear()
                                        在JDK1.0的时候,如何取出Vector 集合中的元素?
                                                通过Vector 的elements 方法获取到一个Enumeration 接口的实现类对象.  
                                                通过该对象的 hasMoreElements 和nextElement 方法取出集合中的元素.
                                        为什么被淘汰:
                                                1.0出现,线程同步(性能低),方法名过长(不方便使用),数组的扩容是100%(效率低)
                                                在1.2 后被ArrayList 替代.
                                        多线程操作:
                                                ArrayList -> 使用Collections         的方法 synchronizedList(List list); 将不同步的集合转换为同步的集合.

很详细，很全面

【二】然后是集合比较重要的知识点之一：遍历

1. package list;
   
2. 
   
3. import java.util.ArrayList;
   
4. import java.util.Iterator;
   
5. import java.util.List;
   
6. 
   
7. /**
   
8. * 遍历List集合的三种方法
   
9. *
   
10. * @author 小媛
    
11. *
    
12. */
    
13. public class ListPrintTest {
    
14.         public static void main(String[] args) {
    
15.                 List<String> list = new ArrayList<String>();//LinkedList
    
16.                 list.add("a");
    
17.                 list.add("b");
    
18.                 list.add("c");
    
19.                 list.add("d");
    
20.                 list.add("e");
    
21.                 list.add("f");
    
22.                 list.add("g");
    
23.                 list.add("h");
    
24. 
    
25.                 ListPrint3(list);
    
26. 
    
27.         }
    
28. 
    
29.         /**
    
30.          * 通过for循环，使用下角标然后操作集合对象的get方法拿到集合的元素
    
31.          * @param list
    
32.          */
    
33.         public static void ListPrint1(List<String> list) {
    
34.                 for (int i = 0; i < list.size(); i++) {
    
35.                         System.out.print(list.get(i));
    
36.                 }
    
37.         }
    
38. 
    
39.         /**
    
40.          * 使用list内部封装好的迭代器 遍历循环获取集合的元素
    
41.          * @param list
    
42.          */
    
43.         public static void ListPrint2(List<String> list) {
    
44.                 for (Iterator<String> i = list.iterator(); i.hasNext();) {
    
45.                         String element = i.next();
    
46.                         System.out.print(element);
    
47.                 }
    
48.         }
    
49. 
    
50.         /**
    
51.          * java1.5新特性 增强for循环
    
52.          * @param list
    
53.          */
    
54.         public static void ListPrint3(List<String> list) {
    
55.                 for(String element : list){
    
56.                         System.out.print(element);
    
57.                 }
    
58.         }
    
59. }
    

复制代码

1. package list;
   
2. 
   
3. import java.util.HashSet;
   
4. import java.util.Iterator;
   
5. import java.util.Set;
   
6. 
   
7. /**
   
8. * @author 小媛
   
9. * Set集合遍历
   
10. */
    
11. public class SetPrintTest {
    
12.         public static void main(String[] args) {
    
13.                
    
14.                 Set<String> set = new HashSet<String>();
    
15.                 set.add("a");
    
16.                 set.add("bb");
    
17.                 set.add("ccc");
    
18.                 set.add("dddd");
    
19.                 set.add("eeeee");
    
20.                 set.add("ffff");
    
21.                 set.add("ggg");
    
22.                 set.add("hh");
    
23.                 set.add("i");
    
24.                
    
25.                 SetPrint1(set);
    
26.         }
    
27.        
    
28.         /**
    
29.          * 使用迭代器
    
30.          * @param set
    
31.          */
    
32.         public static void SetPrint1(Set<String> set){
    
33.                 for(Iterator<String> i = set.iterator(); i.hasNext(); ){
    
34.                         String element = i.next();
    
35.                         System.out.println(element);
    
36.                 }
    
37.         }
    
38.        
    
39.         /**
    
40.          * 增强for
    
41.          * @param set
    
42.          */
    
43.         public static void SetPrint2(Set<String> set){
    
44.                 for(String element : set){
    
45.                         System.out.println(element);
    
46.                 }
    
47.         }
    
48. }
    

复制代码

最后是Map集合的遍历

1. package list;
   
2. 
   
3. import java.util.HashMap;
   
4. import java.util.Map;
   
5. import java.util.Map.Entry;
   
6. 
   
7. /**
   
8. * @author 小媛
   
9. * Map的遍历
   
10. */
    
11. public class MapPrint {
    
12.         public static void main(String[] args) {
    
13.                 Map<Integer, String> map = new HashMap<Integer, String>();
    
14.                 map.put(1, "QQ");
    
15.                 map.put(2, "VV");
    
16.                 map.put(3, "AA");
    
17.                 map.put(6, "PP");
    
18.                 map.put(7, "HH");
    
19.                 map.put(8, "KK");
    
20. 
    
21.                 MapPrint2(map);
    
22. 
    
23.         }
    
24. 
    
25.         /**
    
26.          * 通过Entry集合 增强for遍历获取 键-值
    
27.          * @param map
    
28.          */
    
29.         public static void MapPrint1(Map<Integer, String> map) {
    
30.                 for (Entry<Integer, String> entry : map.entrySet()) {
    
31.                         System.out.println(entry);
    
32.                 }
    
33.         }
    
34. 
    
35.         /**
    
36.          * 通过获取Key集合，增强for遍历获取 键-值
    
37.          * @param map
    
38.          */
    
39.         public static void MapPrint2(Map<Integer, String> map) {
    
40.                 for (Integer key : map.keySet()) {
    
41.                         System.out.println(key + " = " + map.get(key));
    
42.                 }
    
43.         }
    
44. 
    
45.         /**
    
46.          * 直接获取Value集合，增强for遍历获取 值
    
47.          * @param map
    
48.          */
    
49.         public static void MapPrint3(Map<Integer, String> map) {
    
50.                 for(String value : map.values()){
    
51.                         System.out.println(value);
    
52.                 }
    
53.         }
    
54. }
    

复制代码

集合的类型与各自的特性

---|Collection: 单列集合                         ---|List: 有存储顺序, 可重复                                 ---|ArrayList:        数组实现, 查找快, 增删慢                                                         由于是数组实现, 在增和删的时候会牵扯到数组 增容, 以及拷贝元素. 所以慢。数组是可以直接按索引查找, 所以查找时较快                 ---|LinkedList:        链表实现, 增删快, 查找慢由于链表实现, 增加时只要让前一个元素记住自己就可以, 删除时让前一个元素记住后一个元素, 后一个元素记住前一个元素. 这样的增删效率较高但查询时需要一个一个的遍历, 所以效率较低                                 ---|Vector:        和ArrayList原理相同, 但线程安全, 效率略低 和ArrayList实现方式相同, 但考虑了线程安全问题, 所以效率略低                         ---|Set: 无存储顺序, 不可重复                                 ---|HashSet   线程不安全，存取速度快。底层是以哈希表实现的。                 ---|TreeSet   红-黑树的数据结构，默认对元素进行自然排                                 序（String）。如果在比较的时候两个对象                                 返回值为0，那么元素重复。 ---| Map: 键值对   键不可重复，键可以重复                 ---|HashMap    线程不安全，存取速度快。底层是以哈希表实现的. ---|TreeMap   红-黑树的数据结构，默认对元素进行自然排                 序（String）。如果在比较的时候两个对象                  返回值为0，那么元素重复                 ---|HashTable  底层也是使用了哈希表 维护的，存取的读取快，存储元素是                          无序的。 小媛就这么多总结了。楼主加油