13、java.util.Map集合

一、Map映射

 

/**
 *java.util.Map<K,V>
 *K - 此映射所维护的键的类型
 *V - 映射值的类型
 *将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。 
 *Map 接口提供三种collection 视图，允许以键集、值集或键-值映射关系集的形式查看某个映射的内容。
 *映射顺序 定义为迭代器在映射的 collection 视图上返回其元素的顺序。
 *某些映射实现可明确保证其顺序，如 TreeMap 类；
 *另一些映射实现则不保证顺序，如 HashMap 类。
 */
public interface Map<K,V>
{
	/**
	 *
	 *内部接口，映射项（键-值对）。
	 *映射项（键-值对）。Map.entrySet 方法返回映射的 collection 视图，其中的元素属于此类
	 *获得映射项引用的唯一 方法是通过此 collection 视图的迭代器来实现。
	 *
	 */
	public static interface Map.Entry<K,V>
	{
		//返回与此项对应的键。
		K getKey();
		
		//返回与此项对应的值。
		V getValue();

		//用指定的值替换与此项对应的值（可选操作）。
		V setValue(V value);

		//比较指定对象与此项的相等性。
		boolean equals(Object o);

		//返回此映射项的哈希码值。
		int hashCode();
	}

	//返回此映射中的键-值映射关系数。
	int size();

	//如果此映射未包含键-值映射关系，则返回 true。
    boolean isEmpty();

	//如果此映射包含指定键的映射关系，则返回 true。
    boolean containsKey(Object key);

	//如果此映射将一个或多个键映射到指定值，则返回 true
    boolean containsValue(Object value);

    //返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null
    V get(Object key);

    //将指定的值与此映射中的指定键关联（可选操作）。
	//如果添加时，键相同，那么后添加的值会覆盖原有键对应值，并put方法返回被覆盖的值
    V put(K key, V value);

	//如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。
    V remove(Object key);

	//从指定映射中将所有映射关系复制到此映射中（可选操作）。
    void putAll(Map<? extends K, ? extends V> m);

	//从此映射中移除所有映射关系（可选操作）。
    void clear();

	//返回此映射中包含的键的 Set 视图。
    Set<K> keySet();

    //返回此映射中包含的值的 Collection 视图。
    Collection<V> values();

    //返回此映射中包含的映射关系的 Set 视图。
    Set<Map.Entry<K, V>> entrySet();

    //比较指定的对象与此映射是否相等
    boolean equals(Object o);

	//返回此映射的哈希码值。
    int hashCode();
}

 

二、Map体系

 

Map

   |--Hashtable<K,V>：底层是哈希表数据结构，不可以存入null键null值，该集合是线程同步的，jdk1.0，效率低

   |--HashMap<K,V>：底层是哈希表数据结构，允许null键和null值，该集合是不同步的，jdk1.2，效率高

   |--TreeMap<K,V>：底层是二叉树数据结构，线程不同步，可以用于给map集合中的键进行排序

 

三、HashMap集合

 

/**
 *基于哈希表的 Map 接口的实现。
 *此实现提供所有可选的映射操作，并允许使用 null 值和 null 键
 *除了非同步和允许使用 null 之外，HashMap 类与 Hashtable 大致相同
 *此类不保证映射的顺序，特别是它不保证该顺序恒久不变。
  *为了成功地在哈希表中存储和获取对象，用作键的对象必须实现 hashCode 方法和 equals 方法。
 */
public class HashMap<K,V>extends AbstractMap<K,V>
	implements Map<K,V>, Cloneable, Serializable
{
	//构造方法*********************

	//构造一个具有默认初始容量 (16) 和默认加载因子 (0.75) 的空 HashMap
	public HashMap(){}

	//构造一个带指定初始容量和默认加载因子 (0.75) 的空 HashMap
	public HashMap(int initialCapacity){}

	//构造一个带指定初始容量和加载因子的空 HashMap。
	public HashMap(int initialCapacity,float loadFactor){}

	//构造一个映射关系与指定 Map 相同的新 HashMap。
	//所创建的 HashMap 具有默认加载因子 (0.75) 和足以容纳指定 Map 中映射关系的初始容量。
	public HashMap(Map<? extends K,? extends V> m){}

	//常用方法与Map一致
}

 

