java Map接口

zjh0101

已于 2022-09-02 15:04:12 修改

阅读量467

点赞数 1

分类专栏： Java 文章标签： java servlet 哈希算法

于 2022-09-01 21:43:27 首次发布

本文链接：https://blog.csdn.net/zjh0101/article/details/126651981

版权

Java 专栏收录该内容

94 篇文章 0 订阅

订阅专栏

哈希表就是一种以键-值(key-indexed) 存储数据的结构，只要输入待查找的值即key，即可查找到其对应的值。
     哈希的思路很简单，如果所有的键hashCode都是整数，那么就可以使用一个简单的无序数组来实现：将键作为索引，值即为其对应的值，这样就可以快速访问任意键的值。
     它提供了一组键值的映射。其中存储的每个数据对象都有一个相应的键key，键决定了值对象在Map中的存储位置。键应该是唯一的，不允许重复，每个key只能映射一个value。

Map接口的定义
  public interface Map<K, V>
表示存储数据时有2个部分key和value，key不允许重复

int size();

获取key-value个数

boolean containsKey(Object key);

判断集合中是否包含指定的key值

要求key类型需要实现equals和hashCode发方法
首先调用hashCode方法获取key对应的hash值，然后当key值和map中的key值相同时才会继续调用equals进行等值判断，否则是false

boolean containsValue(Object value);

判断集合中是否包含指定的value值

要求value类型需要实现equals，对于hashCode没有要求；进行判断时是直接
调用equals方法

V get(Object key);

根据key值获取对应的value值如果key不存在，则返回为null；即使key值不存在也不会抛异常
获取数据返回为null有2种情形：没有对应的key，存储key对应的值为null

V put(K key, V value);

向map集合中添加key-value对，返回原始存储的value值如果key值已经存在则后盖前，同时返回被覆盖的数据
要求针对key类型必须实现equals和hashCode两个方法

  Java的潜规则：要求当两个对象的equals为true时，hashCode值必须相等

   @Override
       public int hashCode() {
           return Objects.hash(id, name);
       }
       @Override
       public boolean equals(Object obj) {
           if (this == obj)
               return true;
           if (obj == null)
               return false;
           if (getClass() != obj.getClass())
               return false;
           A3 other = (A3) obj;
           return Objects.equals(id, other.id) && Objects.equals(name, other.name);
       }

   V remove(Object key);

根据key值删除对应的key-value对，返回对应的value值
   如果key值不存在，不会抛出异常，只是返回值为null；如果key值存在则返回对应的value
   获取数据返回为null有2种情形：没有对应的key，存储key对应的值为null

   void clear();

清空集合中的所有元素key-value对

   遍历map集合有三种方式，map提供了三种不同的视图
   1、Iterator 2、.forEach(lambda) 3、for-each结构 for(Object tmp: map.keySet)

   Set<K> keySet();获取所有的key所组成的Set集合

   Collection<V> values();获取所有的value所组成的Collection集合

   Set<Map.Entry<K, V>> entrySet();获取所有的key-value对所构成的Set集合

   在Map中一个key-value被封装成一个Entry的对象

   interface Entry<K, V> {
K getKey(); 当前entry对象中存储的key值
V getValue(); 当前entry对象中存储的value值
V setValue(V value); 修改entry对象中所存储的value值

public static <K extends Comparable<? super K>, V> Comparator<Map.Entry<K, V>> comparingByKey() {
return (Comparator<Map.Entry<K, V>> & Serializable)
(c1, c2) -> c1.getKey().compareTo(c2.getKey());
}

public static <K, V extends Comparable<? super V>> Comparator<Map.Entry<K, V>> comparingByValue() {
return (Comparator<Map.Entry<K, V>> & Serializable)
(c1, c2) -> c1.getValue().compareTo(c2.getValue());
}

public static <K, V> Comparator<Map.Entry<K, V>> comparingByKey(Comparator<? super K> cmp) {
Objects.requireNonNull(cmp);
return (Comparator<Map.Entry<K, V>> & Serializable)
(c1, c2) -> cmp.compare(c1.getKey(), c2.getKey());
}

public static <K, V> Comparator<Map.Entry<K, V>> comparingByValue(Comparator<? super V> cmp) {
Objects.requireNonNull(cmp);
return (Comparator<Map.Entry<K, V>> & Serializable)
(c1, c2) -> cmp.compare(c1.getValue(), c2.getValue());
}
}

