Map

学习体系图

Map接口特点

比Set接口常用

第四点有一个特殊情况，可能key不相同也加入不了，看下面解释和源码即可

1.不同于单列集合只传一个对象，双列集合都是传两个对象
2.Node类是HashMap的内部类符号表示HashMap$Node
next把所有的Node元素连接
然后对应数组索引可以调用
到对应索引的第一个Node元素
拿到第一个Node元素相当于后面都有了
Node源码

static class Node<K,V> implements Map.Entry<K,V> {//Entry是一个接口
        final int hash;
        final K key;
        V value;
        Node<K,V> next;

        Node(int hash, K key, V value, Node<K,V> next) {
            this.hash = hash;
            this.key = key;
            this.value = value;
            this.next = next;
        }

        public final K getKey()        { return key; }
        public final V getValue()      { return value; }
        public final String toString() { return key + "=" + value; }

        public final int hashCode() {
            return Objects.hashCode(key) ^ Objects.hashCode(value);
        }

        public final V setValue(V newValue) {
            V oldValue = value;
            value = newValue;
            return oldValue;
        }

        public final boolean equals(Object o) {
            if (o == this)
                return true;
            if (o instanceof Map.Entry) {
                Map.Entry<?,?> e = (Map.Entry<?,?>)o;
                if (Objects.equals(key, e.getKey()) &&
                    Objects.equals(value, e.getValue()))
                    return true;
            }
            return false;
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

3和4.key不能重复，value可以重复，可以重复的话会替换原来key的value
注意可能key不同也不能加入
如果你传入的比较器返回值为0就不能加入进去

5.
6.也可以用其他类的对象做key，因为形参是Object key

7.通过
Map接口的get(Object key)方法可以通过key对象来找value元素，以为key不能重复所以是一一对应的哦
如图

8.这里理解key和value存在Node对象里面
为了方便遍历，会创建一个EntrySet集合，该集合存放的元素类型Entry
一个Entry包含key和value
然后把Node对象封装成Entry对象，然后放到EntrySet集合
方便遍历
然后把所有的key对象封装到一个Set集合里面，用keySet方法调用
把所有的value对象封装到Collection集合里，用values方法调用

Set set = hashMap.keySet();
        Collection values = hashMap.values();
1
2

如图

Map接口方法

1.put(Object Key,Object value)
存放元素

2.remove(Object key)
删除对应key的value

3.get(Object key)
返回key对应的value对象，不过编译类型是Object对象

4.Map对象.size()
返回元素个数，一对key-value算一个

5.Map对象.isEmpty()
如果个数为0返回true
如果个数不为0发布会false

6.Map对象.clear()
删除对象的所有元素

7.Map对象.containsKey(Obejct key)
有对应的key返回true
没有的话返回false

8.keySet
返回对于的key
9.values
返回对应的value
10.entrySet
返回所有的Node

Map接口遍历方式

遍历这个

HashMap hashMap = new HashMap();
        hashMap.put("no3","张无忌");
        hashMap.put(null,"魏无牙");
        hashMap.put("no1","牛");
        hashMap.put("no2","小袁");
1
2
3
4
5

1.增强for和keySet

 Set set = hashMap.keySet();
        for (Object a:set
             ) {
            System.out.println(a+"="+hashMap.get(a));

        }
1
2
3
4
5
6

2.keySet和迭代器

 Set set = hashMap.keySet();
        Iterator iterator = set.iterator();
        while (iterator.hasNext()){
            Object next = iterator.next();
            System.out.println(next+"="+hashMap.get(next));
        }

1
2
3
4
5
6
7

如果你只在乎里面的value可以看下面的方法
3.values方法和增强for

 Collection values = hashMap.values();
        for (Object a:values
             ) {
            System.out.println(a);

        }
1
2
3
4
5
6

4.values方法和迭代器

 Collection values = hashMap.values();
        Iterator iterator = values.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
1
2
3
4
5

5.通过entrySet和增强for

Set set = hashMap.entrySet();
        for (Object a:set
             ) {
            Map.Entry m=(Map.Entry)a;
            //这里向下转型可以调用Map类独有的方法
            //Map.Entry因为entry是Map的内部类
            System.out.println(m);
        }
1
2
3
4
5
6
7
8

6.通过entrySet和迭代器

 Set set = hashMap.entrySet();
        Iterator iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
1
2
3
4
5

HashMap

HashMap类特点

HashSet有具体的HashMap的特点

1.不能有重复元素（指的key对象），value可以一样
2.是一种链表数组形式
3.根据key对象的hash值来确定对象所在的数组索引，添加到链表中-无序
4.线程不安全

在Hash中没有讲到的特点
1.Collection接口是单列集合，只传入一个对象，另一个对象的话，系统生成了PRESENT来补充，本质上也是双列集合，但是另一个对象由系统进行补充并且所有单列集合的那个Valu对象（PRESENT）都一样

2.在双列集合中是put(Object key,Object value)

源码
 public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }
1
2
3
4

传入两个对象
而且但集合中的key对象是同一个的话
后来的value会替换掉之前的value对象
如图
之所以单列集合（HashSet）没有变化，是因为PRESENT是同一个对象
并且不会输出，其实它内部也是有替换的。

HashSet的add源码
 public boolean add(E e) {
        return map.put(e, PRESENT)==null;
    }
PRESENT属性
private static final Object PRESENT = new Object();
1
2
3
4
5
6

HashMap底层机制

和HashSet其实一样，就是有些细节在HasaSet讲的不是特别清楚
用一个图了说明

HashMap源码分析

同HashSet源码分析
可以看我的
Java之单列集合的HashSet源码分析

主要是hash值和equals的判断，来保证key值的不重复

hashCode和equals
1、hashCode的存在主要是用于查找的快捷性，如Hashtable，HashMap等，hashCode是用来在散列存储结构中确定对象的存储地址的；

2、如果两个对象相同，就是适用于equals(java.lang.Object) 方法，那么这两个对象的hashCode一定要相同；

3、如果对象的equals方法被重写，那么对象的hashCode也尽量重写，并且产生hashCode使用的对象，一定要和equals方法中使用的一致，否则就会违反上面提到的第2点；

4、两个对象的hashCode相同，并不一定表示两个对象就相同，也就是不一定适用于equals(java.lang.Object) 方法，只能够说明这两个对象在散列存储结构中，如Hashtable，他们“存放在同一个篮子里”
1
2
3
4
5
6
7
8

简洁来说就是你重写equals一般也要重写hashCode
equals返回true，hashCode一定相同

hashCode相同，equals不一定相同
再归纳一下就是hashCode是用于查找使用的，而equals是用于比较两个对象的是否相等的。

关于树化扩容的机制
你可以去前面的HashSet的扩容数化（一样的）
提一嘴啊
那种一个链表很多个元素导致数组扩容然后树化的
可能性很小，不可能那么多元素的hash值都一样凑一堆了是吧，除非我们故意为之
不过还是有可能的

HashTable

基本介绍

注意2和HashMap不一样其他基本相同

扩容机制

初始数组有11个

第三行
newCapacity是 双倍+1
就是11*2+1=23
放到达临界值时

threshold = (int)Math.min(newCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
1

这个就是临界值loadFactor=0.75

与HashMap区别

Properties

基本介绍

主要应用在IO流
等我学到来更新

一些案例

和HashMap相同的地方

和HashMap不同的地方

集合选择规则