黑马程序员-Java基础:集合(Map)

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

双列集合-Map总结

一、Map概述

Map集合中存储的元素为键值对形式，即所有元素都是键值对的映射 .

特点：一个映射不能包含重复的键；每个键最多只能映射到一个值 .

主要功能 :

a: 添加

    V put(K key, V value): 添加元素.
b: 删除
    void clear(): 移除所有的元素.
    V remove(Object key): 根据指定的键进行删除.
c: 获取功能
   Set<Map.Entry<K,V>> entrySet(): 获取所有的键值对对象的Set集合(重点).
   V get(Object key): 根据键获取值.
   Set<K> keySet(): 获取所有的键对应的Set集合(重点).
   Collection<V> values(): 获取所有的值对应的Collection集合
 d: 长度功能
   int size(): 获取集合的长度.
 e: 判断功能 
   boolean containsKey(Object key): 判断这个集合是否包含指定的key.
   boolean containsValue(Object value): 判断这个集合是否包含指定的value.

   boolean isEmpty(): 判断集合是否为空.

Map 和 Collection 集合区别:
a: Map集合属于双列集合,Collection集合属于单列集合
b: Map集合的数据结构只针对键有效,而Collection集合的数据结构对存储的元素有效
c: Map集合的键唯一 , 而Collection集合中的Set集合可以保证元素的唯一性

例1-1：基本功能

public class MapDemo {
	
	public static void main(String[] args) {
		
		/**
		 *  V put(K key,V value):				添加元素
			V remove(Object key):				根据指定的key删除元素
			void clear():						移除所有的元素
			boolean containsKey(Object key):	判断是否包含指定的key
			boolean containsValue(Object value):判断是否包好指定的value
			boolean isEmpty():					判断集合是否为空
			int size():							获取集合的长度
		 */
		// 创建对象
		Map<String , String> map = new HashMap<String , String>() ;
		
		// V put(K key,V value):				添加元素
		/**
		 * V: 如果是第一次添加那么返回的就是null,如果不是第一次添加,如果键相同那么返回的就是上一次键对应的值
		 */
		System.out.println(map.put("文章", "马伊琍")) ;
		System.out.println(map.put("文章", "姚笛")) ;
		
		// V remove(Object key):根据指定的key删除元素
		/**
		 * V: 返回的是键对应的值
		 */
		System.out.println(map.remove("文章"));
		
		// void clear():
		map.clear() ;
		
		// boolean containsKey(Object key):	判断是否包含指定的key
		System.out.println(map.containsKey("文章"));
		System.out.println(map.containsKey("文章2"));
		
		// boolean containsValue(Object value):判断是否包好指定的value
		System.out.println(map.containsValue("马伊琍"));
		System.out.println(map.containsValue("姚笛"));
		
		// boolean isEmpty():	判断集合是否为空
		System.out.println(map.isEmpty());
		
		// int size():	获取集合的长度
		System.out.println(map.size());
				
		// 输出
		System.out.println("Map :" + map);		
		
	}

}

例1-2：Map集合遍历

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

/**
 * Map集合的遍历:			根据键获取值的遍历
 * 		步骤:
 * 			a: 创建集合对象
 * 			b: 添加元素
 * 			c: 获取所有的键对应的Set集合
 * 			e: 遍历当前的Set集合获取每一个元素,而每一个元素就是键 , 然后根据当前遍历的键获取对应的值
 */
public class MapDemo3 {
	
	public static void main(String[] args) {
		
		//  创建集合对象
		Map<String , String> map = new HashMap<String, String>() ;
		
		// 添加元素
		map.put("乔峰", "阿朱") ;
		map.put("段誉", "王语嫣") ;
		map.put("虚竹", "梦姑") ;
		map.put("方丈", "叶二娘") ;
		
		// 获取所有的键对应的Set集合
		Set<String> keys = map.keySet() ;
		
		// 遍历
		for(String s : keys) {
			
			// 根据当前遍历的元素获取对应的值
			String value = map.get(s) ;
			
			// 输出
			System.out.println(s + "----" + value);
		}
	}

}

输出结果：

方丈----叶二娘
虚竹----梦姑
乔峰----阿朱
段誉----王语嫣

二、HashMap

HashMap是基于哈希表的Map接口实现 

哈希表的作用是用来保证键的唯一性的。 

类似于HashSet集合，键中元素需要重写hashCode()和equals()方法 

元素的使用和Map集合相同。

HashMap和Hashtable的区别：

HashMap: 线程不安全 , 效率高  , 允许null值和null键

Hashtable:线程安全 , 效率低 , 不允许null和null键

列2-1：HashMap的遍历

需求:HashMap集合键是String值是Student

public class HashMapDemo2 {
	
	public static void main(String[] args) {
		
		// 创建集合对象
		HashMap<String , Student> map = new HashMap<String , Student>() ;
 		
		// 创建自定义对象
		Student s1 = new Student("刘亦菲" , 18) ;
		Student s2 = new Student("赵丽颖" , 16) ;
		Student s3 = new Student("陈伟博" , 16) ;
		Student s4 = new Student("裴杲琪" , 18) ;
		
		// 把自定义对象添加到集合中
		map.put("001", s1) ;
		map.put("002", s2) ;
		map.put("003", s3) ;
		map.put("004", s4) ;
		
		// 遍历
		// 第一种遍历: 通过键获取值进行遍历
		Set<String> keys = map.keySet() ;
		
		// 循环
		for(String key : keys) {
			
			// 通过键获取值
			Student s = map.get(key) ;
			
			// 输出
			System.out.println(key + "---" + s.getName() + "----" + s.getAge());
		}
		
		System.out.println("---------------------------");
		
		// 第二种遍历方式:	 通过键值对对象进行遍历
		Set<Entry<String,Student>> entrySet = map.entrySet() ;
		
		// 循环
		for(Entry<String,Student> en : entrySet) {
			
			// 获取键
			String key = en.getKey() ;
			
			// 获取值
			Student s = en.getValue() ;
			
			// 输出
			System.out.println(key + "---" + s.getName() + "----" + s.getAge());
			
		}
		
	}

}

