# 集合框架
[TOC]
## 什么是集合
Java中的集合是工具類，可以存儲任意數量的具有共同屬性的對象。
>[info] 集合類存放于java.util包中。
> 集合類存放的都是對象的引用，而非對象本身，出于表達上的便利，我們稱集合中的對象就是指集合中對象的引用
>[success] 在集合框架中，主要分為 Collection 和 Map 兩大接口。
> 在 Collection 中又分為 List （有序集合） 和 Set （無序集合）。List 和 Set 都是接口。
> 其中Collection存儲的是元素，Map存儲的key-value鍵值對。
>[warning] 集合框架存儲的元素可以是不定長的，即可以任意的添加，但是數組在定義的時候就確定了長度。實際開發中，對于同類型數據的結構，一般使用 Collection 結構會較多。
## Collection
在Collection中，根據不同的數據結構是使用方法，分為Set（無序的數據集合，元素不可重復）、Queue（隊列）、List（有序的集合，元素可以重復）。
在Collection中的定義中Interface Collection，是一種泛型結構，意思是在使用Collection定義對象的時候，需要指定存儲的元素數據類型（強調：**在集合中存儲的數據元素必須都是引用數據類型**）。
### List
list中的內容是有序的并且可以重復的，我們也稱之為序列；
list可以精確的控制每個元素的插入位置，或者刪除某個位置的元素；
>[info] 是實際開發中用的最多的一種數據結構，存儲的單個元素，使用**泛型**去強制約束 List 中存放的是一致的數據類型
> 在List接口中，最常用的實現類為ArrayList和LinkedList，其中ArrayList是運用最多的。
**語法**
~~~
List<E> list = new ArrayList<E>();
~~~
**插入元素**
add()
**遍歷元素**
* 通過元素索引下標方式 for 循環
* 通過 foreach 循環
* 通過迭代器 Iterator
**刪除元素**
如果通過遍歷去查找相關元素進行刪除的時候，不要使用 list.remove(int index) 該方法，因為使用該方法，會動態的直接改變集合的元素結構，導致遍歷的不完整或者有錯誤。要使用迭代器遍歷集合，調用 Iterator.remove() 方法刪除。
### Set
不詳細闡述，在遍歷的時候不能使用索引方式，只能通過迭代器和 foreach。
## Map
類似的可以理解給集合元素中的值定義了一個 Key 鍵（遍歷），之后可以通過相關的方法快速的定位到具體的 Value 中。
Map中存儲是key-value鍵值對，在Map接口中，我們主要使用的實現類為HashMap。
在使用HashMap類的時候，插入的順序和最后遍歷出來的順序可以是有差異的，因為本身HashMap結構它是無序的。
通過map.put(key, value)方法進去數據的寫入，同樣的要注意使用泛型。（強調：**Map中的key鍵和value值的數據元素必須都是引用數據類型**）。
* * *
**語法**
~~~
Map<k,v> map= new HashMap<k,v>();
~~~
Map集合中的一些注意點：
* key必須是唯一的，不唯一，那么后面的value會把前面的value覆蓋
* 對于HashMap，key可以為空，value可以為空，也可以不為空
* HashTable的key和value不能為空
* properties的key和value必須為String類型的
**獲取某個 key 的 value**
Value get(Key)
**如何遍歷 Map 結構**
獲取 Map 的 Key 集合，通過遍歷 Key 集合，獲取 Value 值。
1. 獲取 key 集合：map.keySet()；
2. 遍歷 Key 集合：iterator；
3. 獲取 Value 值：get(key)；
## 開發注意事項
在實際開發中，List 一般使用 ArrayList 實現類去構建，Map 一般使用 HashMap 實現類去構建。
要掌握對于 List 和 Map 的添加元素、遍歷元素。
要認識集合框架中關于對象在內存中的存儲方法。
## 本節課的代碼片段
**代碼運行內存圖**
Clazz.java
~~~
package com.ntqingniao.j96.bean;
import java.util.List;
public class Clazz {
private String name;
private String code;
private List<Student> students;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getCode() {
return code;
}
public void setCode(String code) {
this.code = code;
}
public List<Student> getStudents() {
return students;
}
public void setStudents(List<Student> students) {
this.students = students;
}
}
~~~
Clazz2.java
~~~
package com.ntqingniao.j96.bean;
import java.util.Map;
public class Clazz2 {
private String name;
private String code;
private Map<String, Student> stus;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getCode() {
return code;
}
public void setCode(String code) {
this.code = code;
}
public Map<String, Student> getStus() {
return stus;
}
public void setStus(Map<String, Student> stus) {
this.stus = stus;
}
}
~~~
Client.java
~~~
package com.ntqingniao.j96.bean;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class Client {
public static void main(String[] args) {
Student pxj = new Student("彭賢君", "001");
Student hjn = new Student("黃佳男", "002");
Clazz j96 = new Clazz();
j96.setName("Java96班");
j96.setCode("java96");
// Step1：學生類型的集合定義完成了
List<Student> stus = new ArrayList<Student>();
// Step2: 添加數據
stus.add(pxj);
stus.add(hjn);
// Step3: 追加一個新的學生
Student ljn = new Student("陸佳楠", "003");
stus.add(ljn);
// Step4: 設置班級學生屬性
j96.setStudents(stus);
// for (int i = 0; i < j96.getStudents().size(); i++) {
// Student stu = j96.getStudents().get(i);
// if (stu.getName().equals("黃佳男")) {
// stu.setCode("004");
// }
// }
// for (int i = 0; i < j96.getStudents().size(); i++) {
// // 打印對象，如果沒有顯式的調用toString()方法，編譯器也會執行toString();
// System.out.println(j96.getStudents().get(i));
// }
//
// for (int i = 0; i < stus.size(); i++) {
// System.out.println(stus.get(i));
// }
//
// for (Student stu : stus) {
// System.out.println(stu);
// }
//
// for (Student stu : stus) {
// if (stu.getName().equals("黃佳男")) {
// stu.setCode("005");
// }
// }
// for (int i = 0; i < j96.getStudents().size(); i++) {
// Student stu = j96.getStudents().get(i);
// System.out.println(stu.getName());
// if (stu.getName().equals("彭賢君")) {
// j96.getStudents().remove(i); // 這樣的實現是有問題的
// System.out.println(j96.getStudents().size());
// }
// }
//
// for (Student stu : stus) {
// System.out.println(stu);
// }
// 使用迭代器遍歷
// Step1:創建迭代器
Iterator<Student> it = stus.iterator();
while (it.hasNext()) {
Student stu = it.next();
System.out.println(stu);
if (stu.getName().equals("黃佳男")) {
it.remove();
}
}
System.out.println("處理完的結果======================");
it = stus.iterator();
while (it.hasNext()) {
Student stu = it.next();
System.out.println(stu);
}
}
}
~~~
Client2.java
~~~
package com.ntqingniao.j96.bean;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class Client2 {
public static void main(String[] args) {
Student pxj = new Student("彭賢君", "001");
Student hjn = new Student("黃佳男", "002");
Clazz2 j96 = new Clazz2();
j96.setName("Java96班");
j96.setCode("java96");
Map<String, Student> stus = new HashMap<String, Student>();
stus.put("001", pxj);
stus.put("002", hjn);
j96.setStus(stus);
Student stu = stus.get("001");
System.out.println(stu.getName());
System.out.println(stus.containsKey("003"));
// 遍歷Map
// 第一步：獲取Map中的Key集合
Set<String> keySet = stus.keySet();
// 第二步：迭代Key集合
Iterator<String> keyIt = keySet.iterator();
while (keyIt.hasNext()) {
String key = keyIt.next();
// 根據Key獲取Value
Student value = stus.get(key);
System.out.println(key + "=" + value);
}
}
}
~~~
Client3.java
~~~
package com.ntqingniao.j96.bean;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class Client3 {
public static void main(String[] args) {
Student pxj = new Student("彭賢君", "10", 20);
Student hjn = new Student("黃佳男", "008",19);
Student liuxiaowei = new Student("劉曉衛", "002",22);
Student liuxiaowei2 = new Student("劉曉衛", "005",15);
Student liuxiaowei3 = new Student("劉曉衛", "001",25);
Student liuxiaowei4 = new Student("劉曉衛", "004",13);
List<Student> stus = new ArrayList<Student>();
stus.add(pxj);
stus.add(hjn);
stus.add(liuxiaowei);
stus.add(liuxiaowei2);
stus.add(liuxiaowei3);
stus.add(liuxiaowei4);
Collections.sort(stus);
for(Student stu : stus) {
System.out.println(stu);
}
}
}
~~~
Student.java
~~~
package com.ntqingniao.j96.bean;
public class Student implements Comparable<Student>{
private String name;
private String code;
private int age;
public Student(String name, String code) {
super();
this.name = name;
this.code = code;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getCode() {
return code;
}
public void setCode(String code) {
this.code = code;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Student(String name, String code, int age) {
super();
this.name = name;
this.code = code;
this.age = age;
}
@Override
public String toString() {
return "Student [name=" + name + ", code=" + code + ", age=" + age + "]";
}
@Override
public int compareTo(Student o) {
if (this.age > o.age) {
return 1;
} else if (this.age == o.age) {
return 0;
} else {
return -1;
}
}
}
~~~
**撲克牌實例程序**
>[danger] 由于出現花色特殊的字符，需要把Java文件的字符編碼定義為 UTF-8
Constants.java
~~~
package com.ntqingniao.j96.bean;
public class Constants {
public static String[] FOLLOWS = {"?","?","?","?"};
public static int[] NUMBERS = {2,3,4,5,6,7,8,9,10,11,12,13,14};
public static String[] NUMBERS_STR = {"2","3","4","5","6","7","8","9","10","J","Q","K","A"};
}
~~~
Poker.java
~~~
package com.ntqingniao.j96.bean;
public class Poker {
private String follow;
private int number;
public int compare(Poker p1, Poker p2) {
return 0;
}
public Poker(String follow, int number) {
super();
this.follow = follow;
this.number = number;
}
public String getFollow() {
return follow;
}
public void setFollow(String follow) {
this.follow = follow;
}
public int getNumber() {
return number;
}
public void setNumber(int number) {
this.number = number;
}
@Override
public String toString() {
return this.getFollow() + Constants.NUMBERS_STR[this.getNumber()-2];
}
}
~~~
Client4.java
~~~
package com.ntqingniao.j96.bean;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class Client4 {
public static void main(String[] args) {
List<Poker> pokers = new ArrayList<Poker>();
for (String follow : Constants.FOLLOWS) {
for (int number : Constants.NUMBERS) {
Poker poker = new Poker(follow, number);
pokers.add(poker);
}
}
int i = 0;
for (Poker poker : pokers) {
System.out.print(poker + " ");
i++;
if (i % 13 == 0) {
System.out.println();
}
}
System.out.println("==========洗牌==========");
for (int j = 0; j < 5; j++) {
System.out.println("===========第" + (j + 1) + "副牌==========");
Collections.shuffle(pokers);
i = 0;
for (Poker poker : pokers) {
System.out.print(poker + " ");
i++;
if (i % 13 == 0) {
System.out.println();
}
}
}
}
}
~~~
## 練習
1. **定義一個方法listTest(ArrayList al, Integer s)，要求返回s在al里面第一次出現的索引，如果s沒出現過返回-1。**
~~~java
import java.util.ArrayList;
import java.util.List;
public class ListTestDemo {
public static void main(String[] args) {
List<Integer> list = new ArrayList<Integer>();
list.add(7);
list.add(4);
list.add(2);
list.add(1);
list.add(5);
list.add(2);
System.out.println(ListTest(list, 2));
System.out.println(list.indexOf(7));
}
public static int ListTest(List<Integer> al, Integer s) {
for(int i = 0; i < al.size(); i++) {
if(al.get(i).equals(s)) {//此時集合中和s都是引用數據類型。判斷是否相等采用的是equals方法
return i;
}
}
return -1;
}
}
~~~
2. **現在有一個map集合如下：**
~~~
Map map = new HashMap();
map.put(1, "張三豐");
map.put(2, "周芷若");
map.put(3, "汪峰");
map.put(4, "滅絕師太");
~~~
**要求：**
1. **遍歷集合，并將序號與對應人名打印。**
2. **向該map集合中插入一個編碼為5姓名為李曉紅的信息**
3. **移除該map中的編號為1的信息**
4. **將map集合中編號為2的姓名信息修改為"周林"**
~~~java
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class MapStudy {
public static void main(String[] args) {
Map<Integer, String> map = new HashMap<Integer, String>();
map.put(1,"張三豐");
map.put(2,"周芷若");
map.put(3,"汪峰");
map.put(4,"滅絕師太");
//新增
map.put(5, "李曉紅");
//刪除
map.remove(1);
//修改（覆蓋）
map.put(2, "周林");
//遍歷
Set<Integer> set = map.keySet();
Iterator<Integer> it = set.iterator();
while(it.hasNext()) {
Integer key = it.next();
System.out.println("序號為：" + key + "，姓名為：" + map.get(key));
}
}
}
~~~
3. **有2個數組，第一個數組內容為：\[黑龍江省,浙江省,江西省,廣東省,福建省\]，第二個數組為：\[哈爾濱,杭州,南昌,廣州,福州\]，將第一個數組元素作為key，第二個數組元素作為value存儲到Map集合中。如{黑龍江省=哈爾濱, 浙江省=杭州, …}。**
~~~java
import java.util.HashMap;
import java.util.Map;
public class MapStudy {
public static void main(String[] args) {
String[] province = {"黑龍江省","浙江省","江西省","廣東省","福建省"};
String[] city = {"哈爾濱","杭州","南昌","廣州","福州"};
Map<String,String> map = new HashMap<String,String>();
for(int i = 0; i < province.length; i++) {
map.put(province[i], city[i]);
}
System.out.println(map);
}
}
~~~
4. **雙色球規則：雙色球每注投注號碼由6個紅色球號碼和1個藍色球號碼組成。紅色球號碼從1—33中選擇；藍色球號碼從1—16中選擇；請隨機生成一注雙色球號碼。（要求同色號碼不重復）**
