1.Java集合

1.1 集合应用场景

无法预测存储数据的数量的情况下，
同时存储一对一关系的数据
需要进行数据的增删
数据重复问题

1.2 集合框架的体系结构

集合框架分为两类，一是Collection，用于存储类的对象。二是Map，以键值对的形式存储信息。

Collection主要有三个子接口，List(序列)，Queue(队列),Set(集)。其中List和Queue要求存入数据有序且允许重复,Set中存入数据要求无序并且不能重复。List接口下有个常用实现类ArrayList，可以看为一个长度动态增长的数组。Queue接口下有常用实现类LinkedList，同时也实现了List接口，表示的是列表的内容。Set下有实现类HashSet表示哈希集。
Map主要实现类是HashMap（哈希表），存储以键值对形式存放的数据。

1.3 集合与数组的区别

数组的长度是固定的，集合的长度可以动态扩展；
数组只能存储相同数据类型的数据，而集合可以存储不同数据类型的数据；
数组可以存储基本数据类型数据，也可以是引用类型，而集合只能是引用类型；
数组适用于数据长度固定的情况，并且主要进行查询操作。

1.4 集合中接口和类的特点

1.4.1 Collection

主要用于存储类的对象，Collection下有三个子接口，分别是List、Queue和Set，List和Queue中可以存储有序且重复的数据，Set中存储的数据是无序且不允许重复。 1、List接口的主要实现类包括ArrayList和LinkedList，LinkedList同时实现了Queue接口。

ArrayList的底层实现是数组，因此在内存中是连续存储的。查询速度快，但增加和删除速度慢。
LinkedList底层是基于双向链表的，增加和删除速度快，查询速度慢。

2、Set接口的主要实现类有HashSet和TreeSet

HashSet是基于哈希表实现的，数据是无序的，HashSet元素可以是null，但只能有一个null。
TreeSet是基于二叉树实现的，可以实现数据的自动排序，确保集合元素处于非排序状态，不允许放入空值。
HashSet的性能优于TreeSet，一般情况下建议使用HashSet，如果需要使用排序功能建议使用TreeSet。

1.4.2 Map

主要用于存储键值对的数据，Map的主要实现类包括HashMap和TreeMap，其中HashMap基于哈希表实现，TreeMap基于红黑树实现。 1. HashMap适用于在Map中插入、删除和定位元素。 2. TreeMap适用于按自然顺序或自定义顺序对建值进行遍历。 3. HashMap比TreeMap性能好，所以HashMap使用更多一些，如果需要对数据进行排序可以使用TreeMap。

1.5 集合-List

List是元素有序并且可以重读的集合，称为序列
List可以精确控制每一个元素的插入位置，或者删除某个位置的元素
List两个主要实现类ArrayList和LinkedList,两个接口方法基本相同，ArrayList使用更多
ArrayList是长度动态变化的数组，底层由数组实现。由于与数组一样是连续存储的，所以在列表尾部插入或者删除数据效率非常高，但是中间插入或者删除数据需要进行大量数组复制，效率比较低。所以ArrayList更适合查找和更新元素。
ArrayList元素可以为null。

1.5.1 使用ArrayList存储数据并输出

1public class Demo {
2	public static void main(String[] args) {
3		// 用ArrayList存储编程语言并输出
4		List list = new ArrayList();
5		list.add("JAVA");
6		list.add("Hello");
7		list.add("World");
8		// 输出列表中的元素个数
9		System.out.println("列表中的元素个数为：" + list.size());
10		// 遍历输出所有编程语言
11		System.out.println("***********************************");
12		for (int i = 0; i < list.size(); i++) {
13			System.out.print(list.get(i) + ",");
14		}
15		// 移除列表中的Java；
16		System.out.println();
17		list.remove(0);//数据存储位置
18		//list.remove("JAVA");// 直接输入要移除的数
19		System.out.println("***********************************");
20        System.out.println("判断此时是否包含JAVA，如果包含则输出true，否则false:"+list.contains("JAVA"));
21		System.out.println("移除Java以后的列表元素为：");
22		for (int i = 0; i < list.size(); i++) {
23			System.out.print(list.get(i) + ",");
24		}
25	}
26}
27输出：
28列表中的元素个数为：3
29***********************************
30JAVA,Hello,World,
31***********************************
32判断此时是否包含JAVA，如果包含则输出true，否则false:false
33移除Java以后的列表元素为：
34Hello,World,

