java SE基础(Map接口及其实现)

map接口的继承关系如下图所示

1。Map接口

    (1)Map 接口提供三种collection 视图，允许以键集、值集或键-值映射关系集的形式查看某个映射的内容
    (2)某些映射实现可明确保证其顺序，如 TreeMap 类；另一些映射实现则不保证顺序，如 HashMap 类。
    (3)将可变对象用作映射键时必须格外小心。如果以影响 equals 比较的方式更改了对象的值，则映射的行为将是不确定的
    (4)一个映射不能包含重复的键；每个键最多只能映射到一个值
    (5)嵌套接口Map.Entry<K,V>
        映射项(键-值对),Map.entrySet方法返回映射的collection视图。获得映射项引用的唯一方法是通过此 collection 视图的迭代器来实现

public static interface Map.Entry<K,V>{
	K getKey();						//返回与此项对应的键
	V getValue();					//返回与此项对应的值
	V setValue(V value);			//用指定的值替换与此项对应的值
}

    (6)部分方法

public interface Map<K,V>{
	int size();							//返回此映射中的键-值映射关系数
	boolean containsKey(Object key);	//如果此映射包含指定键的映射关系，则返回 true
	boolean containsValue(Obj value);	//如果此映射将一个或多个键映射到指定值，则返回 true
	V get(Object key);					//返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null
	V put(K key, V value);				//将指定的值与此映射中的指定键关联
	V remove(Object key);				//如果存在一个键的映射关系，则将其从此映射中移除
	Collection<V> values();				//返回此映射中包含的值的 Collection 视图
	Set<K> keySet();					//返回此映射中包含的键的 Set 视图
	Set<Map.Entry<K,V>> entrySet();		//返回此映射中包含的映射关系的 Set 视图
}</span>

2。HashMap类

    (1)基于hash表，允许null值和null键，线程不同步
    (2)不保证映射的顺序恒久不变
    (3)部分方法

public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>,Cloneable,Serializable{
	public HashMap(){}						//构造一个具有默认初始容量(16)和默认加载因子(0.75)的空HashMap
	public HashMap(int initialCapacity){}	//构造一个带指定初始容量和默认加载因子(0.75)的空HashMap
	public HashMap(int initialCapacity,float loadFactor){}		//构造一个带指定初始容量和加载因子的空HashMap
	public HashMap(Map<? extends K,? extends V> m){}			//构造一个映射关系与指定 Map 相同的新 HashMap
	
	public V put(K key,V value){}			//在此映射中关联指定值与指定键。如果该映射以前包含了一个该键的映射关系，则旧值被替换
}                  

(4)例如

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

public class MyHashMap {
	
	public static void main(String[] args) {
		HashMap<Integer	, String> hashmap = new HashMap<Integer , String>();				//创建哈希映射对象
		
		String[] str = {"zero" , "one" , "two" , "three" , "four" , "five" , "six" , "seven"};	//初始化对象
		for(int i  = 0 ; i < 8 ; i++)
			hashmap.put(i, str[i]);
		
		Set<Map.Entry<Integer, String>> set = hashmap.entrySet();							//获取键值对对象集合
		Iterator< Map.Entry<Integer, String>> iterator = set.iterator();					//获取集合的迭代器
		while(iterator.hasNext()){															//遍历集合，取出键值对
			Map.Entry<Integer , String> mapentry = iterator.next();
			System.out.print( "[ "+mapentry.getKey()+","+mapentry.getValue()+" ]\t" );
		}
		System.out.println();
		
		Set<Integer> keyset = hashmap.keySet();					//获取键的集合
		Iterator<Integer> keyiterator = keyset.iterator();		//获取键集合的迭代器
		while(keyiterator.hasNext()){							//遍历键集合，并通过键获取值
			Integer key = keyiterator.next();
			System.out.print( "[ "+key+","+hashmap.get(key)+" ]\t" );
		}
		System.out.println();
		
		System.out.println( hashmap.containsKey(2) );			//测试是否包含某个键或值
		System.out.println( hashmap.containsValue("two") );
		
		System.out.println( hashmap.size() ); 					//获取键值对数目
		
		System.out.println( hashmap.remove(2) );				//根据键移除键值对
		System.out.println( hashmap.put(null, null) );
		System.out.println( hashmap.put(null, "name") );
		System.out.println( hashmap.size() );  					//获取键值对数目
		
		System.out.println( hashmap.containsKey(2) );			//测试是否包含某个键或值
		System.out.println( hashmap.containsValue("two") );
		
		Collection<String> valuecollection = hashmap.values();	//获取值得集合
		Iterator<String> valueiterator = valuecollection.iterator();				//获取迭代器
		while(valueiterator.hasNext())
			System.out.print( valueiterator.next()+"\t" );
		System.out.println();
	}
}

3。SortedMap接口

    (1)进一步提供关于键的总体排序的Map。根据其键的自然顺序进行排序的，或者根据创建有序映射时提供的Comparator进行排序
    (2)插入有序映射的所有键都必须实现Comparable接口,所有这些键都必须是可互相比较的
    (3)部分方法

