# 集合
[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
}
}
~~~
