集合详解：
1 /*
2 Collection
3 |--List:元素是有序的，元素可以重复。因为该集合体系有索引。
4 |--ArrayList:底层的数据结构使用的是数组结构。特点：查询速度很快。但是增删稍慢。线程不同步。
5 |--LinkedList:底层使用的链表数据结构。特点：增删速度很快，查询稍慢。线程不同步。
6 |--Vector:底层是数组数据结构。线程同步。被ArrayList替代了。因为效率低。
7
8
9 |--Set：元素是无序，元素不可以重复。、
10
11
12 List：
13 特有方法。凡是可以操作角标的方法都是该体系特有的方法。
14
15 增
16 add(index,element);
17 addAll(index,Collection);
18
19 删
20 remove(index);
21
22 改
23 set(index,element);
24 查
25 get(index):
26 subList(from,to);
27 listIterator();
28 int indexOf(obj):获取指定元素的位置。
29 ListIterator listIterator();
30
31
32
33
34
35 List集合特有的迭代器。ListIterator是Iterator的子接口。
36
37 在迭代时，不可以通过集合对象的方法操作集合中的元素。
38 因为会发生ConcurrentModificationException异常。
39
40 所以，在迭代器时，只能用迭代器的放过操作元素，可是Iterator方法是有限的，
41 只能对元素进行判断，取出，删除的操作，
42 如果想要其他的操作如添加，修改等，就需要使用其子接口，ListIterator。
43
44 该接口只能通过List集合的listIterator方法获取。
45
46 */
47
48 /*
49 |--Set：元素是无序(存入和取出的顺序不一定一致)，元素不可以重复。、
50 |--HashSet:底层数据结构是哈希表。是线程不安全的。不同步。
51 HashSet是如何保证元素唯一性的呢？
52 是通过元素的两个方法，hashCode和equals来完成。
53 如果元素的HashCode值相同，才会判断equals是否为true。
54 如果元素的hashcode值不同，不会调用equals。
55
56 注意,对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashcode和equals方法。
57
58
59 |--TreeSet：
60
61 Set集合的功能和Collection是一致的。
62
63
64
65
66 */
1 /*
2 Collection
3 |--List:元素是有序的，元素可以重复。因为该集合体系有索引。
4 |--ArrayList:底层的数据结构使用的是数组结构。特点：查询速度很快。但是增删稍慢。线程不同步。
5 |--LinkedList:底层使用的链表数据结构。特点：增删速度很快，查询稍慢。线程不同步。
6 |--Vector:底层是数组数据结构。线程同步。被ArrayList替代了。因为效率低。
7
8
9 |--Set：元素是无序，元素不可以重复。、
10
11
12 List：
13 特有方法。凡是可以操作角标的方法都是该体系特有的方法。
14
15 增
16 add(index,element);
17 addAll(index,Collection);
18
19 删
20 remove(index);
21
22 改
23 set(index,element);
24 查
25 get(index):
26 subList(from,to);
27 listIterator();
28 int indexOf(obj):获取指定元素的位置。
29 ListIterator listIterator();
30
31
32
33
34
35 List集合特有的迭代器。ListIterator是Iterator的子接口。
36
37 在迭代时，不可以通过集合对象的方法操作集合中的元素。
38 因为会发生ConcurrentModificationException异常。
39
40 所以，在迭代器时，只能用迭代器的放过操作元素，可是Iterator方法是有限的，
41 只能对元素进行判断，取出，删除的操作，
42 如果想要其他的操作如添加，修改等，就需要使用其子接口，ListIterator。
43
44 该接口只能通过List集合的listIterator方法获取。
45
46 */
47
48
49 import java.util.*;
50 class ListDemo
51 {
52 public static void sop(Object obj)
53 {
54 System.out.println(obj);
55 }
56 public static void method()
57 {
58
59 ArrayList al = new ArrayList();
60
61 //添加元素
62 al.add("java01");
63 al.add("java02");
64 al.add("java03");
65
66 sop("原集合是："+al);
67 //在指定位置添加元素。
68 al.add(1,"java09");
69
70 //删除指定位置的元素。
71 //al.remove(2);
72
73 //修改元素。
74 //al.set(2,"java007");
75
76 //通过角标获取元素。
77 sop("get(1):"+al.get(1));
78
79 sop(al);
80
81 //获取所有元素。
82 for(int x=0; x<al.size(); x++)
83 {
84 System.out.println("al("+x+")="+al.get(x));
85 }
86
87 Iterator it = al.iterator();
88
89 while(it.hasNext())
90 {
91 sop("next:"+it.next());
92 }
93
94
95 //通过indexOf获取对象的位置。
96 sop("index="+al.indexOf("java02"));
97
98 List sub = al.subList(1,3);
99
100 sop("sub="+sub);
101 }
102
103
104 public static void main(String[] args)
105 {
106
107 //演示列表迭代器。
108 ArrayList al = new ArrayList();
109
110 //添加元素
111 al.add("java01");
112 al.add("java02");
113 al.add("java03");
114
115 sop(al);
116
117
118 ListIterator li = al.listIterator();
119
120
121 //sop("hasPrevious():"+li.hasPrevious());
122
123 while(li.hasNext())
124 {
125 Object obj = li.next();
126
127 if(obj.equals("java02"))
128 //li.add("java009");
129 li.set("java006");
130
131
132 }
133
134 while(li.hasPrevious())
135 {
136 sop("pre::"+li.previous());
137 }
138 //sop("hasNext():"+li.hasNext());
139 //sop("hasPrevious():"+li.hasPrevious());
140
141
142 sop(al);
143
144
145
146 /*
147 //在迭代过程中，准备添加或者删除元素。
148
149 Iterator it = al.iterator();
150
151 while(it.hasNext())
152 {
153 Object obj = it.next();
154
155 if(obj.equals("java02"))
156 //al.add("java008");
157 it.remove();//将java02的引用从集合中删除了。
158
159 sop("obj="+obj);
160
161
162 }
163 sop(al);
164 */
165
166
167
168 }
169 }
1 import java.util.*;
2
3 /*
4 去除ArrayList集合中的重复元素。
5
6 */
7
8 class ArrayListTest
9 {
10
11 public static void sop(Object obj)
12 {
13 System.out.println(obj);
14 }
15 public static void main(String[] args)
16 {
17 ArrayList al = new ArrayList();
18
19 al.add("java01");
20 al.add("java02");
21 al.add("java01");
22 al.add("java02");
23 al.add("java01");
24 // al.add("java03");
25
26
27 /*
28 在迭代时循环中next调用一次，就要hasNext判断一次。
29 Iterator it = al.iterator();
30
31 while(it.hasNext())
32 {
33 sop(it.next()+"...."+it.next());
34 }
35 */
36
37 /**/
38 sop(al);
39
40 al = singleElement(al);
41
42 sop(al);
43
44
45 }
46
47 public static ArrayList singleElement(ArrayList al)
48 {
49 //定义一个临时容器。
50 ArrayList newAl = new ArrayList();
51
52 Iterator it = al.iterator();
53
54 while(it.hasNext())
55 {
56 Object obj = it.next();
57
58 if(!newAl.contains(obj))
59 newAl.add(obj);
60
61 }
62
63 return newAl;
64 }
65 }
1 import java.util.*;
2
3 /*
4 将自定义对象作为元素存到ArrayList集合中，并去除重复元素。
5
6 比如：存人对象。同姓名同年龄，视为同一个人。为重复元素。
7
8
9 思路：
10 1，对人描述，将数据封装进人对象。
11 2，定义容器，将人存入。
12 3，取出。
13
14
15
16 List集合判断元素是否相同，依据是元素的equals方法。
17
18
19
20 */
21
22
23
24 class Person
25 {
26 private String name;
27 private int age;
28 Person(String name,int age)
29 {
30 this.name = name;
31 this.age = age;
32 }
33
34 public boolean equals(Object obj)
35 {
36
37 if(!(obj instanceof Person))
38 return false;
39
40 Person p = (Person)obj;
41 //System.out.println(this.name+"....."+p.name);
42
43 return this.name.equals(p.name) && this.age == p.age;
44 }
45 /**/
46 public String getName()
47 {
48 return name;
49 }
50 public int getAge()
51 {
52 return age;
53 }
54 }
55 class ArrayListTest2
56 {
57 public static void sop(Object obj)
58 {
59 System.out.println(obj);
60 }
61 public static void main(String[] args)
62 {
63 ArrayList al = new ArrayList();
64
65 al.add(new Demo());
66
67 al.add(new Person("lisi01",30));//al.add(Object obj);//Object obj = new Person("lisi01",30);
68 //al.add(new Person("lisi02",32));
69 al.add(new Person("lisi02",32));
70 al.add(new Person("lisi04",35));
71 al.add(new Person("lisi03",33));
72 //al.add(new Person("lisi04",35));
73
74
75 //al = singleElement(al);
76
77 sop("remove 03 :"+al.remove(new Person("lisi03",33)));//remove方法底层也是依赖于元素的equals方法。
78
79
80 Iterator it = al.iterator();
81
82
83 while(it.hasNext())
84 {
85 Person p = (Person)it.next();
86 sop(p.getName()+"::"+p.getAge());
87 }
88 }
89
90
91 public static ArrayList singleElement(ArrayList al)
92 {
93 //定义一个临时容器。
94 ArrayList newAl = new ArrayList();
95
96 Iterator it = al.iterator();
97
98 while(it.hasNext())
99 {
100 Object obj = it.next();
101
102 if(!newAl.contains(obj))
103 newAl.add(obj);
104
105 }
106
107 return newAl;
108 }
109 }
1 import java.util.*;
2
3 /*
4 Collection定义了集合框架的共性功能。
5 1，添加
6 add(e);
7 addAll(collection);
8
9 2，删除
10 remove(e);
11 removeAll(collection);
12 clear();
13
14 3，判断。
15 contains(e);
16 isEmpty();
17
18 4，获取
19 iterator();
20 size();
21
22 5，获取交集。
23 retainAll();
24
25 6，集合变数组。
26 toArray();
27
28
29
30 1，add方法的参数类型是Object。以便于接收任意类型对象。
31
32 2，集合中存储的都是对象的引用(地址)
33
34
35 什么是迭代器呢？
36 其实就是集合的取出元素的方式。
37 如同抓娃娃游戏机中的夹子。
38
39 迭代器是取出方式，会直接访问集合中的元素。
40 所以将迭代器通过内部类的形式来进行描述。
41 通过容器的iterator()方法获取该内部类的对象。
42
43
44
45
46 */
47 class CollectionDemo
48 {
49 public static void main(String[] args)
50 {
51
52 method_get();
53 }
54 public static void method_get()
55 {
56 ArrayList al = new ArrayList();
57
58 //1，添加元素。
59 al.add("java01");//add(Object obj);
60 al.add("java02");
61 al.add("java03");
62 al.add("java04");
63
64 /*
65 Iterator it = al.iterator();//获取迭代器，用于取出集合中的元素。
66
67 while(it.hasNext())
68 {
69 sop(it.next());
70 }
71 */
72
73 for(Iterator it = al.iterator(); it.hasNext() ; )
74 {
75 sop(it.next());
76 }
77 }
78
79
80 public static void method_2()
81 {
82 ArrayList al1 = new ArrayList();
83
84 al1.add("java01");
85 al1.add("java02");
86 al1.add("java03");
87 al1.add("java04");
88 ArrayList al2 = new ArrayList();
89
90 al2.add("java03");
91 al2.add("java04");
92 al2.add("java05");
93 al2.add("java06");
94
95
96 //al1.retainAll(al2);//去交集，al1中只会保留和al2中相同的元素。
97 al1.removeAll(al2);
98
99 sop("al1:"+al1);
100 sop("al2:"+al2);
101
102
103
104
105 }
106
107 public static void base_method()
108 {
109 //创建一个集合容器。使用Collection接口的子类。ArrayList
110 ArrayList al = new ArrayList();
111
112 //1，添加元素。
113 al.add("java01");//add(Object obj);
114 al.add("java02");
115 al.add("java03");
116 al.add("java04");
117
118 //打印原集合。
119 sop("原集合:"+al);
120
121
122 //3，删除元素。
123 //al.remove("java02");
124 //al.clear();//清空集合。
125
126
127 //4，判断元素。
128 sop("java03是否存在:"+al.contains("java03"));
129 sop("集合是否为空？"+al.isEmpty());
130
131
132 //2，获取个数。集合长度。
133 sop("size:"+al.size());
134
135 //打印改变后的集合。
136 sop(al);
137
138 }
139
140 public static void sop(Object obj)
141 {
142 System.out.println(obj);
143 }
144 }
1 import java.util.*;
2 /*
3 |--Set：元素是无序(存入和取出的顺序不一定一致)，元素不可以重复。、
4 |--HashSet:底层数据结构是哈希表。是线程不安全的。不同步。
5 HashSet是如何保证元素唯一性的呢？
6 是通过元素的两个方法，hashCode和equals来完成。
7 如果元素的HashCode值相同，才会判断equals是否为true。
8 如果元素的hashcode值不同，不会调用equals。
9
10 注意,对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashcode和equals方法。
11
12
13 |--TreeSet：
14
15 Set集合的功能和Collection是一致的。
16
17
18
19
20 */
21
22
23 class HashSetDemo
24 {
25 public static void sop(Object obj)
26 {
27 System.out.println(obj);
28 }
29 public static void main(String[] args)
30 {
31
32 HashSet hs = new HashSet();
33
34 sop(hs.add("java01"));
35 sop(hs.add("java01"));
36 hs.add("java02");
37 hs.add("java03");
38 hs.add("java03");
39 hs.add("java04");
40
41 Iterator it = hs.iterator();
42
43 while(it.hasNext())
44 {
45 sop(it.next());
46 }
47 }
48 }
1 import java.util.*;
2
3 /*
4 往hashSet集合中存入自定对象
5 姓名和年龄相同为同一个人，重复元素。
6
7
8
9
10
11 */
12 class HashSetTest
13 {
14 public static void sop(Object obj)
15 {
16 System.out.println(obj);
17 }
18 public static void main(String[] args)
19 {
20 HashSet hs = new HashSet();
21
22 hs.add(new Person("a1",11));
23 hs.add(new Person("a2",12));
24 hs.add(new Person("a3",13));
25 // hs.add(new Person("a2",12));
26 // hs.add(new Person("a4",14));
27
28 //sop("a1:"+hs.contains(new Person("a2",12)));
29
30 // hs.remove(new Person("a4",13));
31
32
33 Iterator it = hs.iterator();
34
35 while(it.hasNext())
36 {
37 Person p = (Person)it.next();
38 sop(p.getName()+"::"+p.getAge());
39 }
40 }
41 }
42 class Person
43 {
44 private String name;
45 private int age;
46 Person(String name,int age)
47 {
48 this.name = name;
49 this.age = age;
50 }
51
52 public int hashCode()
53 {
54 System.out.println(this.name+"....hashCode");
55 return name.hashCode()+age*37;
56 }
57
58 public boolean equals(Object obj)
59 {
60
61 if(!(obj instanceof Person))
62 return false;
63
64 Person p = (Person)obj;
65 System.out.println(this.name+"...equals.."+p.name);
66
67 return this.name.equals(p.name) && this.age == p.age;
68 }
69
70
71 public String getName()
72 {
73 return name;
74 }
75 public int getAge()
76 {
77 return age;
78 }
79 }
80
81 /*
82
83
84 */
1 import java.util.*;
2
3 /*
4 LinkedList:特有方法：
5 addFirst();
6 addLast();
7
8 getFirst();
9 getLast();
10 获取元素，但不删除元素。如果集合中没有元素，会出现NoSuchElementException
11
12 removeFirst();
13 removeLast();
14 获取元素，但是元素被删除。如果集合中没有元素，会出现NoSuchElementException
15
16
17 在JDK1.6出现了替代方法。
18
19 offerFirst();
20 offerLast();
21
22
23 peekFirst();
24 peekLast();
25 获取元素，但不删除元素。如果集合中没有元素，会返回null。
26
27 pollFirst();
28 pollLast();
29 获取元素，但是元素被删除。如果集合中没有元素，会返回null。
30
31
32
33
34 */
35
36 class LinkedListDemo
37 {
38 public static void main(String[] args)
39 {
40 LinkedList link = new LinkedList();
41
42 link.addLast("java01");
43 link.addLast("java02");
44 link.addLast("java03");
45 link.addLast("java04");
46
47 //sop(link);
48 // sop(link.getFirst());
49 // sop(link.getFirst());
50 //sop(link.getLast());
51 //sop(link.removeFirst());
52 //sop(link.removeFirst());
53
54 //sop("size="+link.size());
55
56 while(!link.isEmpty())
57 {
58 sop(link.removeLast());
59 }
60
61 }
62
63 public static void sop(Object obj)
64 {
65 System.out.println(obj);
66 }
67 }
68 /*
69
70 ---
71 java01
72 java02
73 java03
74 java04
75
76 ----
77 java04
78 java03
79 java02
80 java01
81 ---
82 */
/*
使用LinkedList模拟一个堆栈或者队列数据结构。
堆栈：先进后出 如同一个杯子。
队列：先进先出 First in First out FIFO 如同一个水管。
*/
import java.util.*;
class DuiLie
{
private LinkedList link;
DuiLie()
{
link = new LinkedList();
}
public void myAdd(Object obj)
{
link.addFirst(obj);
}
public Object myGet()
{
return link.removeFirst();
}
public boolean isNull()
{
return link.isEmpty();
}
}
class LinkedListTest
{
public static void main(String[] args)
{
DuiLie dl = new DuiLie();
dl.myAdd("java01");
dl.myAdd("java02");
dl.myAdd("java03");
dl.myAdd("java04");
while(!dl.isNull())
{
System.out.println(dl.myGet());
}
}
}