Day17-集合(中)Map

---

Map家族

特点：键值对存储

（1），为什么需要使用map？前面源码分析中常见它的身影,在里面充当了一个什么作用？
Map存储的元素为键值对，通常称为key-value
而key是不允许重复的
Set唯一
（2），掌握Map的常用方法–整体有个印象，我们首先掌握的是HashMap

（3），一一掌握上述的每个方法的应用（采用String，Integer等JDK已提供的引用数据类型）
基本方法的使用
重点掌握数据的存储及遍历的方式（两种遍历方式都要掌握）
（4），深入掌握HashMap的关键技术点，如何区分是否重复？以自定义类型来作为key探究问题的关键
—Map<String,String>
—Mp<自定义类型,String>
看要怎么保证键的唯一性？自定义类型也需要根据业务需求来确定唯一性，(hashcode，equals)

（5），LinkedHashMap
上述的HashMap存储的数据是唯一但无序的，而如果采用LinkedHashMap则是有序且唯一的

（6），TreeMap
有排序的功能,先采用String类型或Integer类型来学习TreeMap的特点
—TreeMap<String,String>
—TreeMap<Integer,Integer>
再以自定义类型来作为key，这个时候又需要我们做什么来保证可排序性？
—TreeMap<自定义类型,String>

1. HashMap(实现类)

特点：key是唯一的

package com.dream.hashmap_class;

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

public class Test01 {
	
	public static void main(String[] args) {
		/**
		 * 使用HashMap的常用方法
		 */
		
		HashMap<String, Integer> map = new HashMap<>();
		
		//添加元素
		map.put("麻生希", 29);
		map.put("椎名空", 24);
		map.put("爱田奈奈", 36);
		map.put("古川伊织", 28);
		map.put("小峰由衣", 34);
		map.put("北条麻衣", 34);
		
		//替换 - 如果key存在，直接替换value值，并返回原来的value
		Integer put = map.put("麻生希", 30);
		System.out.println("获取被替换掉的原值：" + put);
		
		//替换
		map.replace("麻生希", 31);//通过key替换value
		map.replace("麻生希", 31, 32);//通过key和value替换value
		
		//如果key存在，返回值key对应的value
		//如果key不存在，添加元素
		Integer putIfAbsent = map.putIfAbsent("xxx", 1000);
		System.out.println(putIfAbsent);
		
		//添加整个集合
		HashMap<String, Integer> newMap1 = new HashMap<>();
		newMap1.put("古川伊织", 29);
		newMap1.put("aaa", 28);
		newMap1.put("bbb", 28);
		newMap1.put("ccc", 28);
		map.putAll(newMap1);
		
		//删除
		map.remove("爱田奈奈");//通过key删除映射关系
		map.remove("椎名空", 100);//通过key和value删除映射关系
		
		//通过Key获取Value
		Integer v = map.get("古川伊织");
		System.out.println("通过Key获取Value：" + v);
		
		System.out.println("判断集合中是否有某个key：" + map.containsKey("椎名空"));
		System.out.println("判断集合中是否有某个value：" + map.containsValue(34));
		
		System.out.println("获取key对应的value值，如果key不存在，就返回默认值：" + map.getOrDefault("椎名空1", 100));
		
		System.out.println("判断集合中是否没有元素：" + map.isEmpty());
		
		System.out.println("获取集合中映射关系的个数：" + map.size());
		
		//将Map集合中所有的value取出存入到Collection集合中
		Collection<Integer> values = map.values();
		System.out.println(Arrays.toString(values.toArray()));
		
		
		System.out.println("-------------------");
		
		//遍历
		
		//keySet()：将map集合中所有的key取出，存入Set集合中，遍历Set集合，将Key依次取出，再取出对应的value
		Set<String> keySet = map.keySet();
		for (String key : keySet) {
			Integer value = map.get(key);
			System.out.println(key + " -- " + value);
		}
		
		System.out.println("-------------------");
		
		//entrySet()：将map集合中所有的Entry取出，存入Set集合中，遍历Set集合，将Entry依次取出，再取出Entry里的key和value
		Set<Entry<String, Integer>> entrySet = map.entrySet();
		for (Entry<String, Integer> entry : entrySet) {
			String key = entry.getKey();
			Integer value = entry.getValue();
			System.out.println(key + " -- " + value);
		}
		
	}
}

