黑马程序员__集合Collection__List及三个子类的方法介绍

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

一.集合的概念

    1.什么是集合

       集合是一种容器, 长度可变, 可以存储任意类型的对象.

       基本数据类型也可以装入集合, 但其实内部是先自动装箱成包装类对象, 然后再存入集合的

二.集合的分类

    1.Collection

        List: 可重复, 有存储顺序,有索引

           ArrayList  数组实现, 增删慢, 查找快 

           LinkedList 链表实现, 增删快, 查找慢

           Vector     数组实现, 原理和ArrayList相同, 但线程安全

       Set:  不可重复,存取顺序不一致,无索引

           HashSet

           TreeSet

           LinkedHashSet

    2.Map

       HashMap

       TreeMap

       Hashtable

       LinkedHashMap

三、数组和集合的区别

      1,数组既可以存储基本数据类型,也可以存储引用数据类型,存储基本数据类型存储值,存储引用数据类型存储的是地址值

        集合只能存储引用数据类型,也就只能存对象

      2,数组的长度一旦初始化就不可以改变

        集合的长度是可变的,会随着元素的增多而增长

       什么时候用数组,什么时候用集合

       元素不变用数组

       元素可变用集合

[java]  view plain copy

1. import cn.itcast.bean.Person;  
2.   
3. public class Demo1_Collection {  
4. public static void main(String[] args) {  
5.         //int[] arr = new int[5];  
6.         Person[] arr = new Person[5];  
7.         arr = new Person[10];  
8.         arr[0] = new Person("张三", 23);  
9.         arr[1] = new Person("李四", 24);  
10.         System.out.println(arr[2]);  
11.           
12.     }  
13.   
14. }  
15. public class Person {  
16.     private String name;  
17.     private int age;  
18.     public Person() {  
19.         super();  
20.           
21.     }  
22.     public Person(String name, int age) {  
23.         super();  
24.         this.name = name;  
25.         this.age = age;  
26.     }  
27.     public String getName() {  
28.         return name;  
29.     }  
30.     public void setName(String name) {  
31.         this.name = name;  
32.     }  
33.     public int getAge() {  
34.         return age;  
35.     }  
36.     public void setAge(int age) {  
37.         this.age = age;  
38.     }  
39.     @Override  
40.     public String toString() {  
41.         return "Person [name=" + name + ", age=" + age + "]";  
42.     }  
43.       
44.       
45. }  

四、集合的常用方法

 1.常用方法

       add(Object obj)          向集合中添加一个元素, 添到最后的位置

       get(int index)               获取集合中指定位置的元素

       size()                    获取集合的长度

       add(int index, Object obj) 向集合中添加一个元素, 添到指定位置

       set(int index, Object obj) 把集合中指定位置的元素替换

       remove(int index)           删除集合中指定位置的元素

       remove(Object obj)          删除集合中包含的obj对象(遍历集合中的元素如果传入的元素equals某个元素就调用remove方法,注意:角标要--)

2迭代集合

       a.for循环:    从0循环到集合的size()-1, 每次获取其中一个

       b.迭代器:         调用iterator()方法获取迭代器, 使用hasNext()判断是否包含下一个元素, 使用next()获取下一个元素

       c.增强for循环:   for(类型 变量名 : 容器) { 循环体 } 容器中有多少个元素就执行多少次循环体, 每次循环变量指向容器中不同的元素

迭代时删除的问题

       a.for循环:        删除时由于后面的元素会向前移动, 所以删除之后循环变量要--

       b.迭代器:         要删除元素时必须使用Iterator中的remove()否则会抛出异常

       c.增强for循环:       不能删除

 1）Collection

[java]  view plain copy