新增方法:
按照key值获取key所对应的value值，如果key值不存在则返回defaultValue；
如果key存在，即使值为null，也是返回value值，不是defaultValue
default V getOrDefault(Object key, V defaultValue) {
V v;
return (((v = get(key)) != null) || containsKey(key))
? v
: defaultValue;
}

遍历当前Map集合中的所有元素
default void forEach(BiConsumer<? super K, ? super V> action) {
Objects.requireNonNull(action); //判断非action非空，如果action为null则抛出异常
for (Map.Entry<K, V> entry : entrySet()) { for-each结构
K k;
V v;
try {
k = entry.getKey();
v = entry.getValue();
} catch (IllegalStateException ise) {
throw new ConcurrentModificationException(ise);
}
action.accept(k, v);
}
}

对应的lambda表达式接口定义为
@FunctionalInterface
public interface BiConsumer<T, U> {
void accept(T t, U u);
}
可以使用lambda表达式修改Map中所有的value值

default void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {

Objects.requireNonNull(function); 要求function参数非空，否则异常

for (Map.Entry<K, V> entry : entrySet()) {for-each结构用于遍历所有的key-value对

K k;

V v;

try {

k = entry.getKey(); 获取当前entry对象中的key值

v = entry.getValue(); 获取当前entry对象中的value值

} catch (IllegalStateException ise) {

throw new ConcurrentModificationException(ise);

}

v = function.apply(k, v);调用BiFunction中的方法对key和value进行处理，并返回一个V类型的数据

try {

entry.setValue(v);将计算得到的新数据注入到entry对象中，实现数据的修改

} catch (IllegalStateException ise) {

throw new ConcurrentModificationException(ise);

}

@FunctionalInterfacepublic interface BiFunction<T, U, R> {

R apply(T t, U u); 针对传入的t和u进行处理，可以返回一个新的类型数据

}

按照key值修改原始数据，如果key对应的值为空，则修改数据为value，否则返回旧有数据，不修改

default V putIfAbsent(K key, V value) {

V v = get(key); //首先按照key获取对应的value值

if (v == null) { 如果获取的value为空，则修改key对应的值为参数value

v = put(key, value);

}

return v; 返回v值，如果v非空则返回原始数据，如果v为空则返回value

}

按照key和value值执行删除操作

default boolean remove(Object key, Object value) {

Object curValue = get(key); 获取key对应的原始数据

//如果原始存储的数据和value参数不相等或者不存在对应的key并且key对应存储的原始数据为null，则不执行任何操作

if (!Objects.equals(curValue, value) ||

(curValue == null && !containsKey(key))) {

return false;

}

remove(key); 删除key对应的数据

return true;

}

按照指定的key和oldValue值执行替换操作，将key对应的值修改为newValuedefault boolean replace(K key, V oldValue, V newValue) {

Object curValue = get(key); 按照key获取对应的当前存储的value值

//如果当前存储的值和oldValue参数值不相等或者当前值为null并且不包含当前的key，则直接返回

if (!Objects.equals(curValue, oldValue) ||

(curValue == null && !containsKey(key))) {

return false;

}

put(key, newValue); 修改key所对应的value为newValue

return true;

}

按照指定的key进行修改，要求key对应的value非空或者包含对应的key

default V replace(K key, V value) {

V curValue;

if (((curValue = get(key)) != null) || containsKey(key)) {

curValue = put(key, value);

}

return curValue;

}

    ## 哈希表

   Hash一般翻译为散列，也有直接音译为哈希的，这就是把任意长度的输入通过散列算法，变换成固定长度的输出，该输出就是散列值（哈希值）；这种转换是一种压缩映射，散列值的空间通常远小于输入的空间，不同的输入可能会散列成相同的输出，所以不可能从散列值来唯一的确定输入值
     简单的说就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数。

消息摘要算法的使用 md5、SHA-1等
MessageDigest md = MessageDigest.getInstance("md5");
String source="柏嘉safsadfsadflsajdflsakdvklxjcvlkjdsl";
String ss=Base64.getEncoder().encodeToString(sbyte);
System.out.println(ss);

  所有散列函数都有如下一个基本特性：根据同一散列函数计算出的散列值如果不同，那么输入值肯定也不同。但是，根据同一散列函数计算出的散列值如果相同，输入值不一定相同。

### 哈希冲突

  当两个不同的输入值，根据同一散列函数计算出相同的散列值的现象，就把它叫做碰撞（哈希碰撞）。哈希碰撞的解决方案为开放地址法和链地址法。

  以key/value的方式存储数据，采用拉链法综合了数组和链表结构。如果key已知则存取效率较高，但是删除慢，如果不知道key存取则慢，对存储空间使用不充分。最典型的实现是HashMap。

  JDK8+对桶内数据处理从链表转换为红黑树，则查询效率从O(N)提高到O(logN)。当链表中的个数超过8个时会转换为红黑树

## Map实现类
HashMap、TreeMap、LinkedHashMap、Hashtable等

## HashMap

类定义
public class HashMap<K,V> extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable

注意：Map接口的定义
       public interface Map<K, V> 没有父接口

具体的内部数据存储方式
transient Node<K,V>[] table; //哈希表的本质是一个数组，数组中每一个元素称为一个桶，桶中存放的是键值对

transient Set<Map.Entry<K,V>> entrySet;并不是用于实际存储数据，主要用于针对entrySet和keySet两个视图提供支持

transient int size;当前集合中的元素个数

final float loadFactor; 当前集合的负载因子，当前Map集合中扩容的阈值【负载因子最大容积】

transient int modCount;修改次数，主要用于实现多线程操作时的快死异常

重要的阈值
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16 默认的初始化容积
static final int MAXIMUM_CAPACITY = 1 << 30;最大容积值，实际上就是2的30次方
static final float DEFAULT_LOAD_FACTOR = 0.75f; 默认的负载因子/加载因子

static final int TREEIFY_THRESHOLD = 8;//树化阈值：即链表转成红黑树的阈值，在存储数据时，当链表长度 > 该值时，则将链表转换成红黑树
static final int MIN_TREEIFY_CAPACITY = 64;//最小树形化容量阈值：即当哈希表中的容量 > 该值时，才允许树形化链表（即将链表转换成红黑树）否则，若桶内元素太多时，则直接扩容，而不是树形化
static final int UNTREEIFY_THRESHOLD = 6;//桶的链表还原阈值：即红黑树转为链表的阈值，当在扩容resiz）时（此时HashMap的数据存储位置会重新计算），在重新计算存储位置后，当原有的红黑树内数量 < 6时，则将红黑树转换成链表

内部存储的实现
  静态内部类用于实现Entry，HahMap中存放的key/value对就被封装为Node对象。其中key就是存放的键值，用于决定具体的存放位置；value是具体存放的数据，hash就是当前Node对象的hash值，next用于指向下一个Node节点(单向链表)
static class Node<K,V> implements Map.Entry<K,V> {
final int hash; 当前节点的hash值
final K key; 该节点存储的key值
V value; 该节点存储的value值
Node<K,V> next; 下一个节点对象 --- 默认使用单向链表结构，当一个链表上的节点数>8并且总存储元素个数>64时自动转换为红黑树

构造器
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; //给属性loadFactor负载因子赋默认值0.75
//并没有对数组进行初始化操作。采用延迟初始化的策略可以节约空间
}

//当指定初始化容积时，调用另外的构造器进行HashMap的初始化，采用默认的负载因子0.75
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}

//2个参数的构造器，参数1初始化容积大小，参数2负载因子
public HashMap(int initialCapacity, float loadFactor) {
   //对初始化容积值进行合法性验证，如果<0则抛出异常
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity);
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;

if (loadFactor <= 0 || Float.isNaN(loadFactor)) 负载因子应该在(0,1]之间的浮点数
   //负载因子越小，哈希碰撞的概率越低，也就意味着链表长度越小，但是浪费空间；如果值越大，则
   节约空间，但是哈希碰撞概论提高，所以一般建议值在(0,1]之间
throw new IllegalArgumentException("Illegal load factor: " + loadFactor);

this.loadFactor = loadFactor; //接收合法的负载因子值
this.threshold = tableSizeFor(initialCapacity); 并不是直接使用传入的参数作为初始化数组的长度，而是将
传入的整数转换大于等于initialCapacity的最小2的n次方值
   例如initialCapacity=5，则真正的初始化容积为8
   initialCapacity=10，则真正的初始化容积为16

}

