import java.util.ArrayList;
import java.util.Iterator;
/*
1,add方法的参数是Object.以便于接收任意类型对象。
2集合中存储的都是对象的引用(也就是地址)

常用函数
add(); 添加元素
size(); 求集合的长度
contains(String); 判断String字符是否存在于集合中
isEmpty(); 此函数判断集合是否为空
remove(String) 删除数组中的Sring元素
clear(); 清空集合

retainAll()  去交集
remove() 删除有交集的元素

什么是迭代器？
其实就是集合的取出元素的方式。
把取出方式定义在集合的内部，
这样取出方式就可以直接访问集合内容的元素。

那么取出方式就被定义成了内部类。

而每一个容器的数据结构不同。
所以取出的动作细节也不一样，但是都有共性内容。
判读和取出。那么可以可以将共性抽取。

所以这些内部类都符合一个规则。该规则就是Iterator.
如何取出集合的取出对象呢？
通过一个对外提供的方法iterator();
*/

1. class CollectionDemo
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 //mothed_1();
   
6.                 //mothed_2();
   
7.                 dieDai();
   
8.         }
   
9. 
   
10.         //结合容器Collection的一个基本应用
    
11.         public static void mothed_1()
    
12.         {
    
13.                 //创建一个集合容器，使用Collection接口的子类。ArrayList
    
14.                 ArrayList  a1 = new ArrayList();
    
15.                
    
16.                 //添加元素
    
17.                 a1.add("java01");
    
18.                 a1.add("java02");
    
19.                 a1.add("java03");
    
20.                 a1.add("java04");
    
21. 
    
22.                 //获取个数。求集合的长度
    
23.                 p("长度是：" + a1.size());
    
24. 
    
25.                 //打印集合
    
26.                 p("原集合：" + a1);
    
27. 
    
28.                 //判断java03元素是否存在    运用contains函数
    
29.                 p("java03是否存在于集合中：" + a1.contains("java03"));
    
30. 
    
31.                 //判断集合是否为空  运用isEmpty()函数
    
32.                 p("判断集合是否为空：" + a1.isEmpty());
    
33. 
    
34. 
    
35.                 //删除集合
    
36.                 a1.remove("java03"); //调用remove函数删除集合中的元素
    
37.                 p("删除单个元素后的集合：" + a1);
    
38. 
    
39.                 a1.clear(); //调用clear清空集合
    
40.                 p("清空后的集合：" + a1);
    
41.         }
    
42.         
    
43.         //集合中的交集小例子
    
44.         public static void mothed_2()
    
45.         {
    
46.                 //创建一个集合容器，使用Collection接口的子类。ArrayList
    
47.                 ArrayList  a1 = new ArrayList();
    
48.                
    
49.                 //添加元素
    
50.                 a1.add("java01");
    
51.                 a1.add("java02");
    
52.                 a1.add("java03");
    
53.                 a1.add("java04");
    
54.                
    
55.                 ArrayList a2 = new ArrayList();
    
56.                 //添加元素
    
57.                 a2.add("java01");
    
58.                 a2.add("java02");
    
59.                 a2.add("java05");
    
60.                 a2.add("java06");
    
61.                 //a1.retainAll(a2); //判断两个容器是否有交集的地方，有的话。把交集的内容打印,.可以剪短的称之为取交集
    
62.                 //p(a1);
    
63.                 a1.removeAll(a2); //干掉相同的元素
    
64.                 p(a1);
    
65.         }
    
66. 
    
67.         //简单应用迭代器
    
68.         public static void dieDai()
    
69.         {
    
70.                 ArrayList s = new ArrayList();
    
71.                 s.add("java01");
    
72.                 s.add("java02");
    
73.                 s.add("java03");
    
74.                 s.add("java04");
    
75.                 /*   此为while循环
    
76.                 //获取迭代器 使用迭代器取出集合中的元素
    
77.                 Iterator it = s.iterator();
    
78.                 while(it.hasNext()) //判断集合中是否有内容。有就往下执行
    
79.                 {
    
80.                         p(it.next()); //打印输出集合中的内容
    
81.                 }
    
82.                 */
    
83.                 //使用for循环使用迭代器
    
84.                 for(Iterator it = s.iterator(); it.hasNext(); )
    
85.                 {
    
86.                         p(it.next());
    
87.                 }
    
88. 
    
89.         }
    
90.         
    
91.         public static void p(Object obj)
    
92.         {
    
93.                 System.out.println(obj);
    
94.         }
    
95. 
    
96. }

复制代码

给你补充下吧。要想使用迭代器，必须使用iterator接口。
Map集合就不能直接使用迭代器。
必须使用keySet 或者是entrySet，返回Set的集合使用
entrySet效率比较高

正学着这里呢