2. LinkedHashMap

package com.dream.linkedhashmap_class;

import java.util.Arrays;
import java.util.Collection;
import java.util.LinkedHashMap;
import java.util.Map.Entry;
import java.util.Set;

public class Test01 {
	
	public static void main(String[] args) {
		/**
		 * 使用LinkedHashMap的常用方法
		 */
		
		LinkedHashMap<String, Integer> map = new LinkedHashMap<>();
		
		//添加元素
		map.put("麻生希", 29);
		map.put("椎名空", 24);
		map.put("爱田奈奈", 36);
		map.put("古川伊织", 28);
		map.put("小峰由衣", 34);
		map.put("北条麻衣", 34);
		
		//替换 - 如果key存在，直接替换value值，并返回原来的value
		Integer put = map.put("麻生希", 30);
		System.out.println("获取被替换掉的原值：" + put);
		
		//替换
		map.replace("麻生希", 31);//通过key替换value
		map.replace("麻生希", 31, 32);//通过key和value替换value
		
		//如果key存在，返回值key对应的value
		//如果key不存在，添加元素
		Integer putIfAbsent = map.putIfAbsent("xxx", 1000);
		System.out.println(putIfAbsent);
		
		//添加整个集合
		LinkedHashMap<String, Integer> newMap1 = new LinkedHashMap<>();
		newMap1.put("古川伊织", 29);
		newMap1.put("aaa", 28);
		newMap1.put("bbb", 28);
		newMap1.put("ccc", 28);
		map.putAll(newMap1);
		
		//删除
		map.remove("爱田奈奈");//通过key删除映射关系
		map.remove("椎名空", 100);//通过key和value删除映射关系
		
		//通过Key获取Value
		Integer v = map.get("古川伊织");
		System.out.println("通过Key获取Value：" + v);
		
		System.out.println("判断集合中是否有某个key：" + map.containsKey("椎名空"));
		System.out.println("判断集合中是否有某个value：" + map.containsValue(34));
		
		System.out.println("获取key对应的value值，如果key不存在，就返回默认值：" + map.getOrDefault("椎名空1", 100));
		
		System.out.println("判断集合中是否没有元素：" + map.isEmpty());
		
		System.out.println("获取集合中映射关系的个数：" + map.size());
		
		//将Map集合中所有的value取出存入到Collection集合中
		Collection<Integer> values = map.values();
		System.out.println(Arrays.toString(values.toArray()));
		
		
		System.out.println("-------------------");
		
		//遍历
		
		//keySet()：将map集合中所有的key取出，存入Set集合中，遍历Set集合，将Key依次取出，再取出对应的value
		Set<String> keySet = map.keySet();
		for (String key : keySet) {
			Integer value = map.get(key);
			System.out.println(key + " -- " + value);
		}
		
		System.out.println("-------------------");
		
		//entrySet()：将map集合中所有的Entry取出，存入Set集合中，遍历Set集合，将Entry依次取出，再取出Entry里的key和value
		Set<Entry<String, Integer>> entrySet = map.entrySet();
		for (Entry<String, Integer> entry : entrySet) {
			String key = entry.getKey();
			Integer value = entry.getValue();
			System.out.println(key + " -- " + value);
		}
		
	}
}

3. Hashtable

package com.dream.hashtable_class;

import java.util.Arrays;
import java.util.Collection;
import java.util.Hashtable;
import java.util.Map.Entry;
import java.util.Set;

public class Test01 {
	
