集合详解：
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()); } } }