1. public class Demo2_Collection {  
2.   
3.     /** 
4.      * @param args 
5.      */  
6.     public static void main(String[] args) {  
7.         //demo1();  
8.         //demo2();  
9.         //demo3();  
10.         Collection coll = new ArrayList();  
11.         coll.add("a");  
12.         coll.add("b");  
13.         coll.add("c");  
14.         coll.add("d");  
15.         coll.add("e");  
16.           
17.         //System.out.println(coll.isEmpty());           //判断集合是否为空,如果为空就返回true  
18.         //coll.clear();  
19.         //System.out.println(coll.isEmpty());  
20.         System.out.println(coll.remove("a"));           //删除,删除成功返回true  
21.         System.out.println(coll);  
22.         System.out.println(coll.size());  
23.     }  
24.   
25.     private static void demo3() {  
26.         Collection coll1 = new ArrayList();     //alt + shift + r  改名  
27.         coll1.add("a");  
28.         coll1.add("b");  
29.         coll1.add("c");  
30.         coll1.add("d");  
31.         coll1.add("e");  
32.           
33.         Collection coll2 = new ArrayList();     //alt + shift + r  改名  
34.         coll2.add("a");  
35.         coll2.add("b");  
36.         coll2.add("c");                         //alt + 上下键向上或向下移动  
37.         coll2.add("d");  
38.         coll2.add("e");  
39.           
40.         System.out.println(coll1.equals(coll2));//判断两个集合中的元素是否一样,顺序也要一致  
41.     }  
42.   
43.     private static void demo2() {  
44.         Collection coll = new ArrayList();  
45.         coll.add("a");  
46.         coll.add("b");  
47.         coll.add("c");  
48.         coll.add("d");  
49.         coll.add("e");  
50.         //System.out.println(coll);  
51.         //coll.clear();                             //清空集合中的元素  
52.         //System.out.println(coll);  
53.         System.out.println(coll.contains("b"));         //判断是否包含  
54.         System.out.println(coll.contains("z"));         //alt + ctrl + 下键 向下复制一行  
55.     }  
56.   
57.     private static void demo1() {  
58.         Collection coll = new ArrayList();  
59.         boolean b1 = coll.add(1);                   //Object obj = new Integer(1);  
60.         boolean b2 = coll.add("a");  
61.         boolean b3 = coll.add(true);  
62.         boolean b4 = coll.add(1);     
63.         System.out.println(b1);  
64.         System.out.println(b2);  
65.         System.out.println(b3);  
66.         System.out.println(b4);  
67.         System.out.println(coll.toString());  
68.     }  
69.   
70. }  

* 接口没有继承Object,因接口中所有的方法都是抽象的,那么为什么接口可以调用Object中的方法呢?

     * 因为jvm同映射拿到Object中的方法

[java]  view plain copy

