day16Map集合，map集合的两种取出方式。map里面有集合类，map扩展。

/*
Map集合，map集合的两种取出方式。map里面有集合类，map扩展。
*/


/*
Map接口
Map集合：该集合存储键值对。一对一对往里存。而且要保证键的唯一性。

	1，添加。
		put(K key, V value) 将指定的值与此映射中的指定键关联（可选操作）。
		putAll(Map<? extends K,? extends V> m) 从指定映射中将所有映射关系复制到此映射中（可选操作）。

	2，删除。
		clear() 从此映射中移除所有映射关系（可选操作）。
		remove(Object key) 

	3，判断。
		containsValue(Object value) 
		containsKey(Object key)  如果此映射包含指定键的映射关系，则返回 true。
		isEmpty() 

	4，获取。
		get(Object key)  返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。
		size() 返回此映射中的键-值映射关系数。
		values()   返回此映射中包含的值的 Collection 视图。
	Map没有迭代方法，可以用下面二个方式作取出操作。
		entrySet() 返回Map.Entry关系的Set集合。
		keySet() 返回键的Set集合

	Map
	|--Hashtable:底层是哈希表数据结构，不可以存入null键null值。该集合是线程同步的。jdk1.0.效率低。
	为了成功地在哈希表中存储和获取对象，用作键的对象必须实现 hashCode 方法和 equals 方法。
	|--HashMap：底层是哈希表数据结构，允许使用 null 值和 null 键，该集合是不同步的。将hashtable替代，jdk1.2.效率高。
	
	|--TreeMap：底层是二叉树数据结构。线程不同步。可以用于给map集合中的键进行排序。

	Map和Set很像。	其实:Set底层就是使用了Map集合。

*/

import java.util.*;
class  MapDemo
{
	public static void main(String[] args) 
	{
		Map<String,String> map = new HashMap<String,String>();

		//添加元素，如果添加时，出现相同的键。		
		//那么后添加的值会覆盖原有键对应值。
		//并且put方法会返回被覆盖的原来的值。
		System.out.println("put:"+map.put("01","zhangsan1"));
		System.out.println("put:"+map.put("01","wangwu"));
		map.put("02","zhangsan2");
		map.put("03","zhangsan3");

		System.out.println("containsKey:"+map.containsKey("022"));
		//System.out.println("remove:"+map.remove("02"));先返回再删除，不存在就返回null

		System.out.println("get:"+map.get("023"));
		//可以通过get方法的返回值来判断一个键是否存在。通过返回null来判断。
		//返回null代表不存在。

		map.put(null,"aha");//HashMap中null可以作为键存在。
		map.put("04",null);
		System.out.println("get:"+map.get("04"));
			
		//获取map集合中所有的值。HashMap没有顺序。
		map.values();
		Collection<String> coll = map.values();

		System.out.println(coll);
		System.out.println(map);
	}
}

/*
map集合的两种取出方式：
1，Set<k> keySet：将map中所有的键存入到Set集合,因为set具备迭代器。
	可以迭代方式取出所有的键，在根据get方法。获取每一个键对应的值。
		
	Map集合的取出原理：将map集合转成set集合。在通过迭代器取出。

2，Set<Map.Entry<k,v>> entrySet：将map集合中的映射关系存入到了set集合中，
				而这个关系的数据类型就是：Map.Entry

				Entry其实就是Map中的一个static内部接口。
				为什么要定义在内部呢？
				因为只有有了Map集合，有了键值对，才会有键值的映射关系。
				关系属于Map集合中的一个内部事物。
				而且该事物在直接访问Map集合中的元素。
*/

class  MapDemo2
{
	public static void main(String[] args) 
	{
		Map<String,String> map1 = new HashMap<String,String>();
		map1.put("02","zhangsan2");
		map1.put("03","zhangsan3");
		map1.put("01","zhangsan1");
		map1.put("04","zhangsan4");

		//第二种方法。
		Set<Map.Entry<String,String>> entrySet = map1.entrySet();

		Iterator <Map.Entry<String,String>> it = entrySet.iterator();
		
		while(it.hasNext())
		{
			Map.Entry<String,String> me = it.next();
			String key = me.getKey();
			String value = me.getValue();

			System.out.println("key:"+key+"value:"+value);
		}

		/*第一种方式；
		//先获取map集合的所有键的Set的集合，keySet()方法;
		Set<String> keySet = map1.keySet();
		//将Map集合中的映射关系取出，存入到Set集合中。
		//有了Set集合，就可以获取其迭代器。
		Iterator<String> it = keySet.iterator();
		while(it.hasNext())
		{
			String key = it.next();
			String value = map.get(key);
			System.out.println("key:"+key+"value"+value);
		}
		*/
	}
}
/*练习题
学生属性：姓名，年龄
注意：姓名和年龄相同的视为同一个学生
保证学生的唯一性。

1描述学生
2定义map容器，将学生作为键，地址作为值，存入
3获取map集合中的元素。
*/
import java.util.*;

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 = new Integer(this.age).compareTo (new Integer(s.age));
		if(num == 0)
			return this.name.compareTo(s.name);
		return num;
	}

	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}
	public String toString()
	{
		return name+":"+age;
	}
	public int hashCode()
	{
		return name.hashCode()+age*34;
	}
	public boolean equals(Object obj)
	{
		if(!(obj instanceof Student))
			throw new ClassCastException("类型不符合");
		Student stu = (Student)obj;
		return this.name.equals(stu.name) &&this.age == age;
	}
}
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("lisi2",22),"shanghai");
		hm.put(new Student("lisi3",23),"nanjing");
		hm.put(new Student("lisi4",24),"wuhan");

		//方式一keySet
		Set<Student> keySet = hm.keySet();
		 
		 Iterator<Student> it = keySet.iterator();
		 while(it.hasNext())
		{
			 Student stu = it.next();
			 String adds = hm.get(stu);
			 System.out.println(stu+"..."+adds);
		 }

		 // 方式二。entrySet
		 Set<Map.Entry<Student,String>> keyEntry = hm.entrySet();

		 Iterator<Map.Entry<Student,String>> iter = keyEntry.iterator();
		 while(iter.hasNext())
		{
			Map.Entry <Student,String>me = iter.next();
			Student stu = me.getKey();
			String adds = me.getValue();
			System.out.println(stu+"---"+adds);
		 }
	}
}

