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

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

Map集合

   Map集合：该集合存储键值对，是一对一对存的，需要保证键的唯一性。

集合中的方法：

1.添加：

      put(K key,V value),一对一对存储。

      putAll(Map<?extends L,? extends V> m)存储map

2.删除：

      clear()清空

      remove(Object key):根据键去除值

3.判断：

      containsValue(Object value)是否包含值

      containsKey(Object key)是否包含值

4.获取：

      get（object key)根据键获取值

      size()获取长度

      values()取出所有值

Map集合子类：

      Hashtable：底层是哈希表数据结构，不可以存入null键null值，是线程同步的。

      HashMap：底层是哈希表数据结构，允许使用null键和null值，是线程不同步，效率比Hashtable较高

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

其实Set底层就使用了map结构。

方法练习：

package xiaobing.collection;
import java.util.*;
public class MapDemo01 {
	public static void main(String[] args)
	{
		Map<String,String> map=new HashMap<String,String>();
		//添加元素
		map.put("01", "zhangsan1");
		map.put("02", "zhangsan2");
		map.put("03", "zhangsan3");
		//判断是够包含值
		System.out.println("containsKey:"+map.containsKey("02"));
		//取设定的键对应的值
		System.out.println("get。。。"+map.get("03"));
		//可以存入空的键值
		map.put("04", null);
		//所以可以通过get方法得返回值来判断一个是否存在，通过返回空值
		//获取map集合中所有值
		Collection<String> c1=map.values();
		System.out.println(c1);
		//存入相同的键的时候，新的会替换掉旧的值，而put方法会将之前的值返回出来
		System.out.println("put..."+map.put("04", "zhangsan4"));
		System.out.println("put..."+map.put("04", "zhangsan5"));
		System.out.println(map);
	}
}

map集合的两种取出方式：

   1.Set<k>keySet：将map中所有键存入Set集合，因为Set具备迭代器，然后获取每一个键的值

   2.Set<Map.Entry<k,v>>entrySet:返回一个数据类型为Map.Entry的映射关系。

package xiaobing.collection;
import java.util.*;

/*
 * keySet获取所有值
 */
public class MapDemo02 {
	public static void main(String[] args)
	{
		Map<String,String> map=new HashMap<String,String>();
		//添加元素
		map.put("02", "zhangsan2");
		map.put("03", "zhangsan3");
		map.put("01", "zhangsan1");
		map.put("04", "zhangsan4");
		//先获取键的Set集合
		Set<String> keySet=map.keySet();
		//获取set集合迭代器
		Iterator<String> it=keySet.iterator();
		while(it.hasNext())
		{
			String key=it.next();
			//有了键就可以获取value的值
			String value=map.get(key);
			System.out.println(key+"...."+value);
			//有了键就可以获取value的值
		}

	}
}

package xiaobing.collection;
import java.util.*;
public class MapDeno03 {
	public static void main(String[] args)
	{
		Map<String,String> map=new HashMap<String,String>();
		//添加元素
		map.put("02", "zhangsan2");
		map.put("03", "zhangsan3");
		map.put("01", "zhangsan1");
		map.put("04", "zhangsan4");
		//将映射关系取出
		Set<Map.Entry<String,String>> entrySet=map.entrySet();
		//Set迭代器
		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+"..."+value);
		}
    }
}

练习1：

package xiaobing.collection;
import java.util.*;
/*
 * 练习：
 * 每一个学生都有对应的归属地
 * 学生Student，地址String
 * 学生属性：姓名，年龄
 * 年龄姓名一致为同一个
 * 保证学生的唯一性
 * 思路
 * 1.描述学生
 * 2.定义map容器，将学生作为键，地址为值存入
 * 3.获取map集合中的元素
 */
class Student2 implements Comparable<Student2>
{
	private String name;
	private int age;
	Student2(String name,int age)
	{
		this.name=name;
		this.age=age;
	}
	//定义比较方法
    public int compareTo(Student2 s)
    {
    	int num=new Integer(this.age).compareTo(new Integer(s.age));
    	if(num==0)
    		return this.name.compareTo(s.name);
    	return num;
    }
    //复写hashCode方法
	public int hashCode()
	{
		return name.hashCode()+age*34;
	}
	//复写equal方法
	public boolean equals(Object obj)
	{
		if(!(obj instanceof Student2))
			throw new ClassCastException("类型不匹配");
		Student2 s=(Student2) obj;
		return this.name.equals(s.name)&&this.age==s.age;
	}
	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}
	//复写toString方法，定义字符串输出方式
	public String toString()
	{
		return name+".."+age;
	}
	
}
public class MapDemo04 {
	public static void main(String[] args)
	{
		HashMap<Student2,String> hm=new HashMap<Student2,String>();
		hm.put(new Student2("lisi1",21), "beijing");
		hm.put(new Student2("lisi2",22), "shanghai");
		hm.put(new Student2("lisi3",23), "nanjing");
		hm.put(new Student2("lisi4",24), "wuhan");
		//取出值
		Set<Student2> keySet=hm.keySet();
		Iterator<Student2> it=keySet.iterator();
		while(it.hasNext())
		{
			Student2 stu=it.next();
			String addr=hm.get(stu);
			System.out.println(stu+"..."+addr);
		}

}
}

练习2：

package xiaobing.collection;
import java.util.*;
/*
 * 练习：获取"asdcsfsafefdagcsdfr"字符串长字母的出现的次数
 * 希望打印a(1)b(2)..
 * 通过结果发现每一个字母对应的次数
 * 说明存在映射关系
 * 发现映射关系就可以使用Map集合
 * 思路：
 * 1，将字符串转换为字母
 * 2.定义一个map集合，因为打印的有顺序，用Treemap集合
 * 3.遍历数组，将每一个字母作为键查询map集合，如果返回null将
 * 字母和1返回集合中
 * 如果不是将值加1存入集合中，覆盖掉原来的键对应值
 * 4.将map集合中的数据变为指定的字符串形式返回
 */
public class DemoTest01 {
	public static String charCount(String str)
	{
		//转换为字符数组
		char[] chs=str.toCharArray();
		TreeMap<Character,Integer> tm=new TreeMap<Character,Integer>();
		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)
			{
				//不存在数据时存入
				tm.put(chs[x], 1);
			}
			else
			{
				//值加1存入
				value=value+1;
				tm.put(chs[x], value);

			}
		}
		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();
	}
	public static void main(String[] args)
	{
		
		String s=charCount("asdcsfsafefdagcsdfr");
		System.out.println(s);
	}
}