	public static void main(String[] args) {
		/**
		 * 使用Hashtable的常用方法
		 */
		
		Hashtable<String, Integer> map = new Hashtable<>();
		
		//添加元素
		map.put("麻生希", 29);
		map.put("椎名空", 24);
		map.put("爱田奈奈", 36);
		map.put("古川伊织", 28);
		map.put("小峰由衣", 34);
		map.put("北条麻衣", 34);
		
		//替换 - 如果key存在，直接替换value值，并返回原来的value
		Integer put = map.put("麻生希", 30);
		System.out.println("获取被替换掉的原值：" + put);
		
		//替换
		map.replace("麻生希", 31);//通过key替换value
		map.replace("麻生希", 31, 32);//通过key和value替换value
		
		//如果key存在，返回值key对应的value
		//如果key不存在，添加元素
		Integer putIfAbsent = map.putIfAbsent("xxx", 1000);
		System.out.println(putIfAbsent);
		
		//添加整个集合
		Hashtable<String, Integer> newMap1 = new Hashtable<>();
		newMap1.put("古川伊织", 29);
		newMap1.put("aaa", 28);
		newMap1.put("bbb", 28);
		newMap1.put("ccc", 28);
		map.putAll(newMap1);
		
		//删除
		map.remove("爱田奈奈");//通过key删除映射关系
		map.remove("椎名空", 100);//通过key和value删除映射关系
		
		//通过Key获取Value
		Integer v = map.get("古川伊织");
		System.out.println("通过Key获取Value：" + v);
		
		System.out.println("判断集合中是否有某个key：" + map.containsKey("椎名空"));
		System.out.println("判断集合中是否有某个value：" + map.containsValue(34));
		
		System.out.println("获取key对应的value值，如果key不存在，就返回默认值：" + map.getOrDefault("椎名空1", 100));
		
		System.out.println("判断集合中是否没有元素：" + map.isEmpty());
		
		System.out.println("获取集合中映射关系的个数：" + map.size());
		
		//将Map集合中所有的value取出存入到Collection集合中
		Collection<Integer> values = map.values();
		System.out.println(Arrays.toString(values.toArray()));
		
		
		System.out.println("-------------------");
		
		//遍历
		
		//keySet()：将map集合中所有的key取出，存入Set集合中，遍历Set集合，将Key依次取出，再取出对应的value
		Set<String> keySet = map.keySet();
		for (String key : keySet) {
			Integer value = map.get(key);
			System.out.println(key + " -- " + value);
		}
		
		System.out.println("-------------------");
		
		//entrySet()：将map集合中所有的Entry取出，存入Set集合中，遍历Set集合，将Entry依次取出，再取出Entry里的key和value
		Set<Entry<String, Integer>> entrySet = map.entrySet();
		for (Entry<String, Integer> entry : entrySet) {
			String key = entry.getKey();
			Integer value = entry.getValue();
			System.out.println(key + " -- " + value);
		}
		
	}
}

4. ConcurrentHashMap

package com.dream.concurrenthashmap_class;

import java.util.Arrays;
import java.util.Collection;
import java.util.Map.Entry;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;

public class Test01 {
	
