# 集合
[TOC]
## 導學
在現實生活中，我們一直在接觸集合的概念，比如體育課上老師會喊集合！在數學中也會有著集合的概念。那么在Java中，集合是一個什么樣的概念呢？
>[info]Java中的集合是工具類，可以存儲任意數量的具有共同屬性的對象
其實在某種程度上而言，集合和數組有著很大的相似之處。但為什么不使用數組，而用集合呢？這是因為數組的長度是固定的，而集合的長度可以動態變化。
>[info]用數組存儲固定長度的數據，用集合存儲動態變化的數據
所以，集合的應用場景有哪些呢：
* **無法預測存儲數據的數量(集合解決動態問題,數組解決靜態問題)**
* **同時存儲具有一對一關系的數據**
* **需要進行數據的增刪改查**
* **解決數據重復問題**
## 集合框架體系
* Collection：存儲類的對象
Collection有三個子接口，List(序列)、Queue(隊列)、Set(集)
* List：（序列） 有序的、允許重復的 主要實現類：ArrayList：長度動態增長的數組
* Queue：（隊列） 有序的、允許重復的 主要實現類：LinkedList：鏈表的內容
* Set：（集）無序的、不允許重復的 主要實現類：HashSet：哈希集
* Map：鍵值對內容
什么是鍵值對：比如學生都有對應的學號，通過學號就可以指向某個具體的學生。
* Map實現類HashMap(哈希表的意思，存儲以鍵值對表示的形式)
## List集合
`List`是元素有序并且可以重復的集合，稱為序列。
`List`可以精確地控制每個元素的插入位置，或刪除某個位置的元素。
`List`的兩個主要實現類：`ArrayList`和`LinkedList`，本節課主要講解`ArrayList`，這是因為`ArrayList`使用的比較多，而且`ArrayList`和`LinkedList`這兩個實現類中的方法幾乎都是相同的。
`ArrayList`底層是由數組實現的，長度動態增長。`ArrayList`中的元素可以為null且可以有多個。在列表尾部插入或刪除數據非常有效，但是在中間則需要進行大量的數組復制，耗費較多資源。所以更適合查找和更新元素。
**`Collection`接口和`List`接口中方法：**
| 方法 | 作用 |
| --- | --- |
| `add(E e)` | 將元素添加到集合中 |
| `clear()`| 清空集合中的元素|
| `contains(Object o)`|判斷集合中是否存在參數 |
| `isEmpty()`|判斷集合中是否存在元素 |
|`iterator()`| 迭代器方法，可用于集合遍歷|
|`remove(Object o)`|移除集合中的某個元素|
|`size()`|返回集合中元素的數量|
|`toArray()`|用于將集合轉變為數組|
|`get(int index)`|返回集合中指定位置處的元素|
|`indexOf(Object o)`|返回某個對象在集合中第一次出現的位置|
|`sort(Comparator<? super E> c)`|集合排序方法|
**實現類`ArrayList`中構造器及方法：**
| 構造器和方法 | 作用 |
| --- | --- |
| ArrayList() | 創建初始容量為十的列表 |
| ArrayList(Collection<? extends E)?c) | 利用一個已經存在的集合去創建集合 |
| ArrayList(int length) | 創建一個指定初始容量的列表 |
|toArray()|將集合轉變為數組|
### 簡單`List`集合應用
案例：利用List存儲編程語言名稱并輸出
存儲內容：Java,C,C++,Go,Swift
~~~
import java.util.ArrayList;
import java.util.List;
public class ListDemo1 {
public static void main(String[] args) {
List list = new ArrayList();
list.add("Java");
list.add("C");
list.add("C++");
list.add("Go");
list.add("Swift");
//輸出列表中元素的個數
System.out.println("列表中元素的個數為：" + list.size());
//遍歷輸出所有的集合元素
System.out.println("*****************************");
for(int i = 0; i < list.size(); i++) {
System.out.print(list.get(i) + ",");
}
//移除列表中的C++
System.out.println("\n*****************************");
//list.remove(2);
list.remove("C++");
System.out.println("移除列表中的C++元素后，集合元素為：");
for(int i = 0; i < list.size(); i++) {
System.out.print(list.get(i) + ",");
}
}
}
~~~
內存中，集合的存儲和數組類似：
### `List`集合案例
案例：公告管理
需求：（增刪改查）
- 公告的添加與顯示
- 在指定位置處插入公告
- 刪除公告
- 修改公告
任務：
- 創建公告類
- 公告類屬性：編號 id，標題 title，創建人 creater，創建時間createTime
- 公告類方法：構造方法，對應get set方法
~~~
package com.ntdodoke.set;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
public class NoticeTest {
public static void main(String[] args) {
// 創建三條公告
Notice no1 = new Notice(1, "歡迎來到渡課學習Java", "管理員", new Date());
Notice no2 = new Notice(2, "請同學按時提交作業", "老師", new Date());
Notice no3 = new Notice(3, "考勤通知", "班主任", new Date());
// 添加公告
List list = new ArrayList();
list.add(no1);
list.add(no2);
list.add(no3);
// 顯示公告
System.out.println("公告的內容為：");
for (int i = 0; i < list.size(); i++) {
System.out.println(i + 1 + ":" + ((Notice) (list.get(i))).getTitle());
}
System.out.println("******************************");
// 在第一條公告后面添加一條新公告
Notice no4 = new Notice(4, "線上學習可以進行啦", "管理員", new Date());
list.add(1, no4);
// 顯示公告
System.out.println("公告的內容為：");
for (int i = 0; i < list.size(); i++) {
System.out.println(i + 1 + ":" + ((Notice) (list.get(i))).getTitle());
}
System.out.println("******************************");
// 刪除按時完成作業公告
list.remove(2);
// 顯示公告
System.out.println("刪除后公告的內容為：");
for (int i = 0; i < list.size(); i++) {
System.out.println(i + 1 + ":" + ((Notice) (list.get(i))).getTitle());
}
System.out.println("******************************");
// 將線上學習可以進行啦改為Java線上學習可以開始啦
// 修改第二條公告中的title的值
no4.setTitle("Java線上學習可以開始啦");
list.set(1, no4);// 使用新對象替換對應索引的舊對象
// 顯示公告
System.out.println("修改后公告的內容為：");
for (int i = 0; i < list.size(); i++) {
System.out.println(i + 1 + ":" + ((Notice) (list.get(i))).getTitle());
}
}
}
~~~
## Set集合
`Set`中元素無序且不可以重復，稱為集。
`HashSet`是`Set`的一個重要實現類，稱為哈希集。`HashSet`中的元素無序且不可以重復，`HashSet`中只允許一個`null`元素。`HashSet`底層是`HashMap`實現。`HashSet`具有良好的存取和查找性能，所以適合存取和查找的情況。
HashSet 類是按照哈希算法來存儲集合中的元素，使用哈希算法可以提高集合元素的存儲速度，當向 Set 集合中添加一個元素時，HashSet 會調用該元素的 hashCode() 方法，獲取其哈希碼，然后根據這個哈希碼計算出該元素在集合中的存儲位置。
Set接口和其實現類中的方法與之前List集合比較類似，所以本節課，不再過多介紹，結合jdk學習。
### 簡單`Set`集合應用
案例：利用HashSet存儲多個表示顏色的英文單詞，并輸出。
單詞：bule，red，black，yellow，white
說明：當調用`add（Object）`方法時候，首先會調用`Object`的`hashCode`方法判斷`hashCode`是否已經存在，如不存在則直接插入元素；如果已存在則調用`Object`對象的`equals()`方法判斷是否返回`true`，如果為`true`則說明元素已經存在，如為`false`則插入元素。
`HashSet`是借助`HashMap`來實現的，利用`HashMap`中`Key`的唯一性，來保證`HashSet`中不出現重復值。
~~~
package com.ntdodoke.set;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class WordDemo {
public static void main(String[] args) {
// 將單詞添加到集合中
Set set = new HashSet();
set.add("blue");
set.add("red");
set.add("black");
set.add("yellow");
set.add("white");
// 顯示集合的內容
System.out.println("集合中的元素為：");
// 在Set集合中沒有取元素的方法
// 獲取迭代器接口
Iterator it = set.iterator();
// 遍歷迭代器并輸出元素
while (it.hasNext()) {
System.out.print(it.next() + " ");
}
// 在集合中插入新的單詞
set.add("green");
set.add("green");// 沒有報錯
System.out.println("\n插入重復元素后的輸出結果為：");
it = set.iterator();
// 遍歷迭代器并輸出元素
while (it.hasNext()) {
//向HashSet()中插入重復元素不會報錯，因為系統并不會把重復元素插入到集合中.
System.out.print(it.next() + " ");
}
}
}
~~~
Set接口、HashSet類中都沒有顯示元素的get方法，要想顯示元素：
1、Iterator(迭代器)：Iterator接口可以以統一的方式對各種集合元素進行遍歷,
2、hasNext()方法檢測集合中是否還有下一關元素，它的返回值是boolean類型。
3、next()方法返回集合中的下一個元素，返回Object類型的對象。
換言之，元素存貯在迭代器中，再通過遍歷迭代器來遍歷存貯在迭代器中的元素，然后通過`hasNext()`判斷迭代器中是否還有下一個元素，返回`ture`時再通過`next()`方法打印出集合中所有元素。
### Set集合案例
案例：寵物貓信息管理
需求：（增刪改查）
- 添加和顯示寵物貓的信息
- 查找某只寵物貓的信息并輸出
- 修改寵物貓的信息
- 刪除寵物貓的信息
任務：寵物貓類
- 屬性：名字 name，月份 month，品種 species
- 方法：構造方法，get set方法，其他方法
說明：
HashSet中，是無法添加相同的對象的。所以這里要注意，什么是相同的對象了。
問：用相同的屬性對對象進行初始化，它們是相同的對象嗎？如：
Cat cat1 = new Cat("花花", 12, "英國短毛貓");
Cat cat2 = new Cat("花花", 12, "英國短毛貓");
答：不是。
所以這樣的兩個對象，是可以加入的HashSet中的。這往往與我們的期望是不符的，我們認為他們應該是"相同的"，不應該重復加入。
程序是通過調用hashCode和equals兩個方法來判斷對象是否相等的。
所以，對于上面提到的問題，我們可以通過重寫這兩個方法來實現我們需求。
equals方法思路：1）先判斷對象是否相等，相等返回true，不用繼續比較屬性；2）判斷obj是否為目標類的對象，若是則通過強制類型轉換為目標類對象后繼續比較屬性值是否相同；3）以上都不滿足則返回false：
~~~
package com.ntdodoke.set;
public class Cat {
private String name;
private int month;
private String species;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getMonth() {
return month;
}
public void setMonth(int month) {
this.month = month;
}
public String getSpecies() {
return species;
}
public void setSpecies(String species) {
this.species = species;
}
public Cat(String name, int month, String species) {
super();
this.name = name;
this.month = month;
this.species = species;
}
public Cat() {
super();
}
@Override
public String toString() {
return "Cat [姓名=" + name + ", 月份=" + month + ", 品種=" + species + "]";
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + month;
result = prime * result + ((name == null) ? 0 : name.hashCode());
result = prime * result + ((species == null) ? 0 : species.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj.getClass() == Cat.class) {
Cat cat = (Cat)obj;
return cat.getName().equals(this.getName()) && (cat.getMonth() == this.getMonth()) && cat.getSpecies().equals(this.getSpecies());
} else {
return false;
}
}
}
~~~
~~~
package com.ntdodoke.set;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class CatTest {
public static void main(String[] args) {
// 定義寵物貓對象
Cat huahua = new Cat("花花", 12, "英短");
Cat fanfan = new Cat("凡凡", 3, "中華田園貓");
// 將對象放入HashSet
Set<Cat> set = new HashSet<Cat>();
set.add(huahua);
set.add(fanfan);
// 顯示元素信息
Iterator<Cat> it = set.iterator();
while (it.hasNext()) {
// System.out.println(((Cat)(it.next())).getName());
System.out.println(it.next());
}
// 再添加一個與花花屬性一致的貓
Cat huahua2 = new Cat("花花", 12, "英短");
set.add(huahua2);
System.out.println("*****************************");
System.out.println("添加重復數據后集合的元素為：");// 如果沒有重寫hashCode和equals方法，會怎樣
it = set.iterator();
while(it.hasNext()) {
System.out.println(it.next());
}
// 重新插入一個新的寵物貓信息
Cat huahua3 = new Cat("花花2代", 2, "英短");
set.add(huahua3);
System.out.println("添加花花二代后的集合元素為：");
it = set.iterator();
while(it.hasNext()) {
System.out.println(it.next());
}
// 在集合中查找花花的信息，并輸出
System.out.println("*****************************");
if(set.contains(huahua)) {
System.out.println("花花找到了");
System.out.println(huahua);
} else {
System.out.println("花花沒找到");
}
// 使用名字查找
System.out.println("*****************************");
System.out.println("通過名字查找");
boolean flag = false;
Cat c = null;
it = set.iterator();
while(it.hasNext()) {
c = (Cat) it.next();
if (c.getName().equals("花花")) {
flag = true;// 找到了
break;
}
}
if(flag) {
System.out.println("花花找到了");
System.out.println(c);
} else {
System.out.println("花花沒找到");
}
/**
* 查找元素
* 1、直接通過對象查找，使用contains方法
* 2、通過屬性查找，遍歷集合中所有對象，并使用get方法結合equals方法來尋找符合條件的對象
* 注意每次重新使用迭代器都需重置迭代器，否則迭代器會一直指向末尾
*/
//刪除花花二代的信息，并重新輸出
for(Cat cat : set) {
if("花花2代".equals(cat.getName())) {
set.remove(cat);
}
}
System.out.println("**************************");
System.out.println("刪除花花二代后的數據為：");
for(Cat cat : set) {
System.out.println(cat);
}
//刪除集合中的所有寵物貓信息
System.out.println("刪除所有集合后的信息：");
boolean flag2 = set.removeAll(set);
if(set.isEmpty()){
System.out.println("都被刪除了");
} else {
System.out.println("貓還在");
}
//如果不刪除花花二代，而是刪除花花呢？
set.add(huahua);
set.add(fanfan);
set.add(huahua3);
/*for(Cat cat : set) {
if("花花".equals(cat.getName())) {
set.remove(cat);
//break;
}
}
System.out.println("**************************");
System.out.println("刪除花花二代后的數據為：");
for(Cat cat : set) {
System.out.println(cat);
}*/
it = set.iterator();
while(it.hasNext()) {
Cat cat = it.next();
if("花花".equals(cat.getName())) {
it.remove();//利用迭代器刪除
}
}
System.out.println("**************************");
System.out.println("刪除花花后的數據為：");
for(Cat cat : set) {
System.out.println(cat);
}
}
}
~~~
總結：
1. 泛型消除了安全隱患，不需要強制類型轉換。另外使用泛型后，還可以使用增強型for循環來遍歷集合。
2. 集合（包括List，Set，Map）在讀取數據的時候（通過循環遍歷）刪除數據要注意，如果刪除數據后繼續遍歷了，則會報錯，因為此時集合結構已經改變了。可以在刪除指定的數據后馬上break跳出遍歷循環，就不會報錯了。注意如果是刪除的最后一個數據那么不會報錯，因為不會再繼續遍歷了。
注意以上情況是針對刪除一條數據的情況，如果要刪除多條數據，可以使用removeAll()方法。例如：
有一個set集，想要刪除其中2條滿足情況的數據，可以先遍歷這個set，在遍歷的過程中，向新集set2中添加滿足情況的數據。然后set.removeAll(set2); 就可以了。注意set.removeAll(set); 是刪除set集自己中的所有元素。
3. 集合中元素的刪除主要還是依靠迭代器的remove()方法
## Map集合
**Map**
- Map中的數據是以鍵值對（key-value）的形式存儲的；
- key-value以Entry類型的對象實例存在；
- 可以通過key值快速地查找value；
- 一個映射不能包含重復的鍵；
- 每個鍵最對只能映射到一個值。
**HashMap實現類**
- 基于哈希表的Map接口的實現；
- 允許使用null值和null鍵；
- key值不允許重復；
- HashMap中的Entry對象是無序排列的。
具體方法不在過多介紹，結合文檔與案例了解
### 簡單`Map`集合應用
案例：完成一個類似字典的功能
- 將單詞以及單詞的注釋存儲到`HashMap`中
- 顯示`HashMap`中的內容
- 查找某個單詞的注釋并顯示
~~~
package com.ntdodoke.set;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Scanner;
import java.util.Set;
public class DictionaryDemo {
public static void main(String[] args) {
Map<String, String> map = new HashMap<String, String>();
System.out.println("請輸入三組單詞對應的注釋，并存放到HashMap中");
Scanner sc = new Scanner(System.in);
int i = 0;
while (i < 3) {
System.out.println("請輸入key值（單詞）：");
String key = sc.next();
System.out.println("請輸入value值（注釋）：");
String value = sc.next();
// 向map集合中添加元素
map.put(key, value);
i++;
}
// 打印輸出value的值（直接使用迭代器）
System.out.println("**********************************");
System.out.println("使用迭代器輸出所有的value");
// 利用values()方法返回map中值的集合
Iterator<String> it = map.values().iterator();
while (it.hasNext()) {
System.out.print(it.next() + " ");
}
System.out.println("\n**********************************");
// 打印輸出key和value的值
// 通過entrySet()方法
System.out.println("通過entrySet()方法得到key-value值");
Set<Entry<String, String>> entrySet = map.entrySet();
for (Entry<String, String> entry : entrySet) {
System.out.print(entry.getKey() + "-");
System.out.println(entry.getValue());
}
// 打印輸出value的值（使用keySet()）
System.out.println("**********************************");
System.out.println("通過keySet()方法得到key值");
Set<String> keySet = map.keySet();
for(String str : keySet) {
System.out.print(str + "-");
//利用get()獲取集合中對應key的value值
System.out.println(map.get(str));
}
System.out.println("**********************************");
System.out.println("請輸入要查找的單詞：");
//通過單詞找到注釋并輸出
//使用keySet()方法
String searchKey = sc.next();
//1. 取得keySet
Set<String> keySet1 = map.keySet();
//2. 遍歷keySet
for(String key:keySet1) {
System.out.println(key);
if(searchKey.equals(key)) {
System.out.println("找到了！"+"鍵值對："+key+"-"+map.get(key));
break;
}
}
}
}
~~~
### `Map`集合案例
案例：商品信息管理
需求：
* 使用HashMap對商品信息進行管理
- 其中key為商品編號，value為商品對象
* 對HashMap中的商品對象進行增，刪，改，查操作
任務：
- 屬性：商品編號 id， 商品名稱 name， 商品價格 price
- 方法：構造方法、get/set方法、其他方法
~~~
import java.util.HashMap;
import java.util.InputMismatchException;
import java.util.Iterator;
import java.util.Map;
import java.util.Scanner;
public class GoodsTest {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
//定義商品對象并保存到HashMap中
Map<String,Goods> map = new HashMap<String,Goods>();
System.out.println("請輸入三條商品信息");
int i = 0;
while(i < 3) {
System.out.println("請輸入第" + (i + 1) + "條商品信息");
System.out.println("請輸入商品編號");
String id = sc.next();
//防止商品編號重復
if(map.containsKey(id)) {
System.out.println("該商品編號已經存在，請重新輸入！");
continue;
}
System.out.println("請輸入商品名稱");
String name = sc.next();
System.out.println("請輸入商品價格");
double price = 0;
try {
price = sc.nextDouble();
}catch(InputMismatchException e) {
System.out.println("商品價格格式不正確，請重新輸入！");
sc.next();
i--;
continue;
}
Goods goods = new Goods(id,name,price);
map.put(id,goods);
i++;
}
//遍歷map，輸出商品信息
System.out.println("商品的全部信息為：");
Iterator it = map.values().iterator();
while(it.hasNext()) {
System.out.println(it.next());
}
//刪除一條商品信息
System.out.println("請輸入售罄商品編號：");
while(true) {
String nid = sc.next();
if(map.containsKey(nid)) {
map.remove(nid);
break;
} else {
System.out.println("不存在該商品編號，請重新輸入！");
}
}
System.out.println("清空售罄商品后的全部信息為：");
it = map.values().iterator();
while(it.hasNext()) {
System.out.println(it.next());
}
}
}
~~~
## 練習
一、選擇
1. 下列不屬于Collection子接口的是
~~~
A. List
B. Map
C. Queue
D. Set
~~~
2. 已知ArrayList的對象是list，以下哪個方法是判斷ArrayList中是否包含"dodoke"
~~~
A. list.contains("dodoke");
B. list.add("dodoke");
C. list.remove("dodoke");
D. list.remove("dodoke");
~~~
3. 下列哪個方法可以獲取列表指定位置處的元素
~~~
A. add(E e)
B. remove()
C. size()
D. get(int index)
~~~
4. 下列有關HashSet的描述正確的是（多選）
~~~
A. HashSet是Set的一個重要實現類
B. HashSet中的元素無序但可以重復
C. HashSet中只允許一個null元素
D. 不適用于存取和查找
~~~
5. 以下關于Set對象的創建錯誤的是
~~~
A. Set set=new Set();
B. Set set=new HashSet();
C. HashSet set=new HashSet();
D. Set set=new HashSet(10);
~~~
6. 關于Iterator的描述錯誤的是
~~~
A. Iterator可以對集合Set中的元素進行遍歷
B. hasNext()方法用于檢查集合中是否還有下一個元素
C. next()方法返回集合中的下一個元素
D. next()方法的返回值為false時，表示集合中的元素已經遍歷完畢
~~~
7. 定義一個Worker類，關于hashCode()方法的說法正確的是？
~~~
A. 在Worker類中，hashCode()方法必須被重寫
B. 如果hashCode的值相同，則兩個Worker類的對象就認為是相等的
C. hashCode的值不同時，則兩個對象必定不同
D. 以上說法均正確
~~~
8. 下列相關迭代器描述正確的是
~~~
A. Iterator接口可以以統一的方式對各種集合元素進行遍歷
B. hasNext（）是Iterator接口的一個方法，是用來檢測集合中是否還有下一個元素
C. next（）是Iterator接口的一個方法，是用來返回集合中的下一個元素
D. hasNext（）是Iterator接口的一個方法，是用來返回集合中的下一個元素
~~~
9. HashMap的數據是以key-value的形式存儲的，以下關于HashMap的說法正確的是
~~~
A. HashMap中的鍵不能為null
B. HashMap中的Entry對象是有序排列的
C. key值不允許重復
D. value值不允許重復
~~~
10. 已知HashMap對象，橫線處應添加的語句是？
~~~
A. hashMap.get(key);
B. hasMap.getValue();
C. hashMap.getKey();
D. hashMap.Value();
~~~
11. 以下關于Set和List的說法，正確的是
~~~
A. Set中的元素是可以重復的
B. List中的元素是無序的
C. HashSet中只允許有一個null元素
D. List中的元素是不可以重復的
~~~
二、編程
1. 使用集合ArrayList對字符串進行存儲和管理。
**運行效果圖**：
任務：
1. 定義ArrayList對象
2. 存儲學科名稱，見運行效果圖
3. 輸出集合中元素的個數
4. 遍歷輸出集合中的所有元素
編程：
~~~
public class ArrayListDemo {
public static void main(String[] args) {
//用ArrayList存儲學科的名稱
//輸出列表中元素的個數
//遍歷輸出所有列表元素
}
}
~~~
2. 定義一個員工信息類Employee，使用ArrayList對員工信息進行添加和顯示。
**運行效果圖**：
任務：
1、實現員工信息類Employee
? ? 成員變量：編號id（int），姓名name（String），薪資salary（double）
? ? 方法：構造方法和相關的get和set方法
2、定義三條員工信息添加到ArrayList中
3、將所有員工的姓名和薪資輸出，見效果圖
編程：
~~~
public class EmployeeTest {
public static void main(String[] args) {
//定義ArrayList對象
//創建三個Employee類的對象
//添加員工信息到ArrayList中
//顯示員工的姓名和薪資
}
}
~~~
3. 定義一個學生類，使用HashSet對學生類的對象進行管理：執行添加操作，然后解決重復數據的添加問題。
**運行效果圖**：
任務：
1. 定義一個學生類Student
（1）屬性為：學號stuId（int），姓名name（String），成績score（float）
（2）方法為：構造方法，getter和setter方法，toString方法
（3）重寫hashCode()和equals()方法，equals方法的判斷依據是學號和姓名相等
2. 定義三個Student類的對象，添加到HashSet中
3. 顯示HashSet中元素的內容
4. 添加一個重復數據到Set中，觀察輸出結果
編程：
~~~
public class StudentTest {
public static void main(String[] args) {
//定義三個Student類的對象及一個HashSet類的對象
//將Student類的對象添加到集合中
//使用迭代器顯示Student類的對象中的內容
}
}
~~~
4. 已知如下數據：世界杯冠軍及奪冠年份。
將奪冠年份作為key值，冠名隊名作為value值，存儲至少三條數據到HashMap中，并循環打印輸出。
**運行效果圖**：
任務：
1、將奪冠年份和冠軍隊名以key-value形式存儲到HashMap中
2、使用迭代器和EntrySet兩種方式遍歷輸出HashMap中的key和value
編程：
~~~
public class FootballDemo {
public static void main(String[] args) {
//定義HashMap的對象并添加數據
//使用迭代器的方式遍歷
//使用EntrySet同時獲取key和value
}
}
~~~