三、LinkedHashMap 

是Map接口的哈希表和链接列表实现，具有可预知的迭代顺序， 有序 , 并且键是唯一的。 

由哈希表保证键的唯一性 

由链表保证键的有序(存储和取出的顺序一致) 

例：遍历

public class LinkedHashMapDemo {
	
	public static void main(String[] args) {
		
		// 创建对象
		LinkedHashMap<String , String> map = new LinkedHashMap<String , String>() ;
		
		// 添加元素
		map.put("hello", "你好") ;
		map.put("world", "世界") ;
		map.put("java", "爪哇") ;
		map.put("java", "爪哇2") ;
		
		// 遍历集合
		// 第二种遍历方式: 根据键值对对象遍历集合
		// 获取到键值对对象对应的Set集合
		Set<Entry<String,String>> entrySet = map.entrySet() ;
		
		// 遍历
		for(Entry<String,String> en : entrySet) {
			
			// 获取键
			String key = en.getKey() ;
			
			// 获取值
			String value = en.getValue() ;
			
			// 输出
			System.out.println(key + "----" + value);
			 
		}
		
	}

}

四、TreeMap

TreeMap : 底层的数据结构是二叉树, 可以对元素进行排序,而排序有分为两种方式:

第一种是自然排序 。

第二种是比较器排序, 那么我们区分到底使用的是那种排序主要依赖于构造方法。

Map集合的数据结构只针对键有效

例4-1:自然排序

public class TreeMapDemo {
	public static void main(String[] args) {	
		// 创建一个集合对象
		TreeMap<Integer , String> map = new TreeMap<Integer , String>() ;	
		// 添加元素
		map.put(23, "乔丹") ;
		map.put(24, "科比") ;
		map.put(3, "艾弗森") ;
		map.put(1, "麦迪") ;
		map.put(1, "姚明") ;		
		// 遍历
		// 第一种遍历: 使用键获取值的遍历
		Set<Integer> keySet = map.keySet() ;	
		// 循环
		for(Integer i : keySet) {		
			// 获取值
			String value = map.get(i) ;		
			// 输出
			System.out.println(i + "----" + value);		
		}		
		System.out.println("------------------------------");		
		// 第二种遍历方式:  获取键值对对象进行遍历
		Set<Entry<Integer,String>> entrySet = map.entrySet() ;
	
		// 循环
		for(Entry<Integer,String> en : entrySet) {
			
			// 获取键
			Integer key = en.getKey() ;
			
			// 获取值
			String value = en.getValue() ;
			
			// 输出
			System.out.println(key + "----" + value);			
		}				
	}
}

运行结果：

1----姚明
3----艾弗森
23----乔丹
24----科比
------------------------------
1----姚明
3----艾弗森
23----乔丹
24----科比

例4-2:比较器排序

public class TreeMapDemo {
	public static void main(String[] args) {	
		// 创建对象
		TreeMap<Student, String> map = new TreeMap<Student ,String>(new Comparator<Student>() {
			@Override
			public int compare(Student s1, Student s2) {			
				// 比较年龄
				int num = s1.getAge() - s2.getAge() ;			
				// 比较姓名
				int num2 = (num == 0) ? s1.getName().compareTo(s2.getName()) : num ;				
				return num2 ;
			}
		}) ;
				// 创建自定义对象
		Student s1 = new Student("太上老君" , 300) ;
		Student s2 = new Student("元始天尊" , 200) ;
		Student s3 = new Student("玉皇大帝" , 400) ;
		Student s4 = new Student("孙悟空" , 100) ;
		
		// 把自定义对象添加到集合中
		map.put(s1, "帅呆了") ;
		map.put(s2, "酷毙了") ;
		map.put(s3, "无法比喻了") ;
		map.put(s4, "还有谁?") ;
		
		// 遍历
		// 第二种方式: 获取所有的键值对对象进行遍历
		Set<Entry<Student,String>> entrySet = map.entrySet() ;
		
		// 循环
		for(Entry<Student,String> en : entrySet) {
			
			// 获取键
			Student key = en.getKey() ;
			
			// 获取值
			String value = en.getValue() ;
			
			// 输出
			System.out.println(key.getName() + "----" + key.getAge() + "---" + value);			
		}				
	}
}

运行结果：

孙悟空----100---还有谁?
元始天尊----200---酷毙了
太上老君----300---帅呆了
玉皇大帝----400---无法比喻了

五、TreeMap

对集合进行操作的工具类，都是静态方法。 
简单介绍几种方法，如过需要详细了解请查阅API文档：

public static <T> void sort(List<T> list)：排序 默认情况下是自然顺序。
public static <T> int binarySearch(List<?> list,T key):二分查找
public static <T> T max(Collection<?> coll):最大值
public static void reverse(List<?> list):反转
public static void shuffle(List<?> list):随机置换