Map集合

Map是一种把键(key)和值(value)进行映射的集合（k-v）。k相当于v的索引，v仍然可以是Map类型(k-v)。
键（key）和值（value）都可以是任何引用类型的数据。
Map的键（key）不允许重复，即同一个Map对象的任何两个key通过equals方法比较结果总是返回false。
key集的存储形式和Set集合完全相同(即key不能重复)
value集的存储形式和List非常类似(即value可以重复、根据索引来查找)
key可以为null(map中只能有一个为null的key)
key与value是单项一对一关系。即通过key只能找到一个唯一的value值
Map数据结构中存储的数据的顺序不是固定的，Map中的数据，相当于麻袋中存储数据，保证不了顺序

Map集合的应用

  1. HashMap：按照哈希算法来存取key，有很好的存取性能，和HashSet一样，要求覆盖equals()方法和hasCode()方法，同时也不能保证集合中每个key-value对的顺序。
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class HashMapTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Map<String,Integer> m = new HashMap<String,Integer>();
		/*
		 * V put(K key, V value) 用于存储键值对数据
		 */
		m.put("aa", 1);
		m.put("bb", 2);
		m.put("cc", 3);
		System.out.println(m);
		输出：{aa=1, bb=2, cc=3}
		
		/*
		 * 如果再次存储key相同的key-value数据，
		 * 会覆盖之前的value值
		 */
		//再次存储aa，其value值为6
		m.put("aa", 6);
		System.out.println(m);
		//输出：{aa=6, bb=2, cc=3}
		
		/*
		 * V get(Object key) 通过key获取value，如果没有key对象，返回值为null
		 */
		Integer i = m.get("aa");
		System.out.println("aa对应的value值是："+i);
		//输出：aa对应的value值是：6
		
		/*
		 * boolean isEmpty() 如果此集合不包含键值映射，则返回 true 。  
		 */
		System.out.println("集合不包含键值对数据？"+m.isEmpty());
		//输出：集合不包含键值对数据？false
		
		/*
		 * Set<K> keySet() 返回此集合中包含的键的Set视图。  
		 */
		Set<String> s = m.keySet();
		System.out.println("集合中包含的key的Set视图："+s);
		//输出：集合中包含的key的Set视图：[aa, bb, cc]
		
		/*
		 * Set<Map.Entry<K,V>> entrySet() 返回此集合中包含的映射的Set视图。  
		 * Entry对象封装了一个key-value键值对
		 */
		Set<Map.Entry<String,Integer>> s1 = m.entrySet();
		System.out.println("集合中包含的key-value键值对的Set视图："+s1);
		//输出：集合中包含的key-value键值对的Set视图：[aa=6, bb=2, cc=3]
		
		/*
		 * V remove(Object key) 通过指定的key移除key-value键值对，返回value值  
		 */
		//移除键值对aa=1;
		Integer i1 = m.remove("aa");
		System.out.println("被移除的value值："+i1);
		//输出：被移除的value值：6
		
		/*
		 * boolean containsKey(K k)  判断是否包含指定的key值
		 * boolean cotainsValue(V v)  判断是否包含指定的value值
		 */
		System.out.println("集合中是否包含key为aa的值："+m.containsKey("bb"));
		System.out.println("集合中是否包含value为6的值："+m.containsValue(2));
		/*
		 * 输出：集合中是否包含key为aa的值：true
		 *     集合中是否包含value为6的值：true
		 */
		
		/*
		 * void clear()  清空map中的键值对 
		 */
		m.clear();
		System.out.println("清空map中的键值对："+m);
		//输出：清空map中的键值对：{}

	}

}
  1. LinkedHashMap：LinkedHashMap 是 HashMap 的子类。使用双向链表来维护key-value对的次序，该链表负责维护Map的迭代顺序，迭代顺序与 Key-Value 对的插入顺序一致。
import java.util.LinkedHashMap;
import java.util.Map;

public class LinkedHashMapDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Map<String,String> m = new LinkedHashMap<String,String>();
		m.put("aa","100");
		m.put("bb","200");
		m.put("cc","300");
		m.put("dd","400");
		System.out.println(m);
		//输出：{aa=100, bb=200, cc=300, dd=400}
		/*
		 * Set<K> keySet() 返回此集合中包含的键的Set视图。  
		 */
		//遍历m中的所有键值对
		for(String key:m.keySet()){
			System.out.println(key+"："+m.get(key));
		}
		/*
		 * 输出：aa：100
		 * 	   bb：200
		 * 	   cc：300
		 * 	   dd：400
		 */
		
		/*
		 * 说明：LinkedHashMap中的集合排序与插入的顺序保持一致
		 */
	}
}
  1. TreeMap：一个红黑树数据结构，每个key-value对即作为红黑树的一个节点。实现了SortedMap接口，能对key进行排序。TreeMap可以保证所有的key-value对处于有序状态。同样，TreeMap也有两种排序方式（自然排序、定制排序）

Map集合的遍历

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

public class MapBL {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Map<String,Integer> score = new HashMap<String,Integer>();
		score.put("语文", 100);
		score.put("数学", 99);
		score.put("英语", 90);
		score.put("物理", 99);
		score.put("化学", 100);
		System.out.println(score);
		//输出：{物理=99, 数学=99, 化学=100, 语文=100, 英语=90}
		
		/*
		 * Set<Entry<K,V>>  entrySet()
		 * 返回值为：Map的内部类Entry对象的Set集合
		 * 
		 * 内部类Entry：Entry对象封装了一个key-value键值对
		 */
		Set<Entry<String,Integer>> s = score.entrySet();
		for(Entry<String,Integer> e:s){
			System.out.println(e.getKey()+"="+e.getValue());
		}
		/*
		 * 输出：
		 * 物理=99
		 * 数学=99
		 * 化学=100
		 * 语文=100
		 * 英语=90
		 */
		
		/*
		 * Set<K>  keySet()
		 * 将map中所有的key封装到Set集合对象里
		 */
		Set<String> s1 = score.keySet();
		for(String key:s1){
			System.out.println(key+"="+score.get(key));
		}
		/*
		 * 输出：
		 * 物理=99
		 * 数学=99
		 * 化学=100
		 * 语文=100
		 * 英语=90
		 */
		
		/*
		 * Collection<V> values();
		 * 将map中的所有value封装成一个Collection集合对象
		 * 
		 * 返回值对象：HashMap的内部类Values对象
		 */
		Collection<Integer> c = score.values();
		for(Integer i:c){
			System.out.println(i);
		}
		/*
		 * 输出：
		 * 99
		 * 99
		 * 100
		 * 100
		 * 90
		 */
		

	}

}