黑马程序员---集合：Map

------- Java、.Net、Android培训期待与您交流！------- 

一、概述：

Map集合：该集合存储键值对，一对一对往里存，而且要保证键的唯一性。
1、添加。
        put(K key, V value) ;   //K：key键，V：value值
        putAll(Map<? extends K,? extends V> m) ;

2、删除。
        clear( ) ;   //清空集合
        remove(Object key) ;

3、判断。
        containsValue(Object value) ; //是否包含某个值
        containsKey(Object key) ;  //是否包含某个键
        isEmpty( ) ;   //判断集合长度是否为0

4、获取。
        get(Object key) ;   //通过对应键获取值
        size( ) ;   //获取集合大小/长度
        values( ) ; 

        entrySet( ) ;  //集合中键和值的取出方式1
        keySet( ) ;    //集合中键和值的取出方式2

二、Map子类及用法

|--Map
        |--Hashtable：底层是哈希表数据结构，不可以存入null键null值。该集合是线程同步的。jdk1.0.效率低。
        |--HashMap：底层是哈希表数据结构，允许使用null 值和null 键。该集合是不同步的。JDK1.2版本后替代Hashtable，效率高。
        |--TreeMap：底层是二叉树数据结构，线程不同步。可以用于给map集合中的键进行排序。

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

Map集合的两种取出方式：
        1、Set<k> keySet：将Map中所有的键存入到Set集合，因为Set具备迭代器。所有可以迭代方式取出所有的键，在通过get( )方法，获取每一个键对应的值。 

        2、Set<Map.Entry<k,v>> entrySet：将Map集合中的映射关系存入到了Set集合中，而这个关系的数据类型就是：Map.Entry。Entry其实就是Map中的一个static内部接口。为什么要定义在内部呢？因为只有有了Map集合，有了键值对，才会有键值的映射关系。关系属于Map集合中的一个内部事物，而且该事物在直接访问Map集合中的元素。

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

下面分别就Map集合的两个子类作分别做一个例子：

1、HashMap应用

        需求：每一个学生都有对应的归属地：学生Student，地址String。
        学生属性：姓名，年龄。
        注意：姓名和年龄相同的视为同一个学生，保证学生的唯一性。

        思路：
                1、描述学生。
                2、定义HashMap容器(无序)，将学生作为键，地址作为值，存入。
                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;
	}
	//复写compareTo方法，使其满足人这个元素具有自定义的比较方法
	public int compareTo(Student stu)
	{
		int num = this.name.compareTo(stu.name);
		if (num==0)
			return new Integer(this.age).compareTo(new Integer(stu.age));
		return num;
	}
	//复写equals和hashCode是为了保证键值的唯一性，相同键值仅出现一个。类似于一个角标对应一个值。
	//复写equals方法
	public boolean equals(Object obj)
	{
		//判断若传入的值不是Student类，那么就抛出类型不匹配异常，让使用者修改传入值
		if (!(obj instanceof Student))
			throw new ClassCastException("类型不匹配，需要Student类。");
		Student stu = (Student)obj;
		return this.name.equals(stu.name) && this.age==stu.age;
	}
	//复写hashCode方法
	public int hashCode()
	{
		//age*40是为了将不同人之间的hashCode值扩大化。因为有时候可能出现不同人姓名的哈希值相同
		return name.hashCode()+age*40;
	}

	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}
	//复写toString方法，打印：字符串<==>引用变量.toString();
	public String toString()
	{
		return name+":"+age;
	}
}

class  HashMapTest
{
	public static void main(String[] args) 
	{
		HashMap<Student,String> hm = new HashMap<Student,String>();
		//若没有复写equals和hashCode方法，结果会两个相同的键值都打印出来。这样就出现安全问题
		hm.put(new Student("HashMap_1",21),"BeiJing");
		hm.put(new Student("HashMap_2",22),"TianJin");
		hm.put(new Student("HashMap_3",23),"ShangHai");
		hm.put(new Student("HashMap_1",21),"NanJing");
		hm.put(new Student("HashMap_4",24),"WuHan");

		//第一种取出方式keySet()：该方式中泛型进获取HashMap集合中的键值Student
		Set<Student> keySet = hm.keySet();

		for (Iterator<Student> it = keySet.iterator(); it.hasNext(); )
		{
			Student stu = it.next();
			String addr = hm.get(stu);	//根据当前键值获取HashMap集合中键值对应的地址值。
			System.out.println(stu+","+addr);
		}
		
		//第二种取出方式entruSet()
		//Map.Entry中Entry是Map接口的内部静态接口，且该泛型获取的是HashMap集合中的映射关系，也就是包括Student和地址
		Set<Map.Entry<Student,String>> entrySet = hm.entrySet();
		//Map集合不具备迭代器，仅有List和Set集合具备
		for (Iterator<Map.Entry<Student,String>> iter = entrySet.iterator(); iter.hasNext(); )
		{
			Map.Entry<Student,String> me = iter.next();
			Student stu = me.getKey();	//获取键：学生(姓名和年龄)
			String addr = me.getValue();	//获取值：学生地址
			System.out.println(stu+".."+addr);
		}
	}
}