1. public static void main(String[] args) {  
2.         Inter i = new Demo();  
3.         i.print();  
4.     }  
5.   
6. }  
7.   
8. interface Inter {  
9.     public void print();  
10. }  
11.   
12. class Demo implements Inter {  
13.     public void print() {  
14.         System.out.println("111111111111");  

2)List

[java]  view plain copy

1. public class Demo5_List {  
2.   
3.       
4.     public static void main(String[] args) {  
5.         //demo1();  
6.         //demo2();  
7.         //demo3();  
8.         //demo4();  
9.         //demo5();  
10.         //demo6();  
11.         //demo7();  
12.         List list = new ArrayList();  
13.         list.add("a");  
14.         list.add("b");  
15.         list.add("c");  
16.         list.add("d");  
17.         list.add("e");  
18.         list.add("f");  
19.         list.add("g");  
20.           
21.         List newList = list.subList(1, 4);      //截取子集合  
22.         System.out.println(list);  
23.         System.out.println(newList);  
24.     }  
25.   
26.     private static void demo7() {  
27.         List list = new ArrayList();  
28.         list.add("a");  
29.         list.add("b");  
30.         list.add("c");  
31.         list.add("d");  
32.           
33.         list.set(1, "z");  
34.         System.out.println(list);       //修改指定位置的元素  
35.     }  
36.   
37.     private static void demo6() {  
38.         List list = new ArrayList();  
39.         list.add(111);  
40.         list.add(222);  
41.         list.add(333);  
42.           
43. list.remove(new Integer(111));//删除Integer对象的时候,不会自动装需要手动装箱  
44.           
45.         System.out.println(list);  
46.     }  
47.   
48.     private static void demo5() {  
49.         List list = new ArrayList();  
50.         list.add("a");  
51.         list.add("b");  
52.         list.add("c");  
53.         list.add("a");  
54.           
55.         Object obj = list.remove(1)//根据指定索引删除,返回被删除的元素  
56.         boolean b = list.remove("c");  
57.         System.out.println(obj);  
58.         System.out.println(b);  
59.         System.out.println(list);  
60.     }  
61.   
62.     private static void demo4() {  
63.         List list = new ArrayList();  
64.         list.add("a");  
65.         list.add("b");  
66.         list.add("c");  
67.         list.add("a");  
68.           
69.         int index1 = list.indexOf("a"); //在集合中查找对象(从前向后找),返回的是对象的索引  
70.         System.out.println(index1);  
71.           
72.         int index2 = list.lastIndexOf("a");//在集合中查对象对象(从后向前找),返回的是对象的索引  
73.         System.out.println(index2);  
74.     }  
75.   
76.     private static void demo3() {  
77.         List list = new ArrayList();  
78.         list.add("a");  
79.         list.add("b");  
80.         list.add("c");  
81.         //Object obj = list.get(2);  
82.         //System.out.println(obj);  
83.           
84.         for(int i = 0;i < list.size(); i++) {            //List集合中的第一种迭代  
85.             System.out.println(list.get(i));  
86.         }  
87.     }  
88.   
89.     private static void demo2() {  
90.         List list1 = new ArrayList();  
91.         list1.add("a");  
92.         list1.add("b");  
93.           
94.         list1.add("c");  
95.         list1.add("d");  
96.           
97.         List list2 = new ArrayList();  
98.         list2.add("a");  
99.         list2.add("b");  
100.         list2.add("c");  
101.         list2.add("d");  
102.           
103.         list1.addAll(2, list2);         //在指定位置添加一个集合进来  
104.         System.out.println(list1);  
105.     }  
106.   
107.     private static void demo1() {  
108.         List list = new ArrayList();  
109.         list.add("a");  
110.         list.add("b");  
111.         list.add("c");  
112.         //list.add(1, "z");//在指定位置添加,index <= size && index >= 0,否则IndexOutOfBoundsException  
113.         list.add(4, "z");  
114.         System.out.println(list);  
115.     }  
116.   
117. }  

3)List的三个儿子(掌握)

    (1)List的三个儿子特点：

       List

           |--ArrayList

              底层数据结构是数组，查询和修改快，增删慢

              线程不安全，效率高

           |--Vector

              底层数据结构是数组，查询慢(相对应ArrayList)，增删慢(相对应LinkedList)

              线程安全，效率低

           |--LinkedList

              底层数据结构是链表，查询和修改慢，增删快

              线程不安全，效率高

    (2)ArrayList(存储字符串和自定义对象)

    (3)Vector(存储字符串和自定义对象)

       有自己的特殊功能。

       但是不用，被新功能给替代了。

    (4)LinkedList(存储字符串和自定义对象)

       有自己的特殊功能。可以很方便的操作头和尾。

    (5)案例：

       A:ArrayList存储字符串并去除重复值

       B:ArrayList存储自定义对象并去除重复值

           需求：我们认为同姓名和同年龄的人即为同一个人。

       C:用LinkedList模拟栈数据结构

ArrayList

[java]  view plain copy

1. public class Demo7_Delete {  
2.   
3.       
4.     public static void main(String[] args) {  
5.         //demo1();  
6.         ArrayList list = new ArrayList();  
7.         list.add("a");  
8.         list.add("a");  
9.         list.add("b");  
10.         list.add("b");  
11.         list.add("c");  
12.         list.add("d");  
13.           
14.         /*for(int i = 0; i < list.size(); i++) { //普通for循环可以删除,删除的时候索引要--         
15.             Object obj = list.get(i); 
16.             if(obj.equals("a")) { 
17.                 list.remove(i--); 
18.             } 
19.         }*/  
20.         /*Iterator it = list.iterator(); 
21.         while(it.hasNext()) {       //迭代可以删除,但是必须用迭代器的删除方法 
22.             Object obj = it.next(); //如果用集合的删除方法,会出现并发修改异常ConcurrentModificationException 
23.             if(obj.equals("b")) { 
24.                 //list.remove("b"); 
25.                 it.remove(); 
26.             } 
27.         }*/  
28.           
29.         for (Object obj : list) {                   //增强for循环不能删除  
30.             if(obj.equals("b")) {  
31.                 list.remove("b");  
32.             }  
33.         }  
34.           
35.         System.out.println(list);  
36.     }  
37.   
38.     private static void demo1() {  
39.         ArrayList list = new ArrayList();  
40.         list.add("a");  
41.         list.add("b");  
42.         list.add("c");  
43.         list.add("d");  
44.           
45.         for(int i = 0; i < list.size(); i++) {           //如果需要使用索引就用普通for循环  
46.             System.out.println(list.get(i));  
47.         }  
48.           
49.         Iterator it = list.iterator();                  //不需要索引可以用迭代器  
50.         while(it.hasNext()) {  
51.             System.out.println(it.next());  
52.         }  
53.           
54.         for (Object obj : list) {       //代码简单,只要能用迭代迭代的就可以用增强for循环  
55.             System.out.println(obj);  
56.         }  
57.     }  
58.   
59. }  