	public static void main(String[] args) {
		/**
		 * 使用ConcurrentHashMap的常用方法
		 */
		
		ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
		
		//添加元素
		map.put("麻生希", 29);
		map.put("椎名空", 24);
		map.put("爱田奈奈", 36);
		map.put("古川伊织", 28);
		map.put("小峰由衣", 34);
		map.put("北条麻衣", 34);
		
		//替换 - 如果key存在，直接替换value值，并返回原来的value
		Integer put = map.put("麻生希", 30);
		System.out.println("获取被替换掉的原值：" + put);
		
		//替换
		map.replace("麻生希", 31);//通过key替换value
		map.replace("麻生希", 31, 32);//通过key和value替换value
		
		//如果key存在，返回值key对应的value
		//如果key不存在，添加元素
		Integer putIfAbsent = map.putIfAbsent("xxx", 1000);
		System.out.println(putIfAbsent);
		
		//添加整个集合
		ConcurrentHashMap<String, Integer> newMap1 = new ConcurrentHashMap<>();
		newMap1.put("古川伊织", 29);
		newMap1.put("aaa", 28);
		newMap1.put("bbb", 28);
		newMap1.put("ccc", 28);
		map.putAll(newMap1);
		
		//删除
		map.remove("爱田奈奈");//通过key删除映射关系
		map.remove("椎名空", 100);//通过key和value删除映射关系
		
		//通过Key获取Value
		Integer v = map.get("古川伊织");
		System.out.println("通过Key获取Value：" + v);
		
		System.out.println("判断集合中是否有某个key：" + map.containsKey("椎名空"));
		System.out.println("判断集合中是否有某个value：" + map.containsValue(34));
		
		System.out.println("获取key对应的value值，如果key不存在，就返回默认值：" + map.getOrDefault("椎名空1", 100));
		
		System.out.println("判断集合中是否没有元素：" + map.isEmpty());
		
		System.out.println("获取集合中映射关系的个数：" + map.size());
		
		//将Map集合中所有的value取出存入到Collection集合中
		Collection<Integer> values = map.values();
		System.out.println(Arrays.toString(values.toArray()));
		
		
		System.out.println("-------------------");
		
		//遍历
		
		//keySet()：将map集合中所有的key取出，存入Set集合中，遍历Set集合，将Key依次取出，再取出对应的value
		Set<String> keySet = map.keySet();
		for (String key : keySet) {
			Integer value = map.get(key);
			System.out.println(key + " -- " + value);
		}
		
		System.out.println("-------------------");
		
		//entrySet()：将map集合中所有的Entry取出，存入Set集合中，遍历Set集合，将Entry依次取出，再取出Entry里的key和value
		Set<Entry<String, Integer>> entrySet = map.entrySet();
		for (Entry<String, Integer> entry : entrySet) {
			String key = entry.getKey();
			Integer value = entry.getValue();
			System.out.println(key + " -- " + value);
		}
		
	}
}

package com.dream.concurrenthashmap_class;

import java.util.HashMap;
import java.util.Hashtable;
import java.util.concurrent.ConcurrentHashMap;

public class Test02 {
	
	public static void main(String[] args) {
		/**
		 * HashMap vs Hashtable vs ConcurrentHashMap
		 * 
		 * HashMap 允许存储null键
		 * Hashtable 不允许存储null键
		 * ConcurrentHashMap 不允许存储null键
		 */
		
//		HashMap<Object,Object> map = new HashMap<>();
//		map.put(null, "111");
		
		Hashtable<Object,Object> map = new Hashtable<>();
		map.put(null, "111");
		
//		ConcurrentHashMap<Object,Object> map = new ConcurrentHashMap<>();
//		map.put(null, "111");
		
		
		
	}

}

5. TreeMap

package com.dream.treemap_class;

import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;

public class Test01 {
	
	public static void main(String[] args) {
		/**
		 * 做实验理解 TreeMap 的自然排序
		 * 
		 * 注意：针对于Key排序
		 */
		
		TreeMap<String, Integer> map = new TreeMap<>();
		
		map.put("b", 34);
		map.put("d", 28);
		map.put("a", 33);
		map.put("e", 20);
		map.put("c", 26);
		
		Set<Entry<String,Integer>> entrySet = map.entrySet();
		for (Entry<String, Integer> entry : entrySet) {
			
			String key = entry.getKey();
			Integer value = entry.getValue();
			
			System.out.println(key + " -- " + value);
		}
		
	}

}

package com.dream.treemap_class;

import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;

public class Test02 {
	
