黑马程序员_java集合概述

------- android培训、java培训、期待与您交流！ ----------

一，集合类

1.为什么出现集合类？

面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式。

2.数组和集合类同是 容器，有何不同？

数组虽然也可以存储对象，但长度是固定的，集合长度是可变的，数组中可以存储基本数据类型，集合只能存储对象。

3.集合类的特点

集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象。

二，集合框架

1.Collection:

add  rmove contains clear iterator

2.List

ArrayList   LinkList vector

3.set

HashSet TreeSet

4.Collection定义了集合框架的共性功能。
4.1，添加
add(e);
addAll(collection);


4.2，删除
remove(e);
removeAll(collection);
clear();


4.3，判断。
contains(e);
isEmpty();


4.4，获取
iterator();
size();


4.5，获取交集。
retainAll();


4.6，集合变数组。
toArray();

4.7add方法的参数类型是Object。以便于接收任意类型对象。


4.8集合中存储的都是对象的引用(地址).

5.迭代器：

其实就是集合取出元素的方式，

迭代器是取出方式，会直接访问集合中的内部元素。

所以迭代器通过内部类的方式来描述

通过迭代器的Iterator（）方法来获取该内部类的对象

[java]  view plain copy

1. class  CollectionDemo  
2. {  
3.     public static void main(String[] args)   
4.     {  
5.           
6.         method_get();  
7.     }  
8.     public static void method_get()  
9.     {  
10.         ArrayList al = new ArrayList();  
11.   
12.         //1，添加元素。  
13.         al.add("java01");//add(Object obj);  
14.         al.add("java02");  
15.         al.add("java03");  
16.         al.add("java04");  
17.   
18.         /* 
19.         Iterator it = al.iterator();//获取迭代器，用于取出集合中的元素。 
20.  
21.         while(it.hasNext()) 
22.         { 
23.             sop(it.next()); 
24.         } 
25.         */  
26.   
27.         for(Iterator it = al.iterator(); it.hasNext() ; )  
28.         {  
29.             sop(it.next());  
30.         }  
31.     }  
32.   
33.   
34.     public static void method_2()  
35.     {  
36.         ArrayList al1 = new ArrayList();  
37.   
38.         al1.add("java01");  
39.         al1.add("java02");  
40.         al1.add("java03");  
41.         al1.add("java04");  
42.         ArrayList al2 = new ArrayList();  
43.   
44.         al2.add("java03");  
45.         al2.add("java04");  
46.         al2.add("java05");  
47.         al2.add("java06");  
48.   
49.           
50.         //al1.retainAll(al2);//去交集，al1中只会保留和al2中相同的元素。  
51.         al1.removeAll(al2);  
52.   
53.         sop("al1:"+al1);  
54.         sop("al2:"+al2);  
55.   
56.   
57.   
58.   
59.     }  
60.   
61.     public static void base_method()  
62.     {  
63.         //创建一个集合容器。使用Collection接口的子类。ArrayList  
64.         ArrayList al = new ArrayList();  
65.   
66.         //1，添加元素。  
67.         al.add("java01");//add(Object obj);  
68.         al.add("java02");  
69.         al.add("java03");  
70.         al.add("java04");  
71.   
72.         //打印原集合。  
73.         sop("原集合:"+al);  
74.   
75.   
76.         //3，删除元素。  
77.         //al.remove("java02");  
78.         //al.clear();//清空集合。  
79.   
80.   
81.         //4，判断元素。  
82.         sop("java03是否存在:"+al.contains("java03"));  
83.         sop("集合是否为空？"+al.isEmpty());  
84.   
85.   
86.         //2，获取个数。集合长度。  
87.         sop("size:"+al.size());  
88.   
89.         //打印改变后的集合。  
90.         sop(al);  
91.   
92.     }  
93.   
94.     public static void sop(Object obj)  
95.     {  
96.         System.out.println(obj);  
97.     }  
98. }  

List集合特有的迭代器，ListIterator是Iterator的子接口