四、TreeMap集合

 

/**
 *基于红黑树（Red-Black tree）的 NavigableMap 实现
 *该映射根据其键的自然顺序进行排序
 *或者根据创建映射时提供的 Comparator 进行排序，具体取决于使用的构造方法
 *不同步
 */
public class TreeMap<K,V>extends AbstractMap<K,V>
	implements NavigableMap<K,V>, Cloneable, Serializable
{
	//构造方法*********************

	//使用键的自然顺序构造一个新的、空的树映射。插入该映射的所有键都必须实现 Comparable 接口
	public TreeMap(){}

	//构造一个新的、空的树映射，该映射根据给定比较器进行排序
	public TreeMap(Comparator<? super K> comparator){}

	//构造一个与给定映射具有相同映射关系的新的树映射，该映射根据其键的自然顺序 进行排序
	public TreeMap(Map<? extends K,? extends V> m){}

	//常用方法与Map一致
}

 

五、Map集合取出元素的两种方式

 

    原理：将map集合转成set集合，再通过迭代器取出

 

 1，Set<K> keySet：返回此映射中包含的键的 Set 视图，将Map中所有的键存入到Set集合，因为set具备迭代器，所以可以迭代方式取出所有的键，再根据get方法，获取每一个键对应的值

import java.util.*;

class MapDemo 
{
	public static void main(String[] args) 
	{
		HashMap<String,String> hm = new HashMap<String,String>();
		hm.put("01","zhangsan");
		hm.put("02","lisi");
		hm.put("03","wangwu");
		hm.put("04","zhaoliu");
		Set<String> set=hm.keySet();
		Iterator<String> it = set.iterator();
		while(it.hasNext())
		{
			String key = it.next();
			String value = hm.get(key);
			System.out.println(key+":"+value);
		}
	}
}

 

2，Set<Map.Entry<k,v>> entrySet()：将map集合中的映射关系存入到了set集合中，而这个关系的数据类型就是：Map.Entry

import java.util.*;

class MapDemo 
{
	public static void main(String[] args) 
	{
		HashMap<String,String> hm = new HashMap<String,String>();
		hm.put("01","zhangsan");
		hm.put("02","lisi");
		hm.put("03","wangwu");
		hm.put("04","zhaoliu");
		Set<Map.Entry<String,String>> set=hm.entrySet();
		Iterator<Map.Entry<String,String>> it = set.iterator();
		while(it.hasNext())
		{
			Map.Entry<String,String> entry = it.next();
			String key = entry.getKey();
			String value = entry.getValue();
			System.out.println(key+":"+value);
		}
	}
}

 

六、使用集合的技巧

 

1. 看到Array就是数组结构，有角标，查询速度很快。
2. 看到link就是链表结构：增删速度快，而且有特有方法。addFirst； addLast； removeFirst()； removeLast()； getFirst()；getLast()；
3. 看到hash就是哈希表，就要想要哈希值，就要想到唯一性，就要想到存入到该结构的中的元素必须覆盖hashCode，equals方法。
4. 看到tree就是二叉树，就要想到排序，就想要用到比较。
5. 比较的两种方式：
6. 一个是Comparable：覆盖compareTo方法；
7. 一个是Comparator：覆盖compare方法。
8. LinkedHashSet，LinkedHashMap:这两个集合可以保证哈希表有存入顺序和取出顺序一致，保证哈希表有序。

七、集合什么时候用？

 

• 当存储的是一个元素时，就用Collection。当存储对象之间存在着映射关系时，就使用Map集合。
• 保证唯一，就用Set。不保证唯一，就用List。