一、Map实现类的结构
Map:双列数据，存储具有key-value对的数据
1、HashMap:作为Map的主要实现类，线程不安全的，效率高，存储null的key和value
2、LinkedHashMap:保证在遍历map元素时，可以按照添加的顺序实现遍历
原因：在原因的HashMap底层上结构基础上，添加了一对指针，指向前一个元素和后一个元素，对于频繁的遍历操作，此类执行的效率高于HashMap
3、TreeMap:保证添加的key-value对进行排序，实现排序遍历。按照key的自然排序或者定制排序，底层使用红黑树，特点：有序，查询效率高
4、Hashtable:在jdk1.0时代就存在了，线程安全，效率低，不能存储null的key和value
5、Properties:Hashtable的子类，常用来处理配置文件。key 和 value 都是String类型
HashMap的底层：数组+链表(jdk7) // 数组+链表+红黑树(jdk8)
二、 Map结构的理解(HashMap)
1、Map中的key：无序的，不可重复的，使用set存储所有的key -->key所在的类要重写equals()和hashCode()
2、Map中的value：无序的，可重复的，使用collection存储所有的value ----------->value所在类要重写equals()
3、一个键值对：key-value构成了一个entry对象(Map中的entry：无序的，不可重复的，使用set存储所有的entry)
三、HashMap的底层实现原理？以jdk7为例说明：
HashMap map = new HashMap();
在实例化以后，底层创建了长度为16的一维数组Entry[] table
…以执行多次put方法…
map.put(key,value);
首先，调用key所在类的hashCode()计算key的哈希值，此哈希值经过某种算法以后，得到Entry数组中的存放位置。
如果此位置上的数据为空，此时key-value添加成功。–成功1
如果此位置上的数据不为空(此位置上存在一个或多个数据，并且以链表形式存在),比较key和已经存在的一个或多个数据的哈希值：
如果key的哈希值与已经存在的数据的哈希值都不相同，此时key-value添加成功 --成功2
如果key的哈希值与已经存在的某一个数据(key1-value1)的哈希值相同，继续比较：调用key所在类的equals(key1)方法
进行比较：
如果返回false：此时key-value添加成功 --成功3
如果返回true:使用value替换相同key1的value1值
2和3：此时key-value和原来的数据以链表的形式存储。
在不断的添加过程中，会涉及到扩容的问题，当超出临界值时，且当前位置非空，默认的扩容方式，扩容为原来的2倍，并将原有的数据复制过来。
jdk8和jdk7底层实现方面的不同：
1.new HashMap():底层没有创建一个长度为16的数组。
2.jdk8底层的数组时Node[],不再是Entry[]( Node<K,V>[] table;)
3.首次调用put的方法时，底层才创建长度为16的数组
public V put(K key, V value) {
//调用hash，创建数组
return putVal(hash(key), key, value, false, true);
}
4.jdk7的底层结构是：数组+链表 jdk8中的底层结构：数组+链表+红黑树
4.1、形成链表时，七上八下(jdk7：新的元素指向旧的元素 jdk8：旧的元素指向新的元素)
4.2、当数组的某一个索引位置上的元素以链表形式存在的个数 > 8 且当前数组长度 > 64时，
此时索引位置上的所有数据改为使用红黑树存储。(效率高，二叉树可折半查找)
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
static final int TREEIFY_THRESHOLD = 8
//底层源码显示为当它小于64时扩容，大于64时以红黑树进行存储
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
resize();
static final int MIN_TREEIFY_CAPACITY = 64
4.3HashMap底层中源码主要的常量：
DEFAULT_INITIAL_CAPACITY:HashMap的默认容量：16
DEFAULT_LOAD_FACTOR：HashMap的默认加载因子：0.75
threshold:扩容的临界值 = 容量填充因子：160.75 =>12
TREETFY_THRESHOLD:Bucket中的链表长度大于改默认值，转化为红黑树：8
MIN_TREEIFY_CAPACITY:桶中的Node被树化时最小的hash表容量：64
四、LinkedHashMap的底层实现原理(HashMap的子类)
LinkedHashMap底层使用的结构和HashMap相同，因为LinkedHashMap继承于HashMap， 区别在于：LinkedHashMap内部提供了Entry对象，替换了HashMap中的Node
源码：
static class Entry<K,V> extends HashMap.Node<K,V> {
Entry<K,V> before, after;//可以记录添加元素的先后顺序
Entry(int hash, K key, V value, Node<K,V> next) {
super(hash, key, value, next);
}
}
五、Map中定义的方法：
添加、删除、修改操作
Object put(Object key,Object value):将指定的key-value添加到(或修改)当前map对象中
void putAll(Map m):将m中的所有key-value对存放到当前的map中
Object remove(Object key):移除指定的key-value对，并返回value
void clear():清空当前map中的所有数据
元素查询的操作：
Object get(Object key):获取指定key对应的value
boolean containsKey(Object key):是否包含指定的key
boolean containsValue(Object value):是否包含指定的value
int size():返回map中key-value对的个数
boolean isEmpty():判断当前map中是否为空
boolean equals(Object obj):判断当前map和参数对象obj是否相等
元视图操作的方法
Set keySet():返回所有的key构成的Set集合
Collection values():返回所有value构成的Collection集合
Set entrySet():返回所有的key-value对构成的Set集合
public class MapTest {
//LinkedHashMap：有序,不可重复
@Test
public void test1(){
Map map = new LinkedHashMap();
map.put(123,"AA");
map.put(123,"AA");
map.put(456,"BB");
map.put(789,"CC");
map.put(147,"DD");
System.out.println(map);
}
@Test
public void test(){
Map map = new HashMap();
// map = new Hashtable();//java.lang.NullPointerException,不能存储null的key和value
map.put(null,null);
}
//map方法--- 添加、删除、修改操作
@Test
public void test2(){
Map map = new HashMap();
//添加
map.put("AA",123);
map.put(25,123);
map.put("AA","BB");//修改覆盖
map.put(123,"BB");
System.out.println(map);//{AA=BB, 25=123, 123=BB}
Map map1 = new HashMap();
map1.put("CC",123);
map1.put("DD",123);
map.putAll(map1);//{AA=BB, CC=123, DD=123, 25=123, 123=BB}
System.out.println(map);
//删除
Object value = map.remove("CC");
System.out.println(value);//123
System.out.println(map);//{AA=BB, DD=123, 25=123, 123=BB}
//clear()
map.clear();//map = {}
System.out.println(map.size());//0
}
//元素查询的操作
@Test
public void test3(){
Map map = new HashMap();
//添加
map.put("AA",123);
map.put(25,123);
map.put("AA","BB");//修改覆盖
map.put(123,"BB");
System.out.println(map.get(25));//1233,不存在为null
boolean isExist = map.containsKey("BB");
System.out.println(isExist);//false
boolean isFlag = map.containsValue(123);
System.out.println(isFlag);//true
map.clear();
Map ma1 = new HashMap();
//添加
ma1.put("AA",123);
ma1.put(25,123);
ma1.put("AA","BB");//修改覆盖
ma1.put(123,"BB");
Map ma2 = new HashMap();
//添加
ma2.put("AA",123);
ma2.put(25,123);
ma2.put("AA","BB");//修改覆盖
ma2.put(123,"BB");
System.out.println(map.isEmpty());//true
System.out.println(ma1.equals(ma2));//true
}
@Test
public void test5(){
// 元视图操作的方法
Map map = new HashMap();
//添加
map.put("AA",123);
map.put(25,123);
map.put("AA","BB");//修改覆盖
map.put(123,"BB");
//遍历所有的key集合，keySet()
Set set = map.keySet();
Iterator iterator = set.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
//遍历所有的value集合：values
Collection values = map.values();
for (Object obj :values){
System.out.println(obj);
}
//遍历所有的key-value
//方式一、entrySet()
Set entrySet = map.entrySet();
Iterator iterator1 = entrySet.iterator();
while (iterator1.hasNext()){
Object obj = iterator1.next();
//entrySet集合中的元素都是entry
Map.Entry entry = (Map.Entry) obj;
System.out.println(entry.getKey() +"-------------->"+entry.getValue());
}
//方式二、
Set keySet = map.keySet();
Iterator iterator2 =keySet.iterator();
while (iterator2.hasNext()){
Object key = iterator2.next();
//entrySet集合中的元素都是entry
Object value = map.get(key);
System.out.println(key +"-------------->"+ value);
}
}
六、 TreeMap的使用
向TreeMap中添加key-value，要求key必须是同一类创建的对象，因为要按照key进行排序：自然排序、定制排序
首先，自定义一个Person类，用于数据测试
public class Person implements Comparable {
public String name;
public int age;
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;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
//重写equals()方法,比较判断contains()中的比较问题
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
if (age != person.age) return false;
return name != null ? name.equals(person.name) : person.name == null;
}
@Override
public int hashCode() {
int result = name != null ? name.hashCode() : 0;
result = 31 * result + age;
return result;
}
//按照姓名从小到大排列,年龄从小到大排序
@Override
public int compareTo(Object o) {
if (o instanceof Person){
Person person = (Person)o;
// return this.name.compareTo(person.name);
int compare = this.name.compareTo(person.name);
if (compare !=0){
return compare;
}else {
return Integer.compare(this.age,person.age);
}
}else {
throw new RuntimeException("输入的类型不匹配！");
}
}
}
自然排序
@Test
public void test(){
TreeMap map = new TreeMap();
Person p1 = new Person("Tom",12);
Person p2 = new Person("Jerry",45);
Person p3 = new Person("Jack",32);
Person p4 = new Person("Rose",18);
Person p5 = new Person("Tm",12);
map.put(p1,88);
map.put(p2,88);
map.put(p3,88);
map.put(p4,88);
map.put(p5,88);
Set entrySet = map.entrySet();
Iterator iterator1 = entrySet.iterator();
while (iterator1.hasNext()){
Object obj = iterator1.next();
//entrySet集合中的元素都是entry
Map.Entry entry = (Map.Entry) obj;
System.out.println(entry.getKey() +"-------------->"+entry.getValue());
}
}
定制排序
@Test
public void test2(){
TreeMap map = new TreeMap(new Comparator() {
@Override
public int compare(Object o1, Object o2) {
if (o1 instanceof Person && o2 instanceof Person){
Person p1 = (Person)o1;
Person p2 = (Person)o2;
return Integer.compare(p1.getAge(),p2.getAge());
}
throw new RuntimeException("输入的类型不一致！");
}
});
Person p1 = new Person("Tom",12);
Person p2 = new Person("Jerry",45);
Person p3 = new Person("Jack",32);
Person p4 = new Person("Rose",18);
Person p5 = new Person("Tm",12);
map.put(p1,88);
map.put(p2,88);
map.put(p3,88);
map.put(p4,88);
map.put(p5,88);
Set entrySet = map.entrySet();
Iterator iterator1 = entrySet.iterator();
while (iterator1.hasNext()){
Object obj = iterator1.next();
//entrySet集合中的元素都是entry
Map.Entry entry = (Map.Entry) obj;
System.out.println(entry.getKey() +"-------------->"+entry.getValue());
}
}
七、 Properties:Hashtable的子类，常用来处理配置文件。key 和 value 都是String类型
public static void main(String[] args) throws Exception{
Properties prop = new Properties();
FileInputStream stream = new FileInputStream("jdbc.properties");
prop.load(stream);//加载流对应的文件
String name = prop.getProperty("name");
String pwd = prop.getProperty("pwd");
System.out.println("name = "+ name + ",pwd = " + pwd);
stream.close();
}
面试题：
1.HashMap的底层实现原理
2.HashMap和Hashtable的异同？