Collection
|--List:元素是有序的，元素可以重复。因为该集合体系有索引。
|--ArrayList:底层的数据结构使用的是数组结构。特点：查询速度很快。但是增删稍慢。线程不同步。
|--LinkedList:底层使用的链表数据结构。特点：增删速度很快，查询稍慢。线程不同步。
|--Vector:底层是数组数据结构。线程同步。被ArrayList替代了。因为效率低。




|--Set：元素是无序，元素不可以重复。、
List：
特有方法。凡是可以操作角标的方法都是该体系特有的方法。

在迭代时，不可以通过集合对象的方法操作集合中的元素

因为会发生ConcurrentModificatioException异常。

所以，在迭代器时，只能用迭代器的放过操作元素，可是Iterator方法是有限的，

只能对元素进行判断，取出，删除的操作，

如果想要其他的操作如添加，修改等，就需要使用其子接口，ListIterator.

该接口只能通过ListIterator方法获取。

[java]  view plain copy

1. import java.util.*;  
2. class ListDemo   
3. {  
4.     public static void sop(Object obj)  
5.     {  
6.         System.out.println(obj);  
7.     }  
8.     public static void method()  
9.     {  
10.           
11.         ArrayList al = new ArrayList();  
12.   
13.         //添加元素  
14.         al.add("java01");  
15.         al.add("java02");  
16.         al.add("java03");  
17.           
18.         sop("原集合是："+al);  
19.         //在指定位置添加元素。  
20.         al.add(1,"java09");  
21.   
22.         //删除指定位置的元素。  
23.         //al.remove(2);  
24.   
25.         //修改元素。  
26.         //al.set(2,"java007");  
27.   
28.         //通过角标获取元素。  
29.         sop("get(1):"+al.get(1));  
30.   
31.         sop(al);  
32.   
33.         //获取所有元素。  
34.         for(int x=0; x<al.size(); x++)  
35.         {  
36.             System.out.println("al("+x+")="+al.get(x));  
37.         }  
38.   
39.         Iterator it = al.iterator();  
40.   
41.         while(it.hasNext())  
42.         {  
43.             sop("next:"+it.next());  
44.         }  
45.   
46.   
47.         //通过indexOf获取对象的位置。  
48.         sop("index="+al.indexOf("java02"));  
49.   
50.         List sub = al.subList(1,3);  
51.   
52.         sop("sub="+sub);  
53.     }  
54.   
55.       
56.     public static void main(String[] args)   
57.     {  
58.   
59.         //演示列表迭代器。  
60.         ArrayList al = new ArrayList();  
61.   
62.         //添加元素  
63.         al.add("java01");  
64.         al.add("java02");  
65.         al.add("java03");  
66.   
67.         sop(al);  
68.   
69.           
70.         ListIterator li = al.listIterator();  
71.   
72.           
73.         //sop("hasPrevious():"+li.hasPrevious());  
74.   
75.         while(li.hasNext())  
76.         {  
77.             Object obj = li.next();  
78.   
79.             if(obj.equals("java02"))  
80.                 //li.add("java009");  
81.                 li.set("java006");  
82.   
83.   
84.         }  
85.   
86.         while(li.hasPrevious())  
87.         {  
88.             sop("pre::"+li.previous());  
89.         }  
90.         //sop("hasNext():"+li.hasNext());  
91.         //sop("hasPrevious():"+li.hasPrevious());  
92.   
93.   
94.         sop(al);  
95.   
96.   
97.   
98.         /* 
99.         //在迭代过程中，准备添加或者删除元素。 
100.  
101.         Iterator it = al.iterator(); 
102.  
103.         while(it.hasNext()) 
104.         { 
105.             Object obj = it.next(); 
106.  
107.             if(obj.equals("java02")) 
108.                 //al.add("java008"); 
109.                 it.remove();//将java02的引用从集合中删除了。 
110.  
111.             sop("obj="+obj); 
112.  
113.  
114.         } 
115.         sop(al); 
116.         */  
117.           
118.   
119.   
120.     }  
121. }