public interface SortedMap<K,V> extends Map<K,V>{
	Comparator<? super K> comparator();			//返回对此映射中的键进行排序的比较器；如果此映射使用键的自然顺序，则返回 null
	Set<Map.Entry<K,V>> entrySet();				//返回在此映射中包含的映射关系的 Set 视图
	SortedMap<K,V> subMap(K fromKey, K toKey);	//返回此映射的部分视图，其键值的范围从 fromKey（包括）到 toKey（不包括
}

4。TreeMap类

    (1)基于红黑树、键不能null、线程不同步
    (2)此实现为 containsKey、get、put 和 remove 操作提供受保证的 log(n) 时间开销
    (3)部分方法

public class TreeMap<K,V> extends AbstractMap<K,V> implements NavigableMap<K,V>, Cloneable, Serializable{
	TreeMap(){}									//使用键的自然顺序构造一个新的、空的树映射
	TreeMap(Comparator<? super K> comparator){}	//构造一个新的、空的树映射，该映射根据给定比较器进行排序
	
	Collection<V> values(){}					//返回此映射包含的值的 Collection 视图
	Set<K> keySet(){}							//返回此映射包含的键的 Set 视图
	Set<Map.Entry<K,V>> entrySet(){}			//返回此映射中包含的映射关系的 Set 视图
	
	NavigableMap<K,V> descendingMap(){}			//返回此映射中所包含映射关系的逆序视图
	
	Comparator<? super K> comparator(){}		//返回对此映射中的键进行排序的比较器；如果此映射使用键的自然顺序，则返回 nul
}

    (4)例如

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

public class TreeMapCom implements Comparator<Person>{
	public static void main(String[] args) {
		TreeMap<Person,String> treemap = new TreeMap<Person,String>(new TreeMapCom());	//创建树映射对象
		
		String[] str = {"zero","one","two","three","four","five"};						//初始化
		Random rnum = new Random();
		Random rage = new Random();
		int i = 0;
		while( i < str.length){
			Person person = new Person(rnum.nextInt(30), rage.nextInt(20));
			if(!treemap.containsKey(person)){
				treemap.put(person, str[i]);
				i++;
			}
		}
		
		Set<Map.Entry<Person, String>> entry = treemap.entrySet();						//获取键值对集合
		Iterator<Map.Entry<Person, String>> iterator = entry.iterator();				//获取迭代器
		while(iterator.hasNext()){														//遍历
			Map.Entry<Person, String> temp = iterator.next();
			System.out.print( "[ "+temp.getKey().toString()+","+temp.getValue()+" ]\t" );
		}
		System.out.println();
	}
	
/*	@Override
	public int compare(Person arg0, Person arg1) {
		return arg0.getAge() - arg1.getAge();
	}*/
	@Override
	public int compare(Person arg0, Person arg1) {
		return arg0.getNumber() - arg1.getNumber();
	}
}				

5。Hashtable类

    (1)基于哈希表、键和值均不能null、线程同步
    (2)部分方法

public class Hashtable<K,V> extends Dictionary<K,V> implements Map<K,V>, Cloneable, Serializable{
	Hashtable(){}											//用默认的初始容量 (11) 和加载因子 (0.75) 构造一个新的空哈希表
	Hashtable(int initialCapacity, float loadFactor){}		//用指定初始容量和指定加载因子构造一个新的空哈希表
	
	Set<Map.Entry<K,V>> entrySet(){}						//返回此映射中包含的键的 Set 视图
	Set<K> keySet(){}										//返回此映射中包含的键的 Set 视图
	Collection<V> values(){}								//返回此映射中包含的键的 Collection视图
	
	V put(K key, V value){}									//将指定 key 映射到此哈希表中的指定 value
	protected  void rehash(){}								//增加此哈希表的容量并在内部对其进行重组，以便更有效地容纳和访问其元素
}   

    (3)例如

import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;
import java.util.Random;
import java.util.Set;

public class MyHashtable {
	public static void main(String[] args) {
		Hashtable<Integer , Integer> hashtable = new Hashtable<Integer, Integer>();								//创建hashtable对象
		
		Random rkey = new Random();						//利用随机数进行初始化
		Random rvalue = new Random();
		int key , value , count = 0 ;
		while( count < 8 ){
			key = rkey.nextInt(20);
			value = rvalue.nextInt(30);
			
			if(!hashtable.containsKey(key)){
				hashtable.put(key, value);
				count++;
			}
		}
		
		Set< Map.Entry<Integer, Integer> > set = hashtable.entrySet();											//遍历hashtable
		Iterator< Map.Entry<Integer, Integer> > iterator = set.iterator();
		while(iterator.hasNext()){
			Map.Entry<Integer, Integer> entry = iterator.next();
			System.out.print( "[ "+entry.getKey()+","+entry.getValue()+" ]\t" );
		}
		System.out.println();
		System.out.println(hashtable.toString());
		System.out.println(hashtable.hashCode());
	}
}