java hashmap

 public interface Map<K,V>

    将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。

    此接口取代 Dictionary 类，后者完全是一个抽象类，而不是一个接口。

所有已知实现类：

AbstractMap, Attributes, AuthProvider, ConcurrentHashMap, ConcurrentSkipListMap, EnumMap, HashMap, Hashtable, IdentityHashMap, LinkedHashMap, PrinterStateReasons, Properties, Provider, RenderingHints, SimpleBindings, TabularDataSupport, TreeMap, UIDefaults, WeakHashMap

HashMap,Hashtable的区别：

 

         Map   接口
            |
            |---HashMap
                    put(key, value): 保存键值对数据
                    get(key): 获取指定键对应的值
                    entrySet(): 获取map中所有键值对数据的一个set集合,通过set集合的迭代器可以对map中的数据遍历迭代
                    keySet(): 获取map中所有键的一个set集合,通过set集合的迭代器可以对map中的键进行遍历迭代,可以通过get方法来获取迭代的数据

 

          java.util.Dictionary<K,V>//抽象类
                           |---java.util.Hashtable<K,V>

• HashMap 允许使用 null 值和 null 键;Hashtable 的key与value都不可以为null
• Hashtable 是线程安全的，一般用HashMap替代Hashtable
• HashMap 实现线程安全 ： Collections.synchronizedMap(Map<K,V> m)

 

package com.d120914;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.TreeMap;

/**
 * 关于Map排序的练习
 * @author ermao
 * 2012-9-17下午2:59:55
 * TODO
 */
public class MapSortTest_01 
{
	
	public static void main(String[] args) {
		MapSortTest_01 t1 = new MapSortTest_01();
		Map map = t1.initHashMap();
		System.out.println("---------------------");
		t1.sortByEntryVal(map);
		System.out.println("---------------------");
		t1.sortByTreeMap(map);
	}

	
	/**
	 * HashMap 初始化的方法
	 * 通过put(k, v)添加值
	 * @return HashMap<String, Integer>
	 */
	public Map<String, Integer> initHashMap()
	{
		Map<String, Integer> map = new HashMap<String, Integer>();
    		map.put("07", 57);
    		map.put("02", 78);
    		map.put("08", 79);
    		map.put("03", 90);
    		map.put("09", 80);
    		map.put("04", 39);
    		map.put("01", 87);
    		map.put("06", 79);
    		map.put("05", 19);
		map.put("aa", 12);
		map.put("ab", 2);
		map.put("ba", 22);
		map.put("ac", 0);
		map.put("ca", 11);
		map.put("cb", 12);
		map.put("bc", 18);
		
		displayByEntry(map);
		
		return map;
	}

	
	/**
	 * 通过map的键获取值
	 * 首先通过keySet()获取所有的 key 集合
	 * 然后通过Iterator hasNext()方法循环，next()获取值
	 * @param map
	 */
	public void displayByKey(Map<String, Integer> map)
	{
		Iterator<String> itKey = map.keySet().iterator();
		while(itKey.hasNext())
		{
			Object key = itKey.next();
			System.out.println(key+":"+map.get(key));
		}
	}

	
	/**
	 * 通过map的key-value 实体获取
	 * 首先通过entrySet()获取所有的 Entry 集合
	 * 然后通过Iterator hasNext()方法循环，next()获取值单个Entry
	 * 最后通过getKey()获取key,通过getValue()获取value 
	 * @param map
	 */
	public void displayByEntry(Map<String, Integer> map)
	{
		Iterator<Entry<String, Integer>> itEn = map.entrySet().iterator();
		while(itEn.hasNext())
		{
			Entry<String, Integer> e = (Entry<String, Integer>)itEn.next();
			System.out.println(e.getKey()+":"+e.getValue());
		}
	}

	
	/**
	 * 通过containsKey()判断该map是否包含某一个键
	 * 也可以通过 map.containsValue(value) 判断是否包含某一个值
	 * @param map Map
	 * @param key Object map的键
	 * @return
	 */
	public boolean isContainsKey(Map<Object, Object> map, Object key)
	{
		if(map == null)
		{
			return false;
		}
		
		if(!map.containsKey(key))
		{
			return false;
		}
		
		return true;
	}

	
	/**
	 * 借助List实现HashMap排序
	 * 
	 * HashMap本按照hash算法以一定顺序存放，所以既不是我们put进的先后顺序，也不是我们需要的升序或降序
	 * 对HashMap实现排序：
	 * 1.借助TreeMap默认对键升序
	 * 2.借助List，通过实现一个比较器，完成对Map的键或值进行自定义排序
	 * 		2.1 new ArrayList<Entry<String, Integer>>(map.entrySet());
	 *      2.2 实现一个比较器，MyCompare implements Comparator
	 *      2.3 用Collections.sort(List, Comparator);进行排序
	 */
	public void sortByEntryVal(Map map)
    	{
		List<Entry<String, Integer>> arrayList = new ArrayList<Entry<String, Integer>>(map.entrySet());
		
		//升序
		Collections.sort(arrayList,new MyCompare());
		
		//反序，变成降序
//		Collections.reverse(arrayList);
		
		Iterator<Entry<String, Integer>> it = arrayList.iterator();
		while(it.hasNext())
		{
			System.out.println(it.next());
		}
    	}

	
	/**
	 * 借助TreeMap默认对键升序排序
	 * 同样可以实现一个比较器，对map的键进行自定义排序
	 * @param map
	 */
	public void sortByTreeMap(Map map)
	{
		TreeMap tm = new TreeMap(map);
		displayByKey(tm);
		//TreeMap tm = new TreeMap(new MyCompare1());
  		//tm.putAll(map);
  		//displayByKey(tm);	}

}

/**
 * 实现一个比较器 implements Comparator 重写 public int compare(Object o1, Object o2) {}
 * @author ermao
 * 2012-9-17下午2:59:55
 * TODO
 */
class MyCompare implements Comparator<Object>
{
	@SuppressWarnings("unchecked")
	public int compare(Object o1, Object o2) {
		Entry<String, Integer> ob1 = (Entry<String, Integer>)o1;
		Entry<String, Integer> ob2 = (Entry<String, Integer>)o2;
		int r1 = ob1.getValue();
		int r2 = ob2.getValue();
		//降序排序
//		if(r1 == r2)
//		{
//			return 0;
//		}
//		else if(r1 > r2)
//		{
//			return -1;//1升序
//		}
//		else 
//		{
//			return 1;//-1
//		}
		
//		System.out.println(ob1.getValue()+"-"+ob2.getValue()+"="+(ob1.getValue() - ob2.getValue()));
		
		//升序
		return ob1.getValue() - ob2.getValue();

		//降序
//		return -(ob1.getValue() - ob2.getValue());
		
	}
}