32.Map集合

Map集合

1.Map集合概述

• Map接口概述
  查看API可以知道：
  将键映射到值的对象,一个映射不能包含重复的键,每个键最多只能映射到一个值

• B:Map接口和Collection接口的不同
  Map是双列的,Collection是单列的
  Map的键唯一,Collection的子体系Set是唯一的
  Map集合的数据结构值针对键有效，跟值无关;Collection集合的数据结构是针对元素有效

package heima_day18;

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

public class Demo1_Map {
	/**
 	A:Map集合的功能概述
	* a:添加功能
		* V put(K key,V value):添加元素。
			* 如果键是第一次存储，就直接存储元素，返回null
			* 如果键不是第一次存在，就用值把以前的值替换掉，返回以前的值
	* b:删除功能
		* void clear():移除所有的键值对元素
		* V remove(Object key)：根据键删除键值对元素，并把值返回
	* c:判断功能
		* boolean containsKey(Object key)：判断集合是否包含指定的键
		* boolean containsValue(Object value):判断集合是否包含指定的值
		* boolean isEmpty()：判断集合是否为空
	* d:获取功能
		* Set<Map.Entry<K,V>> entrySet():
		* V get(Object key):根据键获取值
		* Set<K> keySet():获取集合中所有键的集合
		* Collection<V> values():获取集合中所有值的集合
	* e:长度功能
		* int size()：返回集合中的键值对的个数
	 */
	public static void main(String[] args) {
		//Demo_a();	
		//Demo_b();
		Map<String, Integer>map = new HashMap<String, Integer>();
		map.put("abc",23);
		map.put("aaa",23);
		map.put("bbb",23);
		map.put("ccc",23);
		
		Collection<Integer> c = map.values();
		System.out.println(c);
		System.out.println(map.size());
	}

	private static void Demo_b() {
		Map<String, Integer>map = new HashMap<String, Integer>();
		map.put("abc",23);
		map.put("aaa",23);
		map.put("bbb",23);
		map.put("ccc",23);
		
		//Integer value = map.remove("abc");//根据键删除元素，返回对应的元素
		//System.out.println(value);
		System.out.println(map.containsKey("abc"));//判断是否包含传入的键
		System.out.println(map.containsKey(111));//判断是否包含传入的值
		System.out.println(map);
	}

	private static void Demo_a() {
		Map<String, Integer>map = new HashMap<String, Integer>();
		Integer i1 = map.put("abc",23);
		Integer i2 = map.put("aaa",23);
		Integer i3 = map.put("bbb",23);
		Integer i4 = map.put("ccc",23);
		Integer i5 = map.put("abc",27);//相同的键不存储，被覆盖的值返回
		System.out.println(map);
		System.out.println(i1);
		System.out.println(i2);
		System.out.println(i3);
		System.out.println(i4);
		System.out.println(i5);
	}

}

双列集合如何迭代？

第一种

package heima_day18;

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

public class Demo2_Map_Iterator {
	/**
	 * 通过看Map api发现没有Iterator，那双列集合如何迭代呢？
	 * *第一种迭代思路
	 *  A:键找值思路：
	 	* 获取所有键的集合
	 	* 遍历键的集合，获取到每一个键
	 	* 根据键找值
	 */
	public static void main(String[] args) {
		Map<String, Integer>map = new HashMap<String, Integer>();
		map.put("abc",23);
		map.put("aaa",24);
		map.put("bbb",25);
		map.put("ccc",26);
		
		Integer i = map.get("abc");//根据键获取值
		System.out.println(i);
		
		//获取所以的键
		Set<String> keySet = map.keySet(); //获取所有键的集合
		Iterator<String> it = keySet.iterator();//获取迭代器
		while(it.hasNext()) {//判断集合中是否有元素
			String key = it.next();//获取每一个键
			Integer value = map.get(key);//根据键获取值
			System.out.println(key+"---"+value);
		}
		//增强for循环迭代双列集合
		for (String key : map.keySet()) {//map.keySet()是所有键的集合
			System.out.println(key+"==="+map.get(key));
		}
	}

}

第二种

package heima_day18;

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

public class Demo3_Map_Iterator {
	/**
	 * 第二种迭代思路
	 * * A:键值对对象找键和值思路：
	 	* 获取所有键值对对象的集合
	 	* 遍历键值对对象的集合，获取到每一个键值对对象
	 	* 根据键值对对象找键和值
	 */
	public static void main(String[] args) {
		Map<String, Integer>map = new HashMap<String, Integer>();
		map.put("abc",23);
		map.put("aaa",24);
		map.put("bbb",25);
		map.put("ccc",26);
		//Map.Entry说明Entry是Map的内部接口，将键和值封装成了Entry对象，并存储在Set集合中
		Set<Map.Entry<String, Integer>> entrySet = map.entrySet();
		//获取每一个对象
		Iterator<Map.Entry<String, Integer>> it = entrySet.iterator();
		while(it.hasNext()) {
			//获取每一个entry对象
			Map.Entry<String, Integer> en = it.next();
			String key = en.getKey();//根据键值对对象获取键
			Integer value = en.getValue();//根据键值对对象获取值
			System.out.println(key+"==="+value);
		}
		
		for (Map.Entry<String, Integer> en : map.entrySet()) {
			System.out.println(en.getKey()+"----"+en.getValue());
		}
	}

}