	public static void main(String[] args) {
		/**
		 * 使用内置比较器
		 */
		
		TreeMap<Student, String> map = new TreeMap<>();
		
		map.put(new Student("麻生希", '女', 28, "2101", "001"), "123456789");
		map.put(new Student("椎名空", '女', 23, "2101", "002"), "123456789");
		map.put(new Student("北岛玲", '女', 27, "2101", "003"), "123456789");
		map.put(new Student("水野朝阳", '女', 31, "2101", "004"), "123456789");
		map.put(new Student("三上悠亚", '女', 26, "2101", "005"), "123456789");
		map.put(new Student("濑亚美莉", '女', 32, "2101", "006"), "123456789");
		map.put(new Student("爱田奈奈", '女', 36, "2102", "001"), "123456789");
		map.put(new Student("深田咏美", '女', 28, "2102", "002"), "123456789");
		map.put(new Student("小西满里惠", '女', 28, "2102", "003"), "123456789");
		map.put(new Student("桃谷绘里香", '女', 29, "2102", "004"), "123456789");
		map.put(new Student("明日花绮罗", '女', 29, "2102", "005"), "123456789");
		map.put(new Student("铃原爱蜜莉", '女', 29, "2102", "006"), "123456789");
		map.put(new Student("波多野结衣", '女', 34, "2102", "007"), "123456789");
		
		Set<Entry<Student,String>> entrySet = map.entrySet();
		for (Entry<Student, String> entry : entrySet) {
			Student key = entry.getKey();
			String value = entry.getValue();
			System.out.println(key + " -- " + value);
		}
		
	}

}

Student类

package com.dream.treemap_class;

public class Student implements Comparable<Student>{
	
	private String name;
	private int age;
	private char sex;
	private String classId;
	private String id;
	
	public Student() {
	}

	public Student(String name, char sex,int age, String classId, String id) {
		this.name = name;
		this.age = age;
		this.sex = sex;
		this.classId = classId;
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public char getSex() {
		return sex;
	}

	public void setSex(char sex) {
		this.sex = sex;
	}

	public String getClassId() {
		return classId;
	}

	public void setClassId(String classId) {
		this.classId = classId;
	}

	public String getId() {
		return id;
	}

	public void setId(String id) {
		this.id = id;
	}

	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + ", sex=" + sex + ", classId=" + classId + ", id=" + id + "]";
	}
	
	@Override
	public boolean equals(Object obj) {
		if(this == obj){
			return true;
		}
		if(obj instanceof Student){
			Student stu = (Student) obj;
			if(this.classId.equals(stu.classId) && this.id.equals(stu.id)){
				return true;
			}
		}
		return false;
	}

	//排序方法
	//排序规则：年龄排序
	//返回值：负数-比比较对象小 
	//返回值：正数-比比较对象大 
	//返回值：0-和比较对象一致（不存储）
	@Override
	public int compareTo(Student o) {
		return this.age - o.age;
	}

}

测试类

package com.dream.treemap_class;

import java.util.Map.Entry;
import java.util.Comparator;
import java.util.Set;
import java.util.TreeMap;

public class Test03 {
	
	public static void main(String[] args) {
		/**
		 * 使用外置比较器
		 */
		
		//外置比较器
		//比较规则：先判断两个学生是否相同，再按照姓名长度，再按照年龄
		TreeMap<Student, String> map = new TreeMap<>(new Comparator<Student>() {

			@Override
			public int compare(Student o1, Student o2) {
				if(o1.equals(o2)){
					return 0;
				}
				if(o1.getName().length() != o2.getName().length()){
					return o1.getName().length() - o2.getName().length();
				}
				if(o1.getAge() != o2.getAge()){
					return o1.getAge() - o2.getAge();
				}
				return 1;
			}
		});
		
		map.put(new Student("麻生希", '女', 28, "2101", "001"), "123456789");
		map.put(new Student("椎名空", '女', 23, "2101", "002"), "123456789");
		map.put(new Student("北岛玲", '女', 27, "2101", "003"), "123456789");
		map.put(new Student("水野朝阳", '女', 31, "2101", "004"), "123456789");
		map.put(new Student("三上悠亚", '女', 26, "2101", "005"), "123456789");
		map.put(new Student("濑亚美莉", '女', 32, "2101", "006"), "123456789");
		map.put(new Student("爱田奈奈", '女', 36, "2102", "001"), "123456789");
		map.put(new Student("深田咏美", '女', 28, "2102", "002"), "123456789");
		map.put(new Student("小西满里惠", '女', 28, "2102", "003"), "123456789");
		map.put(new Student("桃谷绘里香", '女', 29, "2102", "004"), "123456789");
		map.put(new Student("明日花绮罗", '女', 29, "2102", "005"), "123456789");
		map.put(new Student("铃原爱蜜莉", '女', 29, "2102", "006"), "123456789");
		map.put(new Student("波多野结衣", '女', 34, "2102", "007"), "123456789");
		
		Set<Entry<Student,String>> entrySet = map.entrySet();
		for (Entry<Student, String> entry : entrySet) {
			Student key = entry.getKey();
			String value = entry.getValue();
			System.out.println(key + " -- " + value);
		}
		
	}

}