/*
需求：对学生对象的年龄进行升序排序
因为数据是以键值对形式存在的。所以要使用可以排序的
Map集合，TreeMap

然后再按名字排.指定比较器
注意：名字相同，再按年龄，二个都相同时，后面的会覆盖前面的。
*/
import java.util.*;
class StudentComp implements Comparator<Student>
{
	public int compare(Student s1,Student s2)
	{
		int num = s1.getName().compareTo(s2.getName());
		if(num == 0)
		{
			return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
		}
		return num;
	}
}

class  MapTest2
{
	public static void main(String[] args) 
	{
		TreeMap<Student,String> tm = new TreeMap<Student,String>(new StudentComp());

		tm.put(new Student("lisi1",21),"beijing");
		tm.put(new Student("lisi2",22),"shanghai");
		tm.put(new Student("lisi3",23),"nanjing");
		tm.put(new Student("lisi4",24),"wuhan");
		
		Set<Map.Entry<Student,String>> entrySet = tm.entrySet();

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

/*
练习：
"sdfgzxcvasdfxcvdf"获取该字符串中的字母出现的次数
希望打印结果：a(1)c(2)
 通过结果发现，每一个字母都有对应的次数
 说明字母和次数之间都有映射关系
 注意了，当发现有映射关系时，可以选择map集合，
 因为map集合中存放就是映射关系

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

 思路：第一次用a字母作为键去找集合。那么集合没有
 a这个键，所以也没有对应的次数。返回null
 如果为null,就将a字母和1存入集合。

 如果指定的键已经存在，说明有对应的次数，
 那么就将对应的次数取出，自增，再重新存入集合。

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) 
	{
		String s = charCount("sdfgzxcc,vasdfx,.c.vdf");
		System.out.println(s);
	}

	public static String charCount(String str)
	{
		char[] chs = str.toCharArray();

		TreeMap<Character,Integer>map = new TreeMap<Character,Integer>();

		for(int i = 0;i<chs.length;i++)
		{
			if(!(chs[i]>='a' && chs[i]<='z' || chs[i]>='A' && chs[i]<='Z'))
				continue;
			
				Integer value = map.get(chs[i]);
				int count = 1;
				if(value == null)
				{
					map.put(chs[i],1);
				}else
				{
					count = value +1;
					map.put(chs[i],count);
				}
		}
		//System.out.println(map);
		
		StringBuilder sb = new StringBuilder();
		
		Set<Map.Entry<Character,Integer>> entrySet = map.entrySet();

		Iterator<Map.Entry<Character,Integer>>it = entrySet.iterator();

		while(it.hasNext())
		{
			Map.Entry<Character,Integer> me = it.next();
			Character key = me.getKey();
			Integer value = me.getValue();

			sb.append(key+"("+value+")");
			sb.append(",");
		}
		return sb.toString();
	}
}

import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;

public class MapDemo3 {

	/**map里面有集合类，map扩展
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		getStudent_2();
	}
	public static void getStudent_2()//这是很常见的。
	{
		Map<String,HashSet<Student>> czbk = new HashMap<String,HashSet<Student>>();
		
		HashSet<Student> yuye = new HashSet<Student>(); 
		HashSet<Student> zhaoye = new HashSet<Student>(); 
		czbk.put("yuye", yuye);
		czbk.put("zhaoye", zhaoye);
		yuye.add(new Student("zhaosan",10));
		yuye.add(new Student("lisi",12));
		zhaoye.add(new Student("wangwu",19));
		zhaoye.add(new Student("zhangqi",20));
		
		Iterator<String> it = czbk.keySet().iterator();
		while(it.hasNext())
		{
			String room = it.next(); 
			System.out.println(room);
			HashSet<Student> stu = czbk.get(room);
			Iterator<Student> iter = stu.iterator();
			while(iter.hasNext())
			{
				Student stuu = iter.next();
				System.out.println(stuu.getName()+".."+stuu.getAge());
			}
		}
	}
	public static void getStudent()
	{
		Map<String,HashMap<String,String>> czbk = new HashMap<String,HashMap<String,String>>();
		HashMap<String,String> yuye = new HashMap<String,String>(); 
		HashMap<String,String> zhaoye = new HashMap<String,String>(); 
		czbk.put("yuye", yuye);
		czbk.put("zhaoye", zhaoye);
		yuye.put("001", "zhaosan");
		yuye.put("002", "zhanwu");
		zhaoye.put("001", "lisi");
		zhaoye.put("002", "wangwu");
		
		Iterator<String> it = czbk.keySet().iterator();
		while(it.hasNext())
		{
			String room = it.next(); 
			System.out.println(room);
			HashMap<String,String> stu = czbk.get(room);
			Iterator<String> iter = stu.keySet().iterator();
			while(iter.hasNext())
			{
				String id = iter.next();
				String name = stu.get(id);
				System.out.println(id+"::"+name);
			}
		}
	}

}