2、TreeMap应用

    需求："sdf.g[]zx=c+vasdfxc_v>df"获取该字符串中的字母出现的次数。

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

    思路：
        通过结果发现，每一个字母都有对应的次数。说明字母和次数之间都有映射关系。

    步骤：
        1、定义类CharCount，声明成员变量char[] chs;
        2、定义toCharArray方法，将字符串转成字符数组；
        3、定义charCount方法，计数字符数组中每个字符的个数，并将其映射关系存入TreeMap集合中；
        4、定义stringBuilder方法，将TreeMap集合中的键和值根据要求存入到StringBuilder容器中；
        5、定义toString方法，将StringBuilder容器转成可打印的字符串。
        6、在main方法中创建CharCount对象，实现其中public方法。

import java.util.*;

class CharCount
{
	private char[] chs;
	//将字符串转变成字符数组
	public char[] toCharArray(String str)
	{	
		return chs = str.toCharArray();
	}
	//打印最终的字符串表现形式
	public String toString(char[] chs)
	{
		//调用字符技术方法，计算字符在字符数组中出现的次数，并放于Map集合中
		TreeMap<Character,Integer> tm = charCount(chs);	
		return stringBuilder(tm).toString();	//将StringBuilder容器中的字符串变成可打印的字符串，并返回。
	}
	//将字符数组中字符及其对应出现的次数存入TreeMap集合中
	private TreeMap<Character,Integer> charCount(char[] chs)
	{
		TreeMap<Character,Integer> tm = new TreeMap<Character,Integer>();
		
		int count = 0;	//初始化计数器
		for (int i=0; i<chs.length; i++)
		{
			//判断当前字符是否是字母，不是字母则跳出当前循环继续开始下一次for循环
			if (!(chs[i]>='a' && chs[i]<='z' || chs[i]>='A' && chs[i]<='Z'))
				continue;  //
			Integer value = tm.get(chs[i]);	//获取TreeMap集合中当前键值所对应的值
			if (value!=null)
				count = value;
			count++;
			tm.put(chs[i],count);
			count = 0;	//重置计数器
		}
		System.out.println("TreeMap中的映射关系："+tm);
		return tm;
	}
	//将TreeMap集合中的键和值按照一定关系存入容器StringBuilder中
	private StringBuilder stringBuilder(TreeMap<Character,Integer> tm)
	{
		StringBuilder sb = new StringBuilder();	 //定义字符串容器，长度可变，可对当前字符串进行多次操作
		//使用Map的第二种方法，将映射关系存入泛型中。
		Set<Map.Entry<Character,Integer>> entrySet = tm.entrySet();
		for (Iterator<Map.Entry<Character,Integer>> it = entrySet.iterator(); it.hasNext(); )
		{
			Map.Entry<Character,Integer> me = it.next();
			Character ch = me.getKey();	  //获取映射中的键值：字符
			int value = me.getValue();	  //获取映射中的值：次数
			sb.append(ch+"("+value+")");  //按照格式将键值和次数存入字符串容器中
		}

		return sb;
	}
}

class  TreeMapTest2
{
	public static void main(String[] args) 
	{
		String str = "sdf.g[]zx=c+vasdfxc_v>df";
		CharCount cc = new CharCount();
		char[] chs = cc.toCharArray(str);
		String str_1 = cc.toString(chs);
		System.out.println("实际结果："+str_1);	
	}
}

    总结：Map集合应用比较广，而我们生活中存在基本上都具备映射关系，所以我们在遇到有映射关系的数据时，就要先考虑到Map集合。Map集合的方法和Collection集合差不多，熟悉HashMap和TreeMap使用的数据结构。记住Map集合自身不具备取出数据的功能，所以要通过keySet和entrySet方法来将其转换成Set集合来处理，通过获取键或键值的映射关系来获取Map集合中的键和值。