一、集合：
集合是Java API所提供的一系列類的執行個體，可以用于動态存放多個對象
為什麼要使用集合？數組的長度是固定的，存滿了就不能存了。集合可以存儲不同類型的對象，而且它的容量可以随着對象數量的增加，自動擴大。
-----------------------------------------------------------------------------------------------------------------------------------
二、List集合
List：存儲的對象是有序，可以重複的
功能：除了繼承Collection接口提供的功能之外，支援帶下标的操作
----------------------------------------------------------------------------------------------------------------------------------
增加方法：
（1）、void add(int index,E element)添加指定的對象到index的位置
（2）、boolean addAll(int index,Collection<? extends E> c)
删除方法：
（1）、E remove(int index) 删除指定位置的對象，并傳回次對象
修改方法：
（1）、E set(int index,E element)更換指定位置的對象
查詢方法：
（1）、ListIterator<E> listIterator() 傳回此清單元素的清單疊代器（按适當順序）
（2）、ListIterator<E> listIterator(int index) 傳回指定位置的對象
（3）、E get(int index) 得到指定位置的對象
注意：在疊代的過程中對集合進行添加，删除，修改，會發生ConcurrentModificationException異常
1、ArrayList：使用的資料結構是數組，線程不安全的，查找速度快，增删速度慢
示例：
1 import java.util.ArrayList;
2 import java.util.Iterator;
3 import java.util.List;
4
5 public class Demo {
6
7 public static void main(String[] args) {
8 List list = new ArrayList();
9 list.add("你好");
10 list.add("你好嗎？");
11 list.add("我很好");
12 System.out.println(list);
13
14 list.add(1, "不是很好");
15 System.out.println(list);
16
17 // 删除指定下标的元素
18 System.out.println("成功删除:" + list.remove(1));
19 System.out.println(list);
20
21 // 修改
22 list.set(1, "大家好！！！");
23 System.out.println(list);
24
25 List sub = list.subList(1, 2);
26 System.out.println(sub);
27 System.out.println(list.get(1));
28
29 // 周遊集合
30 Iterator it = list.iterator();
31 while (it.hasNext()) {
32 System.out.println(it.next());
33 }
34 System.out.println("-------------");
35 for (Iterator it1 = list.iterator(); it1.hasNext();) {
36 System.out.println(it1.next());
37 }
38 System.out.println("-------------");
39 for (Object obj : list) {
40 System.out.println(obj);
41 }
42 System.out.println("-----------");
43 for (int i = 0; i < list.size(); i++) {
44 System.out.println(list.get(i));
45 }
46
47 // 清空
48 while (!list.isEmpty()) {
49 list.remove(0);
50 }
51 System.out.println(list.size());
52
53 }
54
55 } ArrayList
2、LinkedList：使用的資料結構是連結清單，線程不安全的，查找速度慢，增删速度快
1 import java.util.LinkedList;
2
3 public class Demo {
4 public static void main(String[] args) {
5 LinkedList link = new LinkedList();
6 link.addFirst("001");
7 link.addFirst("002");
8 link.addFirst("003");
9 link.addFirst("004");
10
11 System.out.println(link);
12
13 System.out.println("getFirst:" + link.getFirst());
14 System.out.println("get後的集合" + link);
15 System.out.println("peekFirst:" + link.peekFirst());
16 System.out.println("peek後的集合" + link);
17 System.out.println("pop()" + link.pop());
18 System.out.println("pop後的集合" + link);
19
20 while (!link.isEmpty()) {
21 System.out.println(link.removeFirst());
22 }
23 System.out.println("删除後集合中的元素");
24 System.out.println(link);
25 // 集合中元素為空
26 System.out.println("getFirst:" + link.getFirst());// 抛出NoSuchElementException
27 System.out.println("peekFirst:" + link.peekFirst());// null
28
29 }
30 } View Code
3、Vector：使用的資料結構是數組，線程安全的，查找速度快，增删速度慢,被ArrayList替代了
1 import java.util.Enumeration;
2 import java.util.Vector;
3
4 public class Demo {
5 /*
6 * Vector:被ArrayList替代
7 *
8 * 效率低，線程安全的
9 */
10 public static void main(String[] args) {
11 Vector v = new Vector();
12 v.add("張三");
13 v.add("李四");
14 v.add("王五");
15 for (Object o : v) {
16 System.out.println(o);
17 }
18
19 Enumeration elements = v.elements();
20 // 周遊
21 while (elements.hasMoreElements()) {
22 Object o = elements.nextElement();
23 System.out.println(o);
24 }
25 }
26
27 } Vector
三、Set集合
Set：存儲的對象是無序的，不可以重複的
------------------------------------------------------------------------------------------------------------------------------------
1、HashSet：底層使用的資料結構是哈希表，線程不安全的
确定唯一性的原理：
1、向集合中添加對象時，會先和集合中已經存在的對象比較哈希值
2、若哈希值不同，則直接添加到集合中
3、若哈希值相同，則再調用equals()方法，此方法傳回false時，則将對象添加到集合中，反之不添加
注意：哈希值相同不一定是同一個對象，同一個對象哈希值肯定相同
1 import java.util.HashSet;
2 import java.util.Iterator;
3
4 public class Demo15 {
5
6 public static void main(String[] args) {
7 HashSet<Person> hs = new HashSet<Person>();
8 hs.add(new Person("張三", 20));
9 hs.add(new Person("張三1", 20));
10 hs.add(new Person("張三2", 20));
11 hs.add(new Person("張三3", 20));
12 hs.add(new Person("張三", 20));
13
14 // 周遊--疊代器
15 Iterator it = hs.iterator();
16 while (it.hasNext()) {
17 System.out.println(it.next());
18 }
19
20 }
21
22 static class Person {
23 private String name;
24 private int age;
25
26 public String getName() {
27 return name;
28 }
29
30 public void setName(String name) {
31 this.name = name;
32 }
33
34 public int getAge() {
35 return age;
36 }
37
38 public void setAge(int age) {
39 this.age = age;
40 }
41
42 public Person(String name, int age) {
43 super();
44 this.name = name;
45 this.age = age;
46 }
47
48 @Override
49 public String toString() {
50 return "Person [name=" + name + ", age=" + age + "]";
51 }
52
53 @Override
54 public int hashCode() {
55 final int prime = 31;
56 int result = 1;
57 result = prime * result + age;
58 result = prime * result + ((name == null) ? 0 : name.hashCode());
59 return result;
60 }
61
62 @Override
63 public boolean equals(Object obj) {
64 if (this == obj)
65 return true;
66 if (obj == null)
67 return false;
68 if (getClass() != obj.getClass())
69 return false;
70 Person other = (Person) obj;
71 if (age != other.age)
72 return false;
73 if (name == null) {
74 if (other.name != null)
75 return false;
76 } else if (!name.equals(other.name))
77 return false;
78 return true;
79 }
80
81 }
82 } HashSet重寫equals和hashcode方法
2、TreeSet：底層使用的資料結構是二叉樹，線程不安全的
確定唯一性的方式：依據compareTo()或compare()的傳回值是否為0
方式1：讓存入集合中的對象具備可比較性
（1）、類實作Comparable接口
（2）、實作接口的compareTo(Object o)方法
方式2：讓集合具備排序功能
（1）、建立Comparator接口對象，并實作其方法compare(Object o1,Object o2)方法
（2）、在建立TreeSet的構造方法中傳入Comparator對象
1 import java.util.Comparator;
2 import java.util.Set;
3 import java.util.TreeSet;
4
5 /*
6 * TreeSet:底層使用的資料結構是二叉樹，線程不安全。會對存入集合的對象進行排序。
7 *
8 * 保證加入集合的對象是可排序的：
9 * 1）讓自定義的類實作Comparable接口，int compareTo（）
10 * 2 ）自定義比較器：
11 * 建立比較器，實作Comparator接口，接口int compare（）
12 * 把比較器對象作為參數傳遞給集合的構造方法
13 * */
14 public class Demo16 {
15
16 public static void main(String[] args) {
17 /*
18 * Set tree = new TreeSet(); tree.add(13); tree.add(8); tree.add(17);
19 * tree.add(1); tree.add(11); tree.add(15); System.out.println(tree);
20 */
21
22 Set<Dog> set = new TreeSet<Dog>();
23 set.add(new Dog("大黃", 3));
24 set.add(new Dog("大黃1", 2));
25 set.add(new Dog("大黃2", 1));
26 set.add(new Dog("大黃9", 6));
27 set.add(new Dog("大黃4", 6));
28 System.out.println(set);
29 System.out.println("---------------");
30 // 建立比較器對象
31 MyCompare mc = new MyCompare();
32 TreeSet ts = new TreeSet(mc);
33 ts.add(new Dog("大黃1", 3));
34 ts.add(new Dog("大黃1", 2));
35 ts.add(new Dog("大黃2", 1));
36 ts.add(new Dog("大黃9", 6));
37
38 System.out.println(ts);
39
40 }
41
42 }
43
44 class Dog implements Comparable {
45 private String name;
46 private int age;
47
48 public String getName() {
49 return name;
50 }
51
52 public void setName(String name) {
53 this.name = name;
54 }
55
56 public int getAge() {
57 return age;
58 }
59
60 public void setAge(int age) {
61 this.age = age;
62 }
63
64 public Dog(String name, int age) {
65 super();
66 this.name = name;
67 this.age = age;
68 }
69
70 public Dog() {
71 super();
72 }
73
74 @Override
75 public String toString() {
76 return "Dog [name=" + name + ", age=" + age + "]";
77 }
78
79 @Override
80 public int hashCode() {
81 final int prime = 31;
82 int result = 1;
83 result = prime * result + age;
84 result = prime * result + ((name == null) ? 0 : name.hashCode());
85 return result;
86 }
87
88 @Override
89 public boolean equals(Object obj) {
90 if (this == obj)
91 return true;
92 if (obj == null)
93 return false;
94 if (getClass() != obj.getClass())
95 return false;
96 Dog other = (Dog) obj;
97 if (age != other.age)
98 return false;
99 if (name == null) {
100 if (other.name != null)
101 return false;
102 } else if (!name.equals(other.name))
103 return false;
104 return true;
105 }
106
107 @Override
108 public int compareTo(Object o) {
109 Dog d = (Dog) o;
110 if (this.age < d.age)
111 return -1;
112 else if (this.age > d.age)
113 return 1;
114 else
115 return this.name.compareTo(d.name); // 年齡相同再繼續比較姓名
116 }
117
118 }
119
120 // 自定義比較器
121 // 比較名字是否相等,如果名字相同再按照年齡排序
122 class MyCompare implements Comparator {
123
124 @Override
125 public int compare(Object o1, Object o2) {
126 if (!(o1 instanceof Dog))
127 throw new ClassCastException("類型轉換出錯");
128 if (!(o2 instanceof Dog))
129 throw new ClassCastException("類型轉換出錯");
130 Dog d1 = (Dog) o1;
131 Dog d2 = (Dog) o2;
132 int n = d1.getName().compareTo(d2.getName());
133 return n == 0 ? d1.getAge() - d2.getAge() : n;
134 }
135 } 類繼承比較接口
1 import java.util.Comparator;
2 import java.util.Iterator;
3 import java.util.TreeSet;
4
5 public class Demo18 {
6 public static void main(String[] args) {
7 TreeSet<Person> ts = new TreeSet<Person>(new Comparator<Person>() {
8
9 // 比較年齡，然後在比較姓名
10 @Override
11 public int compare(Person o1, Person o2) {
12 int n = o1.getAge() - o2.getAge();
13 if (n == 0) { // 年齡相等
14 return o1.getName().compareTo(o2.getName()); // 在比較姓名
15 }
16 return n;
17 }
18 });
19 ts.add(new Person("張三4", 39));
20 ts.add(new Person("張三1", 39));
21 ts.add(new Person("張三2", 19));
22 ts.add(new Person("張三3", 27));
23 ts.add(new Person("張三4", 27));
24 ts.add(new Person("張三4", 27));
25
26 Iterator<Person> it = ts.iterator();
27 while (it.hasNext()) {
28 System.out.println(it.next());
29 }
30
31 }
32 }
33
34 class Person {
35 private String name;
36 private int age;
37
38 public String getName() {
39 return name;
40 }
41
42 public void setName(String name) {
43 this.name = name;
44 }
45
46 public int getAge() {
47 return age;
48 }
49
50 @Override
51 public String toString() {
52 return "Person [name=" + name + ", age=" + age + "]";
53 }
54
55 public void setAge(int age) {
56 this.age = age;
57 }
58
59 public Person(String name, int age) {
60 super();
61 this.name = name;
62 this.age = age;
63 }
64
65 } 匿名比較類
四、Map
Map：一個單獨的接口，存儲的是鍵值對，鍵不可以重複,無序的
特點：
1、建立Comparator接口對象，并實作其方法compare(Object o1,Object o2)方法
2、存入HashMap中的映射對的“鍵”的類型必須是引用類型（除數組外）
3、是以存入HashMap中的映射對的“鍵”如果是自定義的類,應該重寫hashCode()和equals()方法
4、常用String作為Map的“鍵”
方法：
1、添加
①V put(K key, V value) //将指定的“鍵-值”對存入Map中
②void putAll(Map<? extends K,? extends V> m)
2、删除
①void putAll(Map<? extends K,? extends V> m)
②void clear(); //清空Map中的所有“鍵-值”對。
3、擷取
①V get(Object key); //傳回指定鍵所映射的值
②Set<K> keySet(); //傳回此Map中包含的鍵的Set集。
③int size(); //獲得些Map中“鍵-值”對的數量。
④Set<Entry<K, V>> entrySet() 傳回此Map的鍵-值對内容的Set集合
⑤Collection<V> values(); //傳回此Map中包含的值的Collection集。值是可重複的.
4、判斷
①boolean isEmpty(); //判斷此Map中是否有元素。
②boolean containsKey(Object key); //判斷此Map是否包含指定鍵的“鍵-值”對。
③boolean containsValue(Object value);//判斷此Map是否包含指定值的“鍵-值”對。
1、HashMap：保證鍵唯一的原理和HashSet一樣，hashCode(),equals()
2、TreeMap：是根據鍵來排序的,保證鍵唯一的原理和TreeSet相同,依據 compareTo()或compare()的傳回值是否為0，為0就認為是重複鍵
Map.Entry接口：
Map.Entry是Map中内部定義的一個static接口，專門用來儲存key-value的内容
1 Set<Map.Entry<Cat, String>> entrySet = map.entrySet();
2 Iterator<Map.Entry<Cat, String>> it = entrySet.iterator();
3 while (it.hasNext()) {
4 Map.Entry<Cat, String> en = it.next();
5 System.out.println(en.getKey() + "---" + en.getValue());
6 } Map.Entry
五、Collection接口
說明：是List接口和Set接口的父接口
1、添加方法
（1）、boolean add(Object o) 增加對象到集合中
（2）、boolean addAll(Collection<? extends E> c) 增加所有其它集合中對象
2、删除方法
（1）、boolean remove(Object o) 從集合中删除對象
（2）、boolean removeAll(Collection<?> c) 從集合中删除所有指定集合包含的對象
（3）、void clear() 清空集合
3、判斷方法
（1）、boolean contains(Object o) 判斷是否集合中是否包含指定對象
（2）、boolean containsAll(Collection<?> c) 判斷集合是否包含指定集合中所有對象
（3）、boolean isEmpty() //判斷集合是否為空
（4）、boolean equals(Object o) 判斷集合是否與某對象相同
4、擷取方法
（1）、Iterator<E> iterator() //擷取集合中的對象
（2）、int size() //擷取集合中對象的個數
5、轉換方法
（1）、 Object[] toArray() 将集合轉換成數組
1 import java.util.ArrayList;
2 import java.util.Collection;
3 import java.util.Iterator;
4
5 public class Demo3 {
6 /*
7 * 周遊集合：---Iterator疊代器，判斷是否存在下一個元素（hasNext（）），如果存在，取出（next（）） Iterator接口
8 */
9 public static void main(String[] args) {
10 Collection col = new ArrayList();
11 col.add("anc");
12 col.add("aaa");
13 col.add("ddd");
14 col.add("eeee");
15
16 // 擷取集合對象的疊代器
17 Iterator it = col.iterator();
18 // 判斷是否存下一個元素
19 while (it.hasNext()) {
20 Object o = it.next();
21 System.out.println(o);// 獲得元素
22
23 // col.remove(o);// 抛異常
24
25 it.remove();// 删除next最後一次擷取的對象，如果使用疊代器周遊集合，必須使用疊代器的remove方法删除元素
26 }
27 System.out.println("------------");
28 for (Object o : col) {
29 System.out.println(o);
30 }
31
32 }
33
34 } Collection
六、Iterator接口
作用：周遊集合中的對象
原理：先對元素進行判斷，判斷是否有内容，如果有内容則把内容取出
特點：隻能讀取和删除，不能添加、修改
方法：（1）boolean hasNext() 是否存在下一個對象（2）E next() 擷取下一個對象（3）void remove() 删除最近next之後擷取的對象
eg:
1 // 擷取集合對象的疊代器
2 Iterator it = col.iterator();
3 // 判斷是否存下一個元素
4 while (it.hasNext()) {
5 Object o = it.next();
6 System.out.println(o);// 獲得元素
7 it.remove();// 删除next最後一次擷取的對象，如果使用疊代器周遊集合，必須使用疊代器的remove方法删除元素
8 } Iterator