6. Properties

package com.dream.properties_class;

import java.io.IOException;
import java.util.Properties;

public class Test01 {
	
	public static void main(String[] args) throws IOException {
		/**
		 * 操作Properties
		 */
		
		//创建配置文件对象
		Properties p = new Properties();
		//把文件加载到对象中
		p.load(Test01.class.getClassLoader().getResourceAsStream("DBConfig.properties"));
		//获取配置文件中的数据
		String username = p.getProperty("username");
		String password = p.getProperty("password");
		
		System.out.println(username + " -- " + password);
	}

}

DBConfig.properties

username=hhy
password=123123

7. Collections工具类

package com.dream.collections_class;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class Test01 {
	
	public static void main(String[] args) {
		
		/**
		 * 使用集合工具类操作集合
		 */
		
		ArrayList<Integer> list = new ArrayList<>();
		
		//批量添加
		Collections.addAll(list, 4,6,2,1,5,3);
		
		//排序
		Collections.sort(list);
	
//		Collections.sort(list, new Comparator<Integer>() {
//			@Override
//			public int compare(Integer o1, Integer o2) {
//				// TODO Auto-generated method stub
//				return o2-o1;
//			}
//		});
		
		System.out.println("查询元素在集合中的下标：" + Collections.binarySearch(list, 3));
		
		//拷贝
		ArrayList<Integer> newList = new ArrayList<>();
		newList.add(0);
		newList.add(0);
		newList.add(0);
		newList.add(0);
		newList.add(0);
		newList.add(0);
		Collections.copy(newList, list);
		
		System.out.println("获取最大值：" + Collections.max(newList));
		System.out.println("获取最小值：" + Collections.min(newList));
		
		System.out.println(newList);
		
	}

}

8. EnumSet工具类

Signal接口

package com.dream.enum_util_class;

public enum Signal {
	RED, YELLOW, GREEN;
}

测试类

package com.dream.enum_util_class;

import java.util.EnumSet;

public class Test01 {

	public static void main(String[] args) {
		
		/**
		 * 
		 * EnumSet工具类
		 * 
		 * 将枚举类中对象放入Set集合中
		 */
		
		EnumSet<Signal> set = EnumSet.allOf(Signal.class);
		for (Signal signal : set) {
			System.out.println(signal);
		}
		
	}
}

测试类

package com.dream.enum_util_class;

import java.util.EnumMap;
import java.util.Map.Entry;
import java.util.Set;

public class Test02 {

	public static void main(String[] args) {
		
		/**
		 * 
		 * EnumMap工具类
		 * 
		 * 将枚举类中对象放入Map集合中
		 */
		
		EnumMap<Signal, String> map = new EnumMap<>(Signal.class);
		map.put(Signal.RED, "红灯");
		map.put(Signal.YELLOW, "黄灯");
		map.put(Signal.GREEN, "绿灯");
		
		Set<Entry<Signal,String>> entrySet = map.entrySet();
		for (Entry<Signal, String> entry : entrySet) {
			Signal key = entry.getKey();
			String value = entry.getValue();
			System.out.println(key + " -- " + value);
		}
		
	}
}