2.HashMap

package heima_day18;

import java.util.HashMap;

import heima_day18_bean.Student;

public class Demo4_HashMap {
	/**
	 * * A:案例演示
	* HashMap集合键是Student值是String的案例
	 * 键是学生对象，代表每一个学生
	 * 值是字符串对象，代表学生归属地
	 */
	public static void main(String[] args) {
		HashMap<Student, String> hm = new HashMap<>();
		hm.put(new Student("张三",23),"北京");
		hm.put(new Student("张三",24),"上海");
		hm.put(new Student("王五",25),"深圳");
		hm.put(new Student("赵六",26),"广州");
		System.out.println(hm);
	}

}

3.LinkedHashMap

import java.util.LinkedHashMap;



public class Demo5_LinkedHashMap {

     /**

           * LinkedHashMap的特点

           * 底层是链表实现的可以保证怎么存就怎么取

      */

     public static void main(String[] args) {

           LinkedHashMap<String, Integer> lhm = new 
LinkedHashMap<String, Integer>();

           lhm.put("aaa", 23);

           lhm.put("bbb", 24);

           lhm.put("ccc", 25);

           lhm.put("ddd", 26);

           System.out.println(lhm);

     }



}

4.TreeMap

package heima_day18;

import java.util.TreeMap;

import heima_day18_bean.Student;

public class Demo6_TreeMap {
	/**
	 * * A:案例演示
	 * TreeMap集合键是Student值是String的案例
	 */
	public static void main(String[] args) {
			Demo1();
			/**
			TreeMap<Student, String> tm = new TreeMap<>(new Comparator<Student>() {
				public int compare(Student s1, Student s2) {
					int num =s1.getName().compareTo(s2.getName());
					return num == 0 ? s1.getAge() -s2.getAge():num;
				}
			});
			tm.put(new Student("张三",23),"北京");
			tm.put(new Student("张三",24),"上海");
			tm.put(new Student("王五",15),"深圳");
			tm.put(new Student("赵六",26),"广州");
*/			
	}
	private static void Demo1() {
		TreeMap<Student, String> tm = new TreeMap<>();
		tm.put(new Student("张三",23),"北京");
		tm.put(new Student("张三",24),"上海");
		tm.put(new Student("王五",15),"深圳");
		tm.put(new Student("赵六",26),"广州");
		System.out.println(tm);
	}

}

5.HashMap嵌套HashMap

package heima_day18;

import java.util.HashMap;

import heima_day18_bean.Student;

public class Demo7_HashMapHashMap {
	/**
	 * 集合嵌套之HashMap嵌套HashMap
	 * 需求
	 * 双元课堂很多基础班
	 * 第88期基础班定义一个双列集合，键是学生对象，值是学生归属地
	 * 第99期基础班定义一个双列集合，键是学生对象，值是学生归属地
	 * 无论88期还是99期都是班级对象，所以为了统一管理，把这些班级放进双元课堂中
	 */
	public static void main(String[] args) {
		//定义88期基础班
		HashMap<Student, String> hm88 = new HashMap<>();
		hm88.put(new Student("张三",23),"北京");
		hm88.put(new Student("张三",24),"上海");
		hm88.put(new Student("王五",25),"深圳");
		hm88.put(new Student("赵六",26),"广州");
		//定义99期基础班
		HashMap<Student, String> hm99 = new HashMap<>();
		hm99.put(new Student("abc",123),"北京");
		hm99.put(new Student("aaa",124),"上海");
		hm99.put(new Student("bbb",125),"深圳");
		hm99.put(new Student("ccc",126),"广州");
		//定义双元课堂
		HashMap<HashMap<Student, String> , String> hm = new HashMap<HashMap<Student,String>, String>();
		hm.put(hm88, "第88期基础班");
		hm.put(hm99, "第99期基础班");
		//遍历双列集合
		for (HashMap<Student, String> h : hm.keySet()) {//hm.keyset()代表的是双列集合中键的集合
			String value = hm.get(h);//get(h)根据键对象获取值对象
			//遍历双列集合
			for (Student key : h.keySet()) { //h,keyset()获取集合中所有的学生的键
				String value2 = h.get(key);
				System.out.println(key+"--"+value2+"--"+value);
			}
		}
	}

}

6.HashMap和Hashtable的区别

Hashtable是JDK1.0版本出现的,是线程安全的,效率低,
HashMap是JDK1.2版本出现的,是线程不安全的,效率高
Hashtable不可以存储null键和null值,HashMap可以存储null键和null值