1.5.2 案例实现（公告管理）

需求： ➩ 公告的添加和显示 ➩ 在指定位置处插入公告 ➩ 删除公告 ➩ 修改公告

第一步公告类的定义

【属性：公告ID、公告标题、公告创建人、公告创建时间】

1package person.xsc.practice;
2import java.util.Date;
3public class Notice {
4	private int id;	// 公告ID
5	private String title; //公告标题
6	private String creator; // 公告创建人
7	private Date createTime;//公告创建时间
8	public Notice() {
9		
10	}
11	public Notice(int id, String title, String creator, Date createTime) {
12		super();
13		this.id = id;
14		this.title = title;
15		this.creator = creator;
16		this.createTime = createTime;
17	}
18	public int getId() {
19		return id;
20	}
21	public void setId(int id) {
22		this.id = id;
23	}
24	public String getTitle() {
25		return title;
26	}
27	public void setTitle(String title) {
28		this.title = title;
29	}
30	public String getCreator() {
31		return creator;
32	}
33	public void setCreator(String creator) {
34		this.creator = creator;
35	}
36	public Date getCreateTime() {
37		return createTime;
38	}
39	public void setCreateTime(Date createTime) {
40		this.createTime = createTime;
41	}
42	@Override
43	public String toString() {
44		return "Notice [id=" + id + ", title=" + title + ", creator=" + creator + ", createTime=" + createTime + "]";
45	}
46}

第二步，测试类的定义

1package person.xsc.practice;
2import java.util.ArrayList;
3import java.util.Date;
4public class TestNotice {
5	public static void main(String[] args) {
6		// TODO Auto-generated method stub
7		// 创建公告对象
8		Notice notice1 = new Notice(1, "欢迎来到我的世界——编程世界", "执键写春秋", new Date());
9		Notice notice2 = new Notice(2, "你好，世界", "执键写春秋", new Date());
10		Notice notice3 = new Notice(3, "你好，程序员", "执键写春秋", new Date());
11		Notice notice4 = new Notice(4, "开始写代码", "执键写春秋", new Date());
12		// 添加公告
13		ArrayList noticeList = new ArrayList();
14		noticeList.add(notice1);
15		noticeList.add(notice2);
16		noticeList.add(notice3);
17		noticeList.add(notice4);
18		// 显示公告内容
19		System.out.println("公告内容为: ");
20		for (Object object : noticeList) {
21			System.out.println(((Notice) object).getId() + " " + ((Notice) object).getTitle() + " "
22					+ ((Notice) object).getCreator() + " " + ((Notice) object).getCreateTime());
23		}
24		// 在第一条公告后面添加一条新公告
25		Notice notice5 = new Notice(5, "抓紧学习", "执键写春秋", new Date());
26		noticeList.add(1, notice5);
27		System.out.println("添加后的公告内容为: ");
28		for (Object object : noticeList) {
29			// 这里标题使用跟之前有所不同
30			System.out.println(((Notice) object).getId() + ": " + ((Notice) object).getTitle());
31		}
32		// 删除按时完成作业的公告
33		noticeList.remove(2);
34		System.out.println("删除后的公告内容为: ");
35		for (Object object : noticeList) {
36			// 这里标题使用跟之前有所不同
37			System.out.println(((Notice) object).getId() + ": " + ((Notice) object).getTitle());
38		}
39		// 1. 修改公告的title值
40		notice4.setTitle("不要你写代码了");
41		System.out.println("修改后公告内容为: ");
42		for (Object object : noticeList) {
43			// 这里标题使用跟之前有所不同
44			System.out.println(((Notice) object).getId() + ": " + ((Notice) object).getTitle());
45		}
46	}
47}
48输出：
49公告内容为: 
501 欢迎来到我的世界——编程世界 执键写春秋 Tue May 11 17:13:02 CST 2021
512 你好，世界 执键写春秋 Tue May 11 17:13:02 CST 2021
523 你好，程序员 执键写春秋 Tue May 11 17:13:02 CST 2021
534 开始写代码 执键写春秋 Tue May 11 17:13:02 CST 2021
54添加后的公告内容为: 
551: 欢迎来到我的世界——编程世界
565: 抓紧学习
572: 你好，世界
583: 你好，程序员
594: 开始写代码
60删除后的公告内容为: 
611: 欢迎来到我的世界——编程世界
625: 抓紧学习
633: 你好，程序员
644: 开始写代码
65修改后公告内容为: 
661: 欢迎来到我的世界——编程世界
675: 抓紧学习
683: 你好，程序员
694: 不要你写代码了