Float.isNaN判断参数是否为一个不是数值 NaN含义为Not a number
public static boolean isNaN(float v) {
return (v != v);
}

//根据传入的初始化容积值求一个合法的初始化容积值
static final int tableSizeFor(int cap) {
int n = -1 >>> Integer.numberOfLeadingZeros(cap - 1);
return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}

HashMap()采用所有的默认配置值，其中的参数值有initialCapacity:int初始化容积，默认值DEFAULT_INITIAL_CAPACITY=16，第2个参数是loadFactor:float用于设置加载因子，取值范围为0-1之间，默认值为DEFAULT_LOAD_FACTOR=0.75，值越大则存储数据越多，hash冲突的概率越高；值越小则越浪费空间，但是hash冲突的概率越低。为了减少hash冲突，引入了加载因子，加载因子表示容器中最多存储百分子多少的数据。例如默认容器为16，默认加载因子为0.75，则表示最多存储160.75个元素，如果大于这个值则需要进行扩容

tableSizeFor用于计算容积值，不是设置多少就是多少。就是计算一个2n值>=设定的容积值.例如初始化容积参数值为7则实际创建容积值为8

注意：在构造器中并没有创建任何用于存储数据的集合---延迟加载，第一次存储数据时才进行空间分配

为什么初始化容积值需要转换位2的n次方?
      求余的实现方法：
      2%8=2 2 & (8-1) 0010 & 0111 = 0010
      9%8=1 9 & (8-1) 1001 & 0111 = 0001
      15%8=7 15 & (8-1) 1111 & 0111=0111


   每个Node[]数组中的元素被称一个桶bucket，一个桶对应一个hash映射的值，例如0，1等，可能会出现不同的key，但是hash映射的位置相同,例如16、32等，这采用链表结构存储hash映射值相同的所有数据(JDK8+在单个链表长度大于阈值8时自动转换为红黑树,删除节点使某单个链表节点数小于阈值6时会自动从红黑树退化为链表结构)

   相关参数:
   - capacity：当前数组容量，始终保持 2^n，可以扩容，扩容后数组大小为当前的2倍。
   - loadFactor：负载因子，默认为 0.75。
   - threshold：扩容的阈值，等于 capacity loadFactor
   JDK1.8以前版本的实现HashMap底层采用的是Entry数组和链表实现。JDK1.8和以后的版本是采用Node数组
   （Entry）+ 单向链表 + 红黑树实现
   Map主要用于存储键key值value对，根据键得到值，因此键不允许重复，但允许值重复。
   HashMap是一个最常用的Map，它根据键的HashCode值存储数据，根据键可以直接获取它的值，具有很快的访问速度。
   HashMap最多只允许一条记录的键为null；允许多条记录的值为null
   HashMap不支持线程的同步，即任一时刻可以有多个线程同时写HashMap；可能会导致数据的不一致，在JDK1.7中会出现环形链，虽然JDK1.8不会出现环形链，但是还会有rehash操作出现死循环、脏读问题、size值不准确等问题。
   如果需要同步，可以用Collections的synchronizedMap方法使HashMap具有同步的能力。

   如何判断环型链？
     创建一个Set，然后遍历整个集合，将每个元素的key值存入set，如果要存的key值已经存储在set中，则出现环型链

   Java7中使用Entry来代表每个HashMap中的数据节点，Java8中使用Node，基本没有区别，都是key，value，hash和next这四个属性，不过，Node只能用于链表的情况，红黑树的情况需要使用TreeNode。

   TREEIFY_THRESHOLD为 8如果新插入的值是链表中的第 9 个会触发下面的 treeifyBin(树化操作，就是将单向链转为红黑树)，也就是将链表转换为红黑树。

   JDK8+插入数据到链表的最后面，Java7是插入到链表的最前面

   HashMap的put方法的具体流程

   public V put(K key, V value) { 以key存储value值，返回原始位置上的value值先执行hash(key)根据key获取一个hash值, 参数2是要存储的key值，参数3是要存储的value，参数4表示如果当前位置已存在一个值，是否替换，false是替换，true是不替换。参数5是否在创建模式，如果为false，则表是在创建模式
return putVal(hash(key), key, value, false, true);
}

