Java_Map集合

一、Map集合：

   map集合中存储的元素是成对出现的元素，这种成对出现的元素，我们称之为键值对元素。

  该集合存储键值对，一对一往里存，而且要保证唯一性。

  一个映射不能包含重复的键，每个键最多只能映射到一个值

二、Map集合功能：

1添加
        put(K key,V value):添加元素。
            如果键是第一次存储，就直接存储元素，返回null
            如果键不是第一次存在，就用值把以前的值替换掉，返回以前的值

        putAll(Map<?  extends K,? extendsV> m)从指定映射中将所有映射关系复制到此映射中
     2 删除
         void clear():移除所有的键值对元素
        V remove(Object key)：根据键删除键值对元素，并把值返回
     3 判断
        booleancontainsKey(Object key)：判断集合是否包含指定的键
        booleancontainsValue(Object value):判断集合是否包含指定的值
        booleanisEmpty()：判断集合是否为空
     4 获取
        Set<Map.Entry<K,V>> entrySet():???
        V get(Object key):根据键获取值
        Set<K> keySet():获取集合中所有键的集合
        Collection<V> values():获取集合中所有值的集

代码演示：

Map<String,String> map = new HashMap<String,String>();//创建map集合
		//添加元素，如果出现添加的键值相同时，后添加的会覆盖原有键值对
		sop(map.put("01","lisi01"));
		sop(map.put("01","zhangsan"));

		map.put("02","lisi02");
		map.put("03","lisi03");
		map.put("04","lisi04");
		
		sop(map.containsKey("01"));//sop()为输出方法
		sop(map.remove("03"));//删除并返回对应的值

		sop(map);
		Collection coll = map.values();//是返回的是集合
		sop(coll);

三、Map集合的两种获取方式keySet()与entrySet()

1 keySet():

将map中所有的键存入Set集合中，因为Set有迭代器
所以可以用迭代器的方式取出所有的值，再根据get方法，获取每一个键对应的值,

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");

		第一种方法KeySet()方法
		//先获取map集合的所有的键的set的集合，keySet()
		Set<String> keyset = map.keySet();
		//有了Set集合，就可以获取迭代器
		Iterator<String> it = keyset.iterator();
		while(it.hasNext())
		{
			String key = it.next();
			sop("key:"+key);
		}

2 entrySet()

返回的set集合中存放的是映射关系，实际使用如代码所示

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<Map.Entry<String,String>> entryset = map.entrySet();//获取所有的键值对象的集
		Iterator<Map.Entry<String,String>> it = entryset.iterator();//获取迭代器
		while(it.hasNext())
		{
			Map.Entry entry = it.next();//获取键值对对象
			sop(entry.getKey());//获取键
		}

四  Map练习

1、将学生信息存入，具体如代码所示：

/*
每一个学生都有对应的归属地
学生student 地址 String
学生属性 姓名 年龄
注意 姓名和年龄相同视为同一个学生
保证学生的唯一性

1、描述学生

2、定义map容器，将学生作为键，地址作为值，存入

3、获取map集合中的元素
*/
import java.util.*;
class Student implements Comparable<Student>//实现比较器接口，泛型为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 int hashCode()
	{
		return name.hashCode()+age*34;
	}
	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;
	}
}
class MapTest 
{
	public static void main(String[] args) 
	{
		Map<Student,String> map = new HashMap<Student,String>();
		map.put(new Student("zhangsan1",17),"beijing");
		map.put(new Student("zhangsan2",13),"shanghai");
		map.put(new Student("zhangsan3",14),"wuhan");
		map.put(new Student("zhangsan2",15),"tianjin");

		//第一种方法KeySet()方法
		//先获取map集合的所有的键的set的集合，keySet()
		Set<Student> keyset = map.keySet();
		//有了Set集合，就可以获取迭代器
		Iterator<Student> it = keyset.iterator();
		while(it.hasNext())
		{
			Student key = it.next();
			sop("name:"+key.getName()+"..."+"age:"+key.getAge()+"..."+map.get(key));
			
		}
		//第二种方法
		//set集合中存放的是映射关系
		Set<Map.Entry<Student,String>> entryset = map.entrySet();
		Iterator<Map.Entry<Student,String>> it1 = entryset.iterator();
		while(it1.hasNext())
		{
			Map.Entry<Student,String> entry = it1.next();
			sop("sfsdfsfsa"+"name:"+entry.getKey().getName()+"..."+"age:"+entry.getKey().getAge()+"..."+map.get(entry.getKey()));
		}


	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

2、练习：

“sdfgzxcvasdfxcvdf”获取该字符串中的字母出现的次数

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

/*

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

注意了，当发现有映射关系时，可以选择map集合
因为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) 
	{
	    String s = charCount("assdfasdf");
		sop(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++)
		{
			Integer value = tm.get(chs[x]);
			if(value!=null)
				count = value;
			count++;
			tm.put(chs[x],count);
		}
		sop(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 sop(Object obj)
	{
		System.out.println(obj);
	}
}