1.6 集合-Set

【提示：Set是接口，不能创建对象，】 Set:元素无需并且不可以重复的集合，被称为集。HashSet是Set一个重要的实现类。

HashSet是Set一个重要的实现类，称为哈希集；
HashSet中元素无序并且不可以重复；
HashSet只允许有一个null元素；
具有良好的存取和查找性能；
HashSet的底层实现其实是HashMap；
HashSet没有get方法。

1.6.1 使用HashSet存储数据并输出

1package person.xsc.practice;
2import java.util.HashSet;
3import java.util.Iterator;
4import java.util.Set;
5public class TestNotice {
6	public static void main(String[] args) {
7		Set set=new HashSet();
8		//向集合中添加元素
9		set.add("H");
10		set.add("e");
11		set.add("ll");
12		set.add("o");
13		//显示集合的内容
14		System.out.println("集合中的元素为：");
15		Iterator it=set.iterator();
16		//遍历迭代器并输出元素
17		while(it.hasNext()) {
18			System.out.print(it.next()+"  ");
19		}
20		System.out.println();
21		//在集合中插入一个重复的单词
22		set.add("o");
23		//遍历迭代器并输出元素
24		System.out.println("******************");
25		System.out.println("插入重复元素后的输出结果为");
26		it=set.iterator();
27		while(it.hasNext()) {
28			System.out.print(it.next()+"  ");
29		}
30		//插入失败，但是不会失败
31	}
32}
33输出：
34集合中的元素为：
35ll  e  H  o  
36******************
37插入重复元素后的输出结果为
38ll  e  H  o

1.6.2 迭代器（iterator）

在程序开发中，经常需要遍历集合中的所有元素。针对这种需求，JDK专门提供了一个接口java.util.Iterator。Iterator接口也是Java集合中的一员，但它与Collection、Map接口有所不同，Collection接口与Map接口主要用于存储元素，而Iterator主要用于迭代访问（即遍历）Collection中的元素，因此Iterator对象也被称为迭代器。

hasNext()方法检测集合中是否还有下一关元素，它的返回值是boolean类型。（当hasNext()方法的返回值为false时，表示集合中的元素已经遍历完毕。）
next()方法返回集合中的下一个元素，返回Object类型的对象。

1.6.3 案例实现（宠物猫管理）

需求 ➩添加和显示宠物猫信息 ➩查找某只宠物猫的信息并输出 ➩修改宠物猫的信息 ➩删除宠物猫信息

第一步猫猫类的定义

