集合框架1（Collection的共性方法，迭代器，ArrayList，LinkedList，Vector）
为什么会出现集合类？
面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就需要对多个对象进行存储，集合类就是方式之一。
那数组和集合均为容器，有什么不同呢？
<1>数组的长度是固定不变的，集合长度是可以变化的。
<2>数组定义时需要指定类型，只能存储同一类型的数据，而集合不限定类型。
<3>数组还可以存储其他的基本数据类型，而集合只能存储对象。
集合类的特点：
<1>集合只用于存储对象 <2>集合的长度是可变的 <3>集合可以用来存储不同类型的对象
Collection的共性方法（以ArrayList为例）：
ArrayList al=new ArrayList( );
<1>添加元素：add(对象)；add方法的参数类型为Object，以便于接收任意类型的对象，集合中存储的都是对象的引用（即地址）。
<2>获取集合的长度：al.size( );
<3>打印集合：System.out.println(al);打印出来的是集合里面的元素。
<4>删除元素：al.remove(对象);
将集合清空：al.clear( );
<5>判断元素：
1:
2: //判断是否包含某一元素，返回值类型为boolean型
3: System.out.println("java03是否存在："+al.contains("java03"));
4:
5: //判断集合是否为空
6: System.out.println("集合是否为空："+al.isEmpty());
7:
<6>取两个集合的交集：
1: //取两个集合的交集，al1中只存放和al2中相同的元素
2: al1.retainAll(al2);
3:
4: //al1中只保留与al2中不同的元素，移走相同的元素
5: al1.removeAll(al2);
6:
迭代器（以ArrayList为例）：
获取迭代器，用于取出集合中的元素：
1: Iterator it=al.iterator();
2: //hasNext方法，如果还有下一个元素可以迭代，那么返回true
3: //next方法，取出下一个元素
4: while(it.hasNext())
5: {
6: System.out.println(it.next());
7: }
那么什么是迭代器呢？
其实就是集合的取出元素的方式。就把这些取出方式定义在集合的内部，这样取出方式就可以直接访问集合内容的元素，那么取出方式就被定义成了内部类。
而每一个容器的数据结构不一样，那么取出的动作细节也不一样，但是都是有同性的，例如判断和取出，那么就将共性内容抽取出来。
这样内部类符合一个规则，该规则是Iterator，如何获取集合的取出对象呢？通过一个对外提供的方法，iterator方法。
1: for(Iterator it=al.iterator();it.hasNext();)
2: {
3: System.out.println(it.next());
4: }
5: //通过indexOf来获取对象的位置：
6: al.indexOf("对象名");
7: //获取al中的部分对象，包含头不包含尾
8: List sub=al.subList(1,3);
9:
列表迭代器：
如果需要在迭代的过程中增加或者删除元素的话。
1: Iterator it=al.iterator();
2: while(it.hasNext())
3: {
4: Object obj=it.next();
5: if(obj.equals("java02"))
6: al.add("java08");
7: System.out.println("obj="+obj);
8: }
9:
10: //运行时会出现ConcurrentModificationException,
11: //当方法检测到并发修改，但是不允许并发修改，会抛出此异常
此时就需要使用到ListIterator，列表迭代器。继承自Iterator。是List集合特有的迭代器。
在迭代时，不可以通过集合对象的方法操作集合中的元素，因为会发生ConcurrentModificationException。因此在迭代时，只可以通过迭代器的方法操作元素。又因为Iterator的方法是有限的（判断，取出，移除）。需要其他操作则需要其子接口ListIterator。
1: ListIterator li=al.listIterator();
2: while(li.hasNext())
3: {
4: Object obj=li.next();
5: if(obj.equals("java02"))
6: li.add("java09");//在java02后面加上java09
7:
8: //将java02置换成java006
9: li.set("java006");
10: }
11:
12: /*
13: boolean hasPrevious();逆向遍历列表，判断前面是否有元素，如果有，返回true
14: previous();返回列表的前一个元素
15:
16: */
List的方法：
特有方法，凡是可以操作角标的方法都是该体系特有的方法。
<1>增加：add(index,element);
addAll(index,Collection);从指定位置开始，将指定的Collection中的所有元素都插入到此列表中
<2>删除：remove(index);
<3>修改：set(index,element);
<4>查询：get(index);通过角标获取元素
subList(from,to);获取该列表的一部分，包含头不包含尾
iterator();
indexOf(obj);获取指定元素的位置
listIterator();
Vector：
1: public static void main(String[] args)
2: {
3: Vector v=new Vector();
4: v.add("java01");
5: v.add("java02");
6: v.add("java03");
7: v.add("java04");
8:
9: //枚举是Vector特有的取出方式，枚举和迭代的使用方法一样。
10: Enumeration en=v.elements();
11: while(en.hasMoreElements())
12: {
13: System.out.println(en.nextElement());
14: }
15: }
LinkedList：
1:
2: public static void main(String[] args)
3: {
4: LinkedList link=new LinkedList();
5: link.add("java01");
6: link.add("java02");
7: link.add("java03");
8: link.add("java04");
9:
10: //将对象添加到链表头部
11: link.addFirst("java00");
12: //将对象添加到链表尾部
13: link.addLast("java05");
14:
15: /*获取链表头部和链表尾部getFirst()，getLast(),只获取，不删除
16:
17: 删除链表头部和链表尾部removeFirst()，removeLast()，获取且删除
18: 如果该链表为空，使用removeFirst和removeLast方法会发出NoSuchElementException,无此元素异常
19:
20: pollFirst()和pollLast()获取并移除列表的第一个元素，最后一个元素
21: 如果链表为空，则返回null
22:
23: offerFirst()和offerLast()在链表的开头或者结尾插入指定的元素
24:
25: peekFirst()和peekLast()获取但是不移除元素，如果集合中没有元素，则返回null
26:
27:
28: */
29: }
使用LinkedList模拟一个堆栈或者队列数据结构，堆栈是先进后出，队列是先进先出
1: class DuiLie
2: {
3: private LinkedList link;
4: DuiLie()
5: {
6: link=new LinkedList();
7: }
8:
9: public void myAdd(Object obj)
10: {
11: link.addFirst(obj);
12: }
13:
14: public Object myGet()
15: {
16: return link.removeLast();
17: }
18:
19: public boolean isNull()
20: {
21: return link.isEmpty();
22: }
23:
24: }
练习：去掉ArrayList中的重复元素：
1: /*
2: 去除ArrayList中的重复元素。
3: */
4:
5: import java.util.*;
6:
7: class ArrayListDemo
8: {
9: private ArrayList al1;
10: ArrayListDemo()
11: {
12: al1=new ArrayList();
13: }
14: public ArrayList newAl(ArrayList al)
15: {
16: for(Iterator it=al.iterator();it.hasNext();)
17: {
18: Object obj=new Object();
19: obj=it.next();
20: if(!al1.contains(obj))
21: {
22: al1.add(obj);
23: }
24: }
25:
26: return al1;
27: }
28:
29: }
30:
31: class ArrayListDemo2
32: {
33: public static void main(String[] args)
34: {
35: ArrayList al=new ArrayList();
36: al.add("java01");
37: al.add("java02");
38: al.add("java03");
39: al.add("java02");
40: al.add("java01");
41:
42: ArrayListDemo ald=new ArrayListDemo();
43:
44:
45: System.out.println(ald.newAl(al));
46: }
47: }
48:
在ArrayList集合中存入人对象，而且根据姓名和年龄判断是否包含相同的元素
1: import java.util.*;
2:
3: class Person
4: {
5: private String name;
6: private int age;
7: Person(String name,int age)
8: {
9: this.name=name;
10: this.age=age;
11: }
12:
13:
14: public String getName()
15: {
16: return name;
17: }
18: public int getAge()
19: {
20: return age;
21: }
22:
23: //list集合判断元素是否相同，依据是元素的equals方法，重写该方法，以自己的标准来进行判断
24: public boolean equals(Object obj)
25: {
26: if(!(obj instanceof Person))
27: return false;
28: Person p=(Person)obj;
29: return this.name.equals(p.name)&&this.age==p.age;
30: }
31:
32:
33: }
34:
35: class ArrayListDemo
36: {
37: private ArrayList al1;
38: ArrayListDemo()
39: {
40: al1=new ArrayList();
41: }
42: public ArrayList newAl(ArrayList al)
43: {
44: for(Iterator it=al.iterator();it.hasNext();)
45: {
46: Object obj=it.next();
47:
48:
49: if(!al1.contains(obj))
50: {
51: al1.add(obj);
52: }
53: }
54:
55: return al1;
56: }
57:
58: }
59:
60:
61: class ArrayListTest
62: {
63: public static void main(String[] args)
64: {
65: ArrayList al=new ArrayList();
66: al.add(new Person("lisi1",20));
67: al.add(new Person("lisi2",20));
68: al.add(new Person("lisi3",30));
69: al.add(new Person("lisi3",30));
70:
71: ArrayListDemo ald=new ArrayListDemo();
72:
73: al=ald.newAl(al);
74: for(Iterator it=al.iterator();it.hasNext();)
75: {
76: Object obj=it.next();
77: Person p=(Person)obj;
78:
79: System.out.println(p.getName()+"......."+p.getAge());
80:
81: }
82:
83: }
84: }
85:
