Java基础视频教程第16天_Map集合

一、集合—— Map 概述

	Map<K,V>  —— key value 
	
	Map 集合: 该集合存储键值对，一对一对往里存，而且要保证键的唯一性。值可以不唯一。

	注意：
		一个键只能对应一个值，但是一个值可以对应多个键。
	
	1、添加
	V put(K key, V value);
	void putAll(Map<? extends K,? extends V> m);

	2、删除
	void clear();
	V remove(Object key);

	3、判断
	boolean containsKey(Object key);
	boolean containsValue(Object value);
	boolean isEmpty();

	4、获取
	V get(Object key);
	int size();
	Collection<V> values();

	Set<Map.Entry<K,V>> entrySet();
	Set<K> keySet();

二、集合 —— Map 子类对象特点 
	Map
		--Hashtable: 底层是哈希表数据结构，不可以存入null键null值。该集合线程同步。效率低。

		--HashMap: 底层是哈希表数据结构，可以使用null键null值，该集合是不同步的。出现于JDK1.2 。效率高。

		--TreeMap: 底层是二叉树数据结构，线程不同步，可以用于给 Map 集合中的键进行排序。

	Map 和 Set 很像。
	其实, Set 底层使用的是 Map 集合。

三、集合 —— Map 共性方法 
	注意：
		添加时，如果添加相同的键，那么后添加的值会覆盖原有键对应的值，同时put方法会返回被覆盖的值。

	常见方法演示：
	import java.util.*;
	class MapDemo
	{
		public static void main(String[] args)
		{
			Map<String,String> map = new HashMap<String,String>();
			
			//添加元素
			sop("put: "+map.put("01","zhangsan1"));//返回 null
			sop("put: "+map.put("01","wangwu"));//返回zhangsan1,同时被wangwu覆盖。
			map.put("02","zhangsan2");
			map.put("03","zhangsan3");
			map.put(null,"zhangsan4");//打印结果 null=zhangsan4
			map.put("05",null);//打印结果 05=null

			sop(map);//{null=zhangsan4, 05=null, 01=wangwu, 02=zhangsan2, 03=zhangsan3}

			sop("containsKey: "+map.containsKey("02"));//判断该键是否存在 true
			sop("containsValue: "+map.containsValue("zhangsan1"));//判断该值是否存在 false

			//map.clear();//清空集合

			sop("get: "+map.get("02"));//根据键获取值，也可用于判断该键是否存在。get: zhangsan2

			sop("remove: "+map.remove("02"));//删除该键所在的元素,remove: zhangsan2
			
			Collection<String> coll = map.values();
			sop(coll);//[zhangsan4, null, wangwu, zhangsan3]
		}
		public static void sop(Object obj)
		{
			System.out.println(obj);
		}
	}
四、集合 —— Map--keySet 
	Map 集合的两种取出方式：
	1, Set keySet(); 将 Map 中所有的键存入到 Set 集合。因为 Set 集合具备迭代器，可以用迭代的方式取出所有的键，再根据get方法获取每一个键对应的值。
	2, Set<Map.Entry<K,V>> entrySet();

	keySet()方法演示：
	import java.util.*;
	class MapDemo2
	{
		public static void main(String[] args) 
		{
			Map<String,String> map = new HashMap<String,String>();

			map.put("02","zhangsan2");
			map.put("01","zhangsan1");
			map.put("03","zhangsan3");
			map.put("04","zhangsan4");

			//先获取Map集合中所有键的集合，keySet();
			Set<String> ks = map.keySet();

			Iterator<String> it = ks.iterator();//此时ks是一个Set集合
			while (it.hasNext())
			{
				String key = it.next();//获取Set集合中的元素，获取key
				String value = map.get(key);//通过key获取value
				System.out.println(key+" : "+value);
			}
		}
	}
	原理：
	从双列集合 Map 的中取出包含键的单列集合 Set ，再通过Set集合的迭代器取出Set集合中的键，然后通过map的get(key)方法获取键对应的值。 

五、集合 —— Map--entrySet 
	java.util.Map.Entry<K,V>
	public static interface Map.Entry<K,V> 它是 Map 的内部接口。

	Map 集合的取出方式二：
	Set<Map.Entry<K,V>>  entrySet();

	原理：
		将 Map 集合中的映射关系存入到了 Set 集合中，这个关系的数据类型是 Map.Entry<K,V> 。
		然后通过Set集合迭代器的方式取出 Map.Entry<K,V>对象, 再通过这个对象 Map.Entry 中的方法getKey()和getValue()获取关系中的键和值。

	理解：
		可以将一对一对的夫妻当做键值对存入Map集合；丈夫代表key，妻子代表value，结婚证书就代表Map.Entry

	Map.Entry<K,V>的方法：
	boolean equals(Object obj);
	K getKey();
	V getValue();
	int hashCode();
	V set(V value); 用指定的值替换与此项对应的值。

	Map.Entry 其实Entry也是一个接口，它是Map接口中的一个内部接口。示例代码：
	interface Map
	{
		public static interface Entry //接口中可以定义内部接口
		{
			public abstract Object getKey();
			public abstract Object getValue();
		}
	}
	class HashMap implements Map
	{
		class Haha implements Map.Entry
		{
			public Object getKey(){}
			public Object getValue(){}
		}
	}
	entrySet()方法演示：
	import java.util.*;
	class MapDemo3
	{
		public static void main(String[] args) 
		{
			Map<String,String> map = new HashMap<String,String>();

			map.put("02","zhangsan2");
			map.put("01","zhangsan1");
			map.put("03","zhangsan3");
			map.put("04","zhangsan4");

			//将Map集合中的映射关系取出，存入到Set集合中
			Set<Map.Entry<String,String>> ent = map.entrySet();

			Iterator<Map.Entry<String,String>> it = ent.iterator();//迭代Set集合

			while(it.hasNext())
			{
				Map.Entry<String,String> me = it.next();//获取Set集合中的元素
				String key = me.getKey();//调用该元素的方法获取键
				String value = me.getValue();//调用该元素的方法获取值

				System.out.println(key+"...."+value);
			}
		}
	}
六、集合 —— Map 练习 
	需求：
	每一个学生都有对应的归属地，学生属性：姓名，年龄；
	学生Student视为键key, 地址String视为值value，将两者存入Map集合中。
	
	注意：姓名和年龄相同视为同一个学生，保证学生的唯一性。

	思路：
		1、定义一个学生类，定义对应属性和方法；
		2、学生类中，复写hashCode(),equals()方法，这样就可以存入到HashSet集合中；
		3、学生类实现Comparable接口，复写compareTo()方法；
		4、创建一个Map集合，将学生对象作为键，地址作为值传入集合中；
		5、遍历取出集合中的元素。

	代码：
	import java.util.*;

	class MapTest 
	{
		public static void main(String[] args) 
		{
			HashMap<Student,String> hm = new HashMap<Student,String>();
			hm.put(new Student("lisi1",21),"beijing");
			hm.put(new Student("lisi1",21),"tianjing");
			hm.put(new Student("lisi2",22),"shanghai");
			hm.put(new Student("lisi3",23),"nanjing");
			hm.put(new Student("lisi4",24),"wuhan");

			Set<Student> keyset = hm.keySet();
			Iterator<Student> it = keyset.iterator();
			while (it.hasNext())
			{
				Student s = it.next();
				String addr = hm.get(s);
				System.out.println(s+"..."+addr);
			}

			Set<Map.Entry<Student,String>> ent = hm.entrySet();
			Iterator<Map.Entry<Student,String>> iter = ent.iterator();
			while (iter.hasNext())
			{
				Map.Entry<Student,String> me = iter.next();
				Student s = me.getKey();
				String addr = me.getValue();
				System.out.println(s+"......."+addr);
			}
		}
	}

	class Student implements Comparable<Student>
	{
		private String name;
		private int age;
		Student(String name, int age)
		{
			this.name = name;
			this.age = age;
		}
		public int compareTo(Student s)
		{
			int num = this.age-s.age;
			if (num==0)
			{
				return this.name.compareTo(s.name);
			}
			return num;
		}
		public int hashCode()
		{
			return name.hashCode()+age*37;
		}
		public boolean equals(Object obj)
		{
			if (!(obj instanceof Student))
				throw new ClassCastException("不是学生");
			Student s = (Student)obj;
			return this.name.equals(s.name) && this.age==s.age;
		}
		public String getName()
		{
			return name;
		}
		public int getAge()
		{
			return age;
		}
		public String toString()
		{
			return name+": "+age;
		}
	}
七、集合 —— TreeSet 练习 
	通过查阅API发现，TreeMap集合可以通过构造函数给定比较器：
		TreeMap(Comparator<? super K> comparator)，可以传入泛型定义为K类或者K的父类类型的比较器
	
	需求：对学生对象的年龄进行升序排序

	因为数据是以键值对的形式存在的。
	所以要使用可以排序的Map集合。

	思路：
		定义一个比较器，将学生年龄作为主要条件，姓名作为次要条件即可。
	
	代码：
	import java.util.*;
	class MapTest2
	{
		public static void main(String[] args) 
		{
			TreeMap<Student,String> tm = new TreeMap<Student,String>(new StuAgeCom());
			tm.put(new Student("lisi7",21),"beijing");
			tm.put(new Student("lisi3",23),"nanjing");
			tm.put(new Student("lisi1",24),"wuhan");
			tm.put(new Student("lisi2",22),"shanghai");

			Set<Map.Entry<Student,String>> ent = tm.entrySet();//获取Set集合

			Iterator<Map.Entry<Student,String>> it = ent.iterator();//迭代
			while(it.hasNext())
			{
				Map.Entry<Student,String> me = it.next();//获取集合中的元素
				Student stu = me.getKey();
				String addr = me.getValue();
				System.out.println(stu+"...."+addr);
			}
		}
	}

	class StuAgeCom implements Comparator<Student>
	{
		public int compare(Student s1, Student s2)
		{
			int num = new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
			//int num = s1.getAge() - s2.getAge();
			if(num==0)
				return s1.getName().compareTo(s2.getName());
			return num; 
		}
	}
八、集合 —— TreeMap 练习——字母出现的次数 
	练习：
	"aaabbccccddddd"获取该字符串中字母出现的次数

	希望打印结果：a(1) c(2) ......

	分析：
		通过结果发现，每一个字母都有对应的次数。
		说明字母和次数之间都有映射关系。
		因此可以使用Map集合。

	什么时候使用 Map集合呢？
		当数据之间存在映射关系时，就要先想Map集合。

	思路：
		1，将字符串转换成字符数组。因为要对每一个字母进行操作。
		2，定义一个map集合，因为打印结果的字母有顺序，所以使用TreeMap集合。
		3，遍历字符数组。
			将每一个字母作为键去查map集合；
			如果返回null，将该字母和1存入到map集合中；
			如果返回不是null，说明该字母在map集合已经存在并有对应次数；
			那么就获取该次数并进行自增，然后将该字母和自增后的次数存入到map集合中，覆盖原来键所对应的值。
		4，将map集合中的数据变成指定的字符串形式返回。
	
	代码：
	import java.util.*;
	class MapTest3 
	{
		public static void main(String[] args) 
		{
			System.out.println('a'-'c');
			String str = "aapklabbccc++--..cdddd";
			String s = charCount(str);
			System.out.println(s);
		}
		public static String charCount(String str)
		{
			char[] chs = str.toCharArray();//字符串变数组

			TreeMap<Character,Integer> tm = new TreeMap<Character,Integer>();//创建集合

			int count = 0;
			for (int x=0 ;x<chs.length ;x++ )//遍历数组
			{
				if(!(chs[x]>='a' && chs[x]<='z' || chs[x]>='A' && chs[x]<='Z'))
					continue;
				Integer value = tm.get(chs[x]);
				if(value!=null)
					count = value;
				count = count+1;
				tm.put(chs[x],count);
				count = 0;
			}
			//System.out.println(tm);

			StringBuilder sb = new StringBuilder();

			Set<Map.Entry<Character,Integer>> entryset = tm.entrySet();
			Iterator<Map.Entry<Character,Integer>> it = entryset.iterator();
			while(it.hasNext())
			{
				Map.Entry<Character,Integer> me = it.next();
				Character ch = me.getKey();
				Integer value = me.getValue();
				sb.append(ch+"("+value+")  ");
			}

			return sb.toString();
		}
	}
九、集合 —— Map 扩展 
	Map集合被使用是因为具备映射关系，而集合中存放的是具体对象，集合也是对象；
	那么，就可以往集合中存入集合对象。也就是集合中嵌套集合。
	例如：
		将一个学校视为一个集合，该学校有很多班级；
		每一个班级又视为一个集合，每一个班级中有很多具体的学生。
		以传智播客为例：
			传智播客有预热班和就业班；
			每个班级都有自己的学生。
			学生只有id和name两个属性。
		方式一：
			用Map集合表示一个学校，用List集合表示一个班级，班级中存放的是具体的学生对象
			HashMap<String,List<Student>> czbk = new HashMap<String,List<Student>>();
			List<Student> yure = new ArrayList<Student>();
			List<Student> jiuye = new ArrayList<Student>();
		方式二：
			用Map集合表示一个学校，用Map集合表示一个班级，班级中存放的是以学生的id和名字的键值对形式存放
			HashMap<String,HashMap<String,String>> czbk = new HashMap<String,HashMap<String,String>>();//创建一个学校集合
			HashMap<String,String> yure = new HashMap<String,String>();//创建一个班级yure
			HashMap<String,String> jiuye = new HashMap<String,String>();//创建一个班级jiuye

	代码：
	import java.util.*;
	class Student 
	{
		private String id;
		private String name;
		Student(String id, String name)
		{
			this.id = id;
			this.name = name;
		}
		public String toString()
		{
			return id+"::"+name ;
		}
	}
	class MapDemo4
	{
		//主函数
		public static void main(String[] args) 
		{
			demo();
			//demo_2();
		}
		//方式一：
		public static void demo()
		{
			//创建一个学校集合
			HashMap<String,List<Student>> czbk = new HashMap<String,List<Student>>();

			//创建两个班级
			List<Student> yure = new ArrayList<Student>();
			List<Student> jiuye = new ArrayList<Student>();

			//将班级加入学校
			czbk.put("yureban",yure);
			czbk.put("jiuyeban",jiuye);

			//每个班级中添加学生对象
			yure.add(new Student("01","zhangsan"));
			yure.add(new Student("02","lisi"));
			jiuye.add(new Student("01","wangwu"));
			jiuye.add(new Student("02","zhaoliu"));

			//迭代这个学校集合，取出每一个班级集合
			Iterator<String> it = czbk.keySet().iterator();
			while(it.hasNext())
			{
				String roomName = it.next();
				List<Student> room = czbk.get(roomName);
				System.out.println(roomName);

				//调用迭代班级中学生的方法
				getInfos(room);
			}
		}
		//定义一个方法，用于迭代取出班级中的每一个学生对象
		public static void getInfos(List<Student> list)
		{
			Iterator<Student> it = list.iterator();
			while(it.hasNext())
			{
				Student s = it.next();
				System.out.println(s);
			}
		}

		//方式二：
		public static void demo_2()
		{
			HashMap<String,HashMap<String,String>> czbk = new HashMap<String,HashMap<String,String>>();//创建一个学校集合

			HashMap<String,String> yure = new HashMap<String,String>();//创建一个班级yure
			
			HashMap<String,String> jiuye = new HashMap<String,String>();//创建一个班级jiuye

			//将班级加入学校
			czbk.put("yureban",yure);
			czbk.put("jiuyeban",jiuye);

			//将学生的id和name作为键值对传入班级集合中
			yure.put("01","zhangsan");
			yure.put("02","lisi");
			jiuye.put("01","wangwu");
			jiuye.put("02","zhaoliu");

			//迭代这个学校集合，取出每一个班级
			Iterator<String> it = czbk.keySet().iterator();
			while(it.hasNext())
			{
				String roomName = it.next();
				HashMap<String,String> room = czbk.get(roomName);
				System.out.println(roomName);

				//调用取出学生的方法。
				getStudentInfo(room);
			}
		}
		//定义一个方法，用于取出班级中的学生id和name
		public static void getStudentInfo(HashMap<String,String> roomMap)
		{
			Iterator<String> it = roomMap.keySet().iterator();
			while(it.hasNext())
			{
				String id = it.next();
				String name = roomMap.get(id);
				System.out.println(id+"..."+name);
			}
		}
	}