1package person.xsc.practice;
2public class Cat {
3	private String name;
4	private int month;
5	private String kinds;
6	public Cat() {
7	}
8	public Cat(String name,int month,String kinds) {
9		this.name=name;
10		this.month=month;
11		this.kinds=kinds;
12	}
13	public String getName() {
14		return name;
15	}
16	public void setName(String name) {
17		this.name = name;
18	}
19	public int getMonth() {
20		return month;
21	}
22	public void setMonth(int month) {
23		this.month = month;
24	}
25	public String getKinds() {
26		return kinds;
27	}
28	public void setKinds(String kinds) {
29		this.kinds = kinds;
30	}
31	@Override
32	public String toString() {
33		return "Cat [name=" + name + ", month=" + month + ", kinds=" + kinds + "]";
34	}
35@Override
36	public int hashCode() {
37		final int prime = 31;
38		int result = 1;
39		result = prime * result + ((kinds == null) ? 0 : kinds.hashCode());
40		result = prime * result + month;
41		result = prime * result + ((name == null) ? 0 : name.hashCode());
42		return result;
43	}
44	@Override
45    public boolean equals(Object obj) {
46        //先判断对象是否相等，相等则返回true，不用继续比较属性了
47        if(this==obj)
48            return true;
49        //判断obj是否是Cat类的对象
50        if(obj.getClass()==Cat.class){
51            //如果是，则强制转换成cat类型，然后比较各个属性是否相等
52            Cat cat=(Cat)obj;
53            return cat.getName().equals(name)&&(cat.getMonth()==month)&&(cat.getKinds().equals(kinds));
54
55        }
56        return false;
57    }
58}

第二步，测试类的定义

1package person.xsc.practice;
2import java.util.HashSet;
3import java.util.Iterator;
4import java.util.Set;
5public class TestCat {
6	public static void main(String[] args) {
7		// TODO Auto-generated method stub
8		//定义宠物猫对象
9        Cat huahua=new Cat("小花",12,"英国短毛猫");
10        Cat fanfan=new Cat("小凡",3,"中华田园猫");
11        //将宠物猫对象放入HashSet中
12        Set set=new HashSet();
13        set.add(huahua);
14        set.add(fanfan);
15        //显示宠物猫信息
16        Iterator it=set.iterator();
17        while(it.hasNext()){
18            System.out.println(it.next());
19        }
20        //再添加一个与花花属性一样的猫
21        Cat huahua01=new Cat("小花",12,"英国短毛猫");
22        set.add(huahua01);
23        System.out.println("**********************************************");
24        System.out.println("添加重复数据后的宠物猫信息:");
25        it= set.iterator();
26        while(it.hasNext()){
27            System.out.println(it.next());
28        }
29        //在集合中查找花花的信息并输出
30        System.out.println("************************************");
31        //方案1:使用对象查找
32        if(set.contains(huahua)){
33            System.out.println("小花找到了！");
34            System.out.println(huahua);
35        }
36        else{
37            System.out.println("小花没找到");
38        }
39      //方案2:使用名字查找
40        System.out.println("************************************");
41        it= set.iterator();
42		boolean flag = false;
43		Cat c = null;
44		while (it.hasNext()) {
45			c = (Cat) it.next();
46			if (c.getName().equals("小花花")) {
47				flag = true;// 找到了
48				break;
49			}
50		}
51		if (flag) {
52			System.out.println("小花花找到了");
53			System.out.println(c);
54		} else {
55			System.out.println("小花花没找到");
56		}
57		//删除huahua对象
58		 System.out.println("************************************");
59		 //方案一：直接通过对象名删除
60		 set.remove(huahua);
61		 it= set.iterator();
62		 while (it.hasNext()) {
63			 System.out.println(it.next());
64		 }
65		 //方案二：可以尝试通过别的方法删除
66	}
67}
68
69输出：
70Cat [name=小凡, month=3, kinds=中华田园猫]
71Cat [name=小花, month=12, kinds=英国短毛猫]
72**********************************************
73添加重复数据后的宠物猫信息:
74Cat [name=小凡, month=3, kinds=中华田园猫]
75Cat [name=小花, month=12, kinds=英国短毛猫]
76************************************
77小花找到了！
78Cat [name=小花, month=12, kinds=英国短毛猫]
79************************************
80小花花没找到
81************************************
82Cat [name=小凡, month=3, kinds=中华田园猫]

1.6.4 Set不可重复性

由于HashSet中不允许添加重复元素，调用add方法时使用hashCode和equals方法判断元素是不同的。

