JAVASE----11----Map集合

Map

1--HashTable: 底层是哈希表数据结构，不可以存入null健null值。该集合是线程同步的。 jdk1.0，效率低。
2--HashMap：底层是哈希表数据结构，允许使用null健null值。该集合是不同步的。jdk1.2，效率高。

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

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

基本方法：

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;

public class MapDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Map<String, String> map = new HashMap<String, String>();
		// 添加元素,如果出现添加时，有相同的键，后面添加的值会覆盖原有的键对应的值，并put方法会返回被覆盖的值。
		map.put("01", "zhangsan");
		map.put("01", "zhangsan01");
		map.put("02", "lisi");
		map.put("03", "wangwu");
		System.out.println(map.containsKey("01"));    //true
		System.out.println(map.remove("02"));   //lisi
		System.out.println(map.get("02"));      //null
		//可以通过get方法的返回值来判断一个键是否存在，通过返回null来判断。
		System.out.println(map.get("03"));     //wangwu
	     //获取map集合中所有值
    	Collection<String>coll=map.values();
    	System.out.println(coll);   //[zhangsan01, wangwu]
		System.out.println(map);     //{01=zhangsan01, 03=wangwu}


	}

}

取值方式：

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

public class MapDemo02 {

	/**
	 * Map集合中的2中取出方式： 1，keySet：将map中所有键存入到Set集合中。因为Set具备迭代器。
	 * 所一可以用迭代方式取出所有的键，在根据get方法。获取每一个键对应的值。
	 * 
	 * 
	 */
	public static void main(String[] args) {
		Map<String, String> map = new HashMap<String, String>();

		map.put("01", "zhangsan");
		map.put("04", "zhangsan01");
		map.put("02", "lisi");
		map.put("03", "wangwu");
		// 先获取map集合所有键的Set集合，keySet();
		Set<String> keySet = map.keySet();
		//通过Set集合就可以获取迭代器
		Iterator<String>it=keySet.iterator();
		while(it.hasNext())
		{   
			String key=it.next();
			//有了键通过map集合的get方法获取其对应的值。
			String value=map.get(key);
			System.out.println(value);
			//result: 
			//zhangsan01
			//zhangsan
			//lisi
			//wangwu

			
		}

	}

}

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

public class MapDemo02 {

	/**
	 * Map集合的取出原理：将map集合转成set集合，再通过迭代器取出。
	 * 
	 * 2， Set<Map.Entry<k,v>>entrySet： 将map集合中的映射关系存入到了set集合中，而这个关系的数据类型就是：
	 * Map.Entry
	 */
	public static void main(String[] args) {
		Map<String, String> map = new HashMap<String, String>();

		map.put("01", "zhangsan");
		map.put("04", "zhangsan01");
		map.put("02", "lisi");
		map.put("03", "wangwu");
		

			//将Map集合中的映射关系取出，存入到Set集合中。
		Set<Map.Entry<String, String>> entrySet=map.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+"="+value);
			
			//result:
			//04=zhangsan01
			//01=zhangsan
			//02=lisi
			//03=wangwu
		}

	}

}
/*
 * Map.Entry 其实Entry也是一个接口，它是Map接口中的一个内部接口。
 * interface  Map
 * {
 *   public static interface Entry
 *   {
 *      public  abstract Object getKey()；
 *      public  abstract Object getValue()；
 *   }
 * }
 * 
 */

练习一：

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

/* 每个学生都有对应的归属地
 * 保证学生的唯一性。
 * 
 * 1，描述学生
 * 2，定义map容器，将学生作为健，地制作为值传入。
 * 3，获取map集合中的元素。
 */
class Studentx implements Comparable<Studentx> {
	private String name;
	private int age;

	public Studentx(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public String toString() {

		return name + ":" + age;
	}

	@Override
	public int hashCode() {

		return name.hashCode() + age * 34;
	}

	@Override
	public boolean equals(Object obj) {
		if (!(obj instanceof Studentx))
			throw new ClassCastException("数据类型不匹配");

		Studentx s = (Studentx) obj;
		return this.name.equals(s.name) && this.age == s.age;

	}

	@Override
	public int compareTo(Studentx s) {
		int num = new Integer(this.age).compareTo(new Integer(s.age));
		if (num == 0) {
			return this.name.compareTo(s.name);
		}
		return num;

	}
}
public class Mapexercise {
	public static void main(String[] args) {
		HashMap<Studentx, String> hm = new HashMap<Studentx, String>();
		hm.put(new Studentx("lisi1", 21), "beijing");
		hm.put(new Studentx("lisi2", 20), "shanghai");
		hm.put(new Studentx("lisi3", 19), "shenzhen");
		hm.put(new Studentx("lisi4", 18), "guangzhou");
		hm.put(new Studentx("lisi4", 17), "changsha"); //会存入
		//hm.put(new Studentx("lisi4", 18), "changsha"); //会覆盖guangzhou
		//第一种取出方式 keySet
		   Set<Studentx> keySet = hm.keySet();  
	        Iterator<Studentx>iT=keySet.iterator();  
	        while(iT.hasNext())  
	        {     
	        	Studentx key=iT.next();  
	            String value=hm.get(key);  
	            System.out.println(value);  
	              
	        }  

		// 第二种取出方式
		Set<Map.Entry<Studentx, String>> entrySet = hm.entrySet();
		Iterator<Map.Entry<Studentx, String>> it = entrySet.iterator();
		while (it.hasNext()) {
			Map.Entry<Studentx, String>me=it.next();
			Studentx key=me.getKey();
			String value=me.getValue();
			System.out.println(key.getName()+"="+value);
		}
	}
}

把学生类按姓名排序；

class StuNameComparator implements Comparator<Studentx>
{

	@Override
	public int compare(Studentx s1, Studentx s2) {
		
		int num=s1.getName().compareTo(s2.getName());
		if(num==0)
		{
			return s1.getAge()-s2.getAge();
		}
	     return  num;
	}
	
}

TreeMap<Studentx, String> hm = new TreeMap<Studentx, String>(new StuNameComparator());

排序成功。


练习2：

import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;


public class Mapexercise2 {

	/**
	 * 获取字符串中的字母出现次数： a(1)c(2).......
	 * 当发现有映射关系时，可以选择map集合，因为map集合中存放的就是映射关系。
	 * 
	 * 思路：
	 * 1，将字符串转换成字符数组，因为要对每一个字母进行操作。
	 * 2，定义一个map集合，因为打印结果的字母有顺序，所以使用treemap集合。
	 * 3，便利字符数组，将每一个字母作为键去查map集合。
	 * 如果返回null，将该字母和1存入想到map集合中。
	 * 如果返回不是null，说明该字母在map集合已经存在并有对应的次数。
	 * 那么就获取该次数并进行自增，然后将该字母和自增后的次数存入到map集合中，覆盖原来键所对应的值。
	 * 4，将map集合中的数据变成指定的字符串形式返回。
	 */
	public static void main(String[] args) {
		
	String s=charCount("aasdasdasdsdfgfdfas");
	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++)
		{
			Integer value=tm.get(chs[x]);
			
		/*	if(value==null)
			{
				tm.put(chs[x], 1);
			}
			else
			{
				value=value+1;tm.put(chs[x], value);
			}*/
			if(value!=null)
				count=value;
			count++;
			tm.put(chs[x], count);
			count=0;
		}
		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 key=me.getKey();
			Integer value=me.getValue();
			sb.append(key+"("+value+")");
		}
		return sb.toString();
		
	}

}