hash方法：将高位数据移位到低位进行异或计算，这是因为有些数据计算出的哈希值差异在于高位，而HashMap里的哈希寻址是忽略容量以上的高位的，可以有效地避免类似情况下的哈希碰撞
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
Node<K,V>[] tab;
Node<K,V> p;
int n, i;
1.如果table为空或者长度为0，即没有元素，那么使用resize()方法扩容。resize方法兼顾两个职责，创建初始化数组[因为数组采用的是延迟处理]或者在容量不满足需求时进行扩容处理。插入数据if (++size > threshold)resize();进行条件扩容
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;

2.计算插入存储的数组索引i，具体的索引下标值为插入数据的key算出来的hash值对数组长度求余, 如果对应位置上没有数据则直接创建node对象插入到对应的桶上

if ((p = tab[i = (n - 1) & hash]) == null)

tab[i] = newNode(hash, key, value, null);

else {

Node<K,V> e; K k;

if (p.hash == hash &&

((k = p.key) == key || (key != null && key.equals(k))))

e = p;

else if (p instanceof TreeNode)

e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);

else {

for (int binCount = 0; ; ++binCount) {

if ((e = p.next) == null) {

p.next = newNode(hash, key, value, null);

if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st

treeifyBin(tab, hash);

break;

}

if (e.hash == hash &&

((k = e.key) == key || (key != null && key.equals(k))))

break;

p = e;

}

if (e != null) { // existing mapping for key

V oldValue = e.value;

if (!onlyIfAbsent || oldValue == null)

e.value = value;

afterNodeAccess(e);

return oldValue;

}

++modCount;

if (++size > threshold)

resize();

afterNodeInsertion(evict);

return null;

}