添加数据时，会调用hashCode方法得到hash code的值，通过这个值可以找到数据存储的位置，这个位置可以理解为一片区域，在该区域中存储的数据hash code都是相等的
如果该区域已经有数据了，就继续调用equals()方法判断数据是否相等，如果相等就说明重复了，就不允许添加，如果hash code值不等，就找一个区域进行存储。
如果需要比较两个对象是否相等，则必须同时覆盖对象的hashCode方法和equals方法，并且hashCode方法和equals方法的返回值必须相同。
如果一个类没有覆盖hashCode()和equals()方法，则它的equals()方法执行的是引用相等性的比较。

【如果两个对象hashCode值不同，则两个对象必然不同】

1.6.5 getClass()和.class

在上述代码重写equals时用到了getClass()和.class，这里作个说明：getClass()是Object类的方法，该方法的返回值类型是Class类，通过getClass()方法可以得到一个Class类的对象。而.class返回的也是Class类型的对象。所以，如果obj.getClass()和Cat.class返回的内容相等，说明是同一个对象。

既然都可以得到Class的对象，关于getClass()和.class的区别：getClass()方法，有多态能力，运行时可以返回子类的类型信息。.class是没有多态的，是静态解析的，编译时可以确定类型信息。

1.7 集合——Map

Map中的数据是以键值对(key-value)的形式存储的。
key-value以Entry类型的对象实例存在。
可以通过key值快速地查找value，一个值可以有多个键。
一个映射不能包含重复的键。
每个键最多只能映射到一个值。

Map中最常用实现类HashMap，HashSet是在HashMap基础上实现的。

基于哈希表 Map接口的实现；
允许使用null值和null键，由于键不能重复，所以只能有一个null键；
key值不能重复；
HashMap中Entry对象是无序排列的（除了List都是无序）。

1.7.1 使用HashMap实现数据存储和输出

1package person.xsc.practice;
2import java.util.HashMap;
3import java.util.Iterator;
4import java.util.Map;
5import java.util.Set;
6public class MapDemo {
7	public static void main(String[] args) {
8		// TODO Auto-generated method stub
9		   HashMap<String,String> has = new HashMap<String,String>();
10	       has.put("English", "英语");
11	       has.put("Math", "数学");
12	       has.put("Chinese", "语文");
13	       System.out.println("打印输出value的值(直接使用迭代器)");
14	       Iterator<String> iter = has.values().iterator();
15	       while (iter.hasNext()) {
16	           System.out.println(iter.next());
17	       }
18	       System.out.println("********************************");
19	       System.out.println("打印输出key的值(直接使用迭代器),使用keySet()方法获取所有的key值");
20	       Iterator<String> it=has.keySet().iterator();
21	       while (it.hasNext()){
22	            System.out.println(it.next());
23	        }
24	       System.out.println("********************************");
25	       System.out.println("打印输出key和value的值：通过entrySet方法");
26	       /**
27	        * Map.Entry是Map中的一个接口，他的用途是表示一个映射项(里面有K和V)，而Set<Map.Entry<k,V>>
28	        * 表示一个映射项的Set。然后就可以从Map.Entry中的getKey方法和getValue方法中取出Key和Value。      
29	        */
30	       Set<Map.Entry<String, String>> entrySet = has.entrySet();
31	       for (Map.Entry<String ,String> entry:entrySet) {
32	           System.out.print(entry.getKey()+"-");
33	           System.out.println(entry.getValue());
34	       }
35	       System.out.println("********************************");
36	       System.out.println("打印输出key和value的值：通过默认的toString方法");
37	       System.out.println(has);
38	       System.out.println("********************************");
39	       System.out.println("打印输出key和value的值：通过get() 方法获取指定 key 对应对 value。");
40		   Set keys = has.keySet();
41		   for (Object key : keys) {
42		       System.out.println(key + "=" + has.get(key));
43		   }
44		   System.out.println("********************************");
45		   System.out.println("根据指定key 取value");
46	       String str1="Chinese";
47	       for(Map.Entry<String,String> str : has.entrySet()){
48	           if(str1.equals(str.getKey())){
49	                  System.out.println(str1+"对应的value值为："+str.getValue());
50	          }
51	       }  
52	   }
53	}
54输出：
55打印输出value的值(直接使用迭代器)
56英语
57语文
58数学
59********************************
60打印输出key的值(直接使用迭代器),使用keySet()方法获取所有的key值
61English
62Chinese
63Math
64********************************
65打印输出key和value的值：通过entrySet方法
66English-英语
67Chinese-语文
68Math-数学
69********************************
70打印输出key和value的值：通过默认的toString方法
71{English=英语, Chinese=语文, Math=数学}
72********************************
73打印输出key和value的值：通过get() 方法获取指定 key 对应对 value。
74English=英语
75Chinese=语文
76Math=数学
77********************************
78根据指定key 取value
79Chinese对应的value值为：语文