Vector

 Vector和ArrayList的区别

     * 共同点:Vector和ArrayList的底层都是用数组实现的

     * 区别:

     * Vector是jdk1.0版本的出现的,是线程安全的,效率低

     * ArrayList是jdk1.2版本出现的,是线程不安全的,效率高

     * 特有迭代器 ： 枚举

[java]  view plain copy

1. public class Demo2_Vector {  
2.   
3.     /** 
4.      * @param args 
5.      */  
6.     public static void main(String[] args) {  
7.         Vector v = new Vector();  
8.         v.addElement("a");  
9.         v.addElement("b");  
10.         v.addElement("c");  
11.         v.addElement("d");  
12.           
13.         Enumeration en = v.elements();  
14.         while(en.hasMoreElements()) {  
15.             System.out.println(en.nextElement());  
16.         }  
17.           
18.         Vector v2 = new Vector();  
19.         v2.add("a");  
20.         v2.add("b");  
21.         v2.add("c");  
22.         v2.add("d");  
23.           
24.         Iterator it = v2.iterator();  
25.         while(it.hasNext()) {  
26.             System.out.println(it.next());  
27.         }  
28.     }  

LinkedList

ArrayList和LinkedList的区别

     * ArrayList底层是数组实现的,查找和修改比较快,增和删比较慢

     * LinkedList底层是链表实现的,查找和修改比较慢,增和删比较快

     */

[java]  view plain copy

1. public class Demo3_LinkedList {  
2.   
3.     /** 
4.      * @param args 
5.      */  
6.     public static void main(String[] args) {  
7.         //demo1();  
8.         LinkedList list = new LinkedList();  
9.         /*list.add("a"); 
10.         list.add("b"); 
11.         list.add("c"); 
12.         list.add("d");*/  
13.           
14. //      System.out.println(list.getFirst());    //当集合中没有元素,抛出元素找不到异常,后续代码不会执行  
15. //      System.out.println(list.getLast());  
16. //      System.out.println(list.peekFirst());       //当集合中没有元素,返回null,后续代码继续执行  
17. //      System.out.println(list.peekLast());  
18.           
19.         System.out.println(list.removeFirst());     //删除第一个元素  
20. //      System.out.println(list.removeLast());      //删除最后一个元素  
21. //      System.out.println(list.pollFirst());  
22. //      System.out.println(list.pollLast());  
23.         System.out.println("111111111111111111111111111");  
24.     }  
25.   
26.     private static void demo1() {               //ctrl + d  删除选中部分  
27.         LinkedList list = new LinkedList();  
28.         list.addFirst("a");                     //在集合的第一个位置添加  
29.         list.addFirst("b");  
30.         list.addFirst("c");  
31.         list.addFirst("d");  
32.         list.addLast("e");                      //在集合的最后一个位置添加  
33.           
34.         System.out.println(list);  
35.     }  
36.       
37.       
38. }  

五、总结

1、List的所有子类都能迭代

ArrayList：a、有普通for循环 b、迭代器 c、增强for循环

Vector:  a、有普通for循环 b、迭代器 c、增强for循环 d、枚举

LinkedList: a、迭代器 b、增强for循环

2、ArrayList和LinkedList的区别

      ArrayList底层是数组实现的,查找和修改比较快,增和删比较慢

      LinkedList底层是链表实现的,查找和修改比较慢,增和删比较快

3、Vector和ArrayList的区别

     * 共同点:Vector和ArrayList的底层都是用数组实现的

     * 区别:

     * Vector是jdk1.0版本的出现的,是线程安全的,效率低

     * ArrayList是jdk1.2版本出现的,是线程不安全的,效率高，

     *特有迭代器 枚举