final Node<K,V>[] resize() {

Node<K,V>[] oldTab = table;

int oldCap = (oldTab == null) ? 0 : oldTab.length;

int oldThr = threshold;

int newCap, newThr = 0;

if (oldCap > 0) {

if (oldCap >= MAXIMUM_CAPACITY) {

threshold = Integer.MAX_VALUE;

return oldTab;

}

else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&

oldCap >= DEFAULT_INITIAL_CAPACITY)

newThr = oldThr << 1; // double threshold

}

else if (oldThr > 0) // initial capacity was placed in threshold

newCap = oldThr;

else { // zero initial threshold signifies using defaults

newCap = DEFAULT_INITIAL_CAPACITY;

newThr = (int)(DEFAULT_LOAD_FACTOR DEFAULT_INITIAL_CAPACITY);

}

if (newThr == 0) {

float ft = (float)newCap loadFactor;

newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?

(int)ft : Integer.MAX_VALUE);

}

threshold = newThr;

@SuppressWarnings({"rawtypes","unchecked"})

Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];

table = newTab;

if (oldTab != null) {

for (int j = 0; j < oldCap; ++j) {

Node<K,V> e;

if ((e = oldTab[j]) != null) {

oldTab[j] = null;

if (e.next == null)

newTab[e.hash & (newCap - 1)] = e;

else if (e instanceof TreeNode)

((TreeNode<K,V>)e).split(this, newTab, j, oldCap);

else { // preserve order

Node<K,V> loHead = null, loTail = null;

Node<K,V> hiHead = null, hiTail = null;

Node<K,V> next;

do {

next = e.next;

if ((e.hash & oldCap) == 0) {

if (loTail == null)

loHead = e;

else

loTail.next = e;

loTail = e;

}

else {

if (hiTail == null)

hiHead = e;

else

hiTail.next = e;

hiTail = e;

}

} while ((e = next) != null);

if (loTail != null) {

loTail.next = null;

newTab[j] = loHead;

}

if (hiTail != null) {

hiTail.next = null;

newTab[j + oldCap] = hiHead;

}

return newTab;

}

zjh0101

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java Map接口

先执行hash(key)根据key获取一个hash值, 参数2是要存储的key值，参数3是要存储的value，参数4表示如果当前位置已存在一个值。* Java7中使用Entry来代表每个HashMap中的数据节点，Java8中使用Node，基本没有区别，都是key，value，hash和。//如果原始存储的数据和value参数不相等或者不存在对应的key并且key对应存储的原始数据为null，则不执行任何操作。//哈希表的本质是一个数组，数组中每一个元素称为一个桶，桶中存放的是键值对。
复制链接

扫一扫