1.7.2 泛型的概念

泛型是参数化类型，一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。

这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。

泛型的好处是在编译时检查类型安全，并且所有的强制转换都是自动和隐式的，提高了代码的重用率，避免在运行时出现 ClassCastException。下面来看一段代码：

1package person.xsc.practice;
2import java.util.ArrayList;
3public class FanXingTest {
4	public static void main(String[] args) {
5		// TODO Auto-generated method stub
6		ArrayList arrayList=new ArrayList();
7		arrayList.add(888);
8		arrayList.add("HelloWorld");
9		for(int i=0;i<arrayList.size();++i) {
10			String str=(String) arrayList.get(i);
11			System.out.println(str);	
12		}
13	}
14}

上面这段代码，编译器没有报任何错误，但是当我运行的时候，输出了下面异常：

1Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
2	at person.xsc.practice.FanXingTest.main(FanXingTest.java:17)

ArrayList可以存放任意类型，就像上面代码我添加了一个String类型，然后又添加了一个Integer类型，然后再使用String来定义并强制转换，在编译阶段就无法发现问题，为了可以在编译阶段发现类似问题并解决，泛型应运而生。

下面我将上面代码修改一下，编译器会在编译阶段就能够帮我发现类似问题。

关于更多的泛型知识就不在这里一一阐述了，有兴趣的可以去社区里搜索下面几篇文章：

java 泛型详解-绝对是对泛型方法讲解最详细的,没有之一
死磕Java泛型（一篇就够）

1.7.3 案例实现（商品管理）

需求 ➩ 使用HashMap对商品信息进行管理【其中key为商品编号，value为商品对象】 ➩ 对HashMap中的商品信息进行增、删、改、查操作

第一步商品类的定义

1package person.xsc.practice;
2public class Goods {
3	private String id;
4	private String name;
5	private double price;
6	public Goods() {
7		
8	}
9	public Goods(String id,String name,double price) {
10		this.id=id;
11		this.name=name;
12		this.price=price;
13	}
14	public String getId() {
15		return id;
16	}
17	public void setId(String id) {
18		this.id = id;
19	}
20	public String getName() {
21		return name;
22	}
23	public void setName(String name) {
24		this.name = name;
25	}
26	public double getPrice() {
27		return price;
28	}
29	public void setPrice(double price) {
30		this.price = price;
31	}
32	@Override
33	public String toString() {
34		return "Goods [id=" + id + ", name=" + name + ", price=" + price + "]";
35	}
36	
37}
38

第二步，测试类的定义

1package person.xsc.practice;
2import java.util.HashMap;
3import java.util.Iterator;
4import java.util.Map;
5import java.util.Scanner;
6import java.util.Set;
7public class GoodsTest {
8	public static void main(String[] args) {
9		// TODO Auto-generated method stub
10		Scanner console=new Scanner(System.in);
11		//定义HashMap对象
12		Map<String,Goods> goodsMap=new HashMap<String,Goods>();
13		System.out.println("请输入三条商品信息：");
14		int i=0;
15		while (i<3){
16			System.out.println("请输入第"+(i+1)+"条商品编号：");
17			String goodsId=console.next();
18			if (goodsMap.containsKey(goodsId)) {
19			      System.out.println("该商品编号已经存在！请重新输入！");
20			      continue;
21			}
22			System.out.println("请输入第"+(i+1)+"条商品名称：");
23			String goodsName=console.next();
24			while (true) {
25				  System.out.println("请输入第"+(i+1)+"条商品价格：");
26				  double goodsPrice = 0;
27			      try {
28			         goodsPrice = console.nextDouble();
29			      } catch (java.util.InputMismatchException e) {
30			         System.out.println("商品价格的格式不正确，请输入数值型数据！");
31			         console.next();
32			         //输入错误，跳过此循环，进行下一次循环，提示输入价格
33			         continue;
34			      }
35			//把商品的信息组成一个商品的对象，再添加到hachmap中
36			Goods goods=new Goods(goodsId,goodsName,goodsPrice);
37			goodsMap.put(goodsId,goods);
38			i++;
39			//输入正确，将商品信息添加到map中，使用break结束里面的循环，继续执行整体的循环
40			break;
41			}
42		}
43		 System.out.println("************************************");
44		//遍历Map输出商品信息
45		System.out.println("商品全部信息为：");
46		//把value值存储到迭代器中
47		Iterator<Goods> itGoods=goodsMap.values().iterator();
48		while(itGoods.hasNext()){
49		    System.out.println(itGoods.next());
50		}
51		System.out.println("************************************");
52		Set setGoodsID = goodsMap.keySet();
53		System.out.println("请输入你要修改的商品名称：");
54		String ChangePriceName=console.next();
55	    for(Object s:setGoodsID){
56	        if(goodsMap.get(s).getName().equals(ChangePriceName)){
57	        	System.out.println("请输入新的商品价格：");
58	        	double newPrice=console.nextDouble();
59	        	goodsMap.get(s).setPrice(newPrice);
60	        	break;
61	        }
62	    }
63	    System.out.println("商品全部信息为：");
64	    System.out.println(goodsMap);
65		System.out.println("************************************");
66		//清空所有的商品
67		goodsMap.clear();
68		System.out.println("清空后的商品全部信息为：");
69		if(goodsMap.size()==0) {
70			System.out.println("商品集合已经清空，没有数据了！");
71		}else {
72			System.out.println(goodsMap);
73		}
74		
75	}
76}
77
78输出：
79请输入三条商品信息：
80请输入第1条商品编号：
81G001
82请输入第1条商品名称：
83笔记本
84请输入第1条商品价格：
8518.5
86请输入第2条商品编号：
87G002
88请输入第2条商品名称：
89钢笔
90请输入第2条商品价格：
91999.8
92请输入第3条商品编号：
93G003
94请输入第3条商品名称：
95橡皮
96请输入第3条商品价格：
971.5
98************************************
99商品全部信息为：
100Goods [id=G002, name=钢笔, price=999.8]
101Goods [id=G001, name=笔记本, price=18.5]
102Goods [id=G003, name=橡皮, price=1.5]
103************************************
104请输入你要修改的商品名称：
105笔记本
106请输入新的商品价格：
10716.8
108商品全部信息为：
109{G002=Goods [id=G002, name=钢笔, price=999.8], G001=Goods [id=G001, name=笔记本, price=16.8], G003=Goods [id=G003, name=橡皮, price=1.5]}
110************************************
111清空后的商品全部信息为：
112商品集合已经清空，没有数据了！

1.8 关于集合的面试问题

List, Set, Map是否继承自Collection接口? List，Set是，Map不是。
如果两个对象值相同(x.equals(y) == true)，但却可有不同的hash code，这句话对不对 不对，两个对象值相同(x.equals(y) == true)，则一定有相同的hash code。Java对于eqauls方法和hashCode方法是这样规定的：

如果两个对象相同（equals方法返回true），那么它们的hashCode值一定要相同；
如果两个对象的hashCode相同，它们并不一定相同。

List、Map、Set三个接口，存取元素时，各有什么特点？ List 以特定次序来持有元素，可有重复元素。Set 无法拥有重复元素,内部排序。Map 保存key-value值，value可多值。

Java集合之综合论述