存取之美 —— HashMap原理、源码、实践

最新推荐文章于 2019-03-11 15:22:18 发布
最新推荐文章于 2019-03-11 15:22:18 发布
阅读量357 收藏
点赞数
分类专栏： java HashMap

HashMap是一种十分常用的数据结构，作为一个应用开发人员，对其原理、实现的加深理解有助于更高效地进行数据存取。本文所用的jdk版本为1.5。 

使用HashMap 

《Effective JAVA》中认为，99%的情况下，当你覆盖了equals方法后，请务必覆盖hashCode方法。默认情况下，这两者会采用Object的“原生”实现方式，即： 

Java代码  复制代码
  1. protected native int hashCode();   
  2. public boolean equals(Object obj) {   
  3.     return (this == obj);   
  4. }  
[java]  view plain  copy
  1. protected native int hashCode();  
  2. public boolean equals(Object obj) {  
  3.     return (this == obj);  
  4. }  



hashCode方法的定义用到了native关键字，表示它是由C或C++采用较为底层的方式来实现的，你可以认为它返回了该对象的内存地址；而缺省equals则认为，只有当两者引用同一个对象时，才认为它们是相等的。如果你只是覆盖了equals()而没有重新定义hashCode()，在读取HashMap的时候，除非你使用一个与你保存时引用完全相同的对象作为key值，否则你将得不到该key所对应的值。 

另一方面，你应该尽量避免使用“可变”的类作为HashMap的键。如果你将一个对象作为键值并保存在HashMap中，之后又改变了其状态，那么HashMap就会产生混乱，你所保存的值可能丢失（尽管遍历集合可能可以找到）。可参考http://www.ibm.com/developerworks/cn/java/j-jtp02183/ 

HashMap存取机制 

Hashmap实际上是一个数组和链表的结合体，利用数组来模拟一个个桶（类似于Bucket Sort）以快速存取不同hashCode的key，对于相同hashCode的不同key，再调用其equals方法从List中提取出和key所相对应的value。 

JAVA中hashMap的初始化主要是为initialCapacity和loadFactor这两个属性赋值。前者表示hashMap中用来区分不同hash值的key空间长度，后者是指定了当hashMap中的元素超过多少的时候，开始自动扩容，。默认情况下initialCapacity为16，loadFactor为0.75，它表示一开始hashMap可以存放16个不同的hashCode，当填充到第12个的时候，hashMap会自动将其key空间的长度扩容到32，以此类推；这点可以从源码中看出来： 

Java代码  复制代码
  1. void addEntry(int hash, K key, V value, int bucketIndex) {   
  2.     Entry<K,V> e = table[bucketIndex];   
  3.         table[bucketIndex] = new Entry<K,V>(hash, key, value, e);   
  4.         if (size++ >= threshold)   
  5.             resize(2 * table.length);   
  6. }  
[java]  view plain  copy
  1. void addEntry(int hash, K key, V value, int bucketIndex) {  
  2.     Entry<K,V> e = table[bucketIndex];  
  3.         table[bucketIndex] = new Entry<K,V>(hash, key, value, e);  
  4.         if (size++ >= threshold)  
  5.             resize(2 * table.length);  
  6. }  



而每当hashMap扩容后，内部的每个元素存放的位置都会发生变化（因为元素的最终位置是其hashCode对key空间长度取模而得），因此resize方法中又会调用transfer函数，用来重新分配内部的元素；这个过程成为rehash，是十分消耗性能的，因此在可预知元素的个数的情况下，一般应该避免使用缺省的initialCapacity，而是通过构造函数为其指定一个值。例如我们可能会想要将数据库查询所得1000条记录以某个特定字段（比如ID）为key缓存在hashMap中，为了提高效率、避免rehash，可以直接指定initialCapacity为2048。 

另一个值得注意的地方是，hashMap其key空间的长度一定为2的N次方，这一点可以从一下源码中看出来： 

Java代码  复制代码
  1. int capacity = 1;   
  2. while (capacity < initialCapacity)    
  3.     capacity <<= 1;  
[java]  view plain  copy
  1. int capacity = 1;  
  2. while (capacity < initialCapacity)   
  3.     capacity <<= 1;  



即使我们在构造函数中指定的initialCapacity不是2的平方数，capacity还是会被赋值为2的N次方。 

为什么Sun Microsystem的工程师要将hashMap key空间的长度设为2的N次方呢？这里参考R.W.Floyed给出的衡量散列思想的三个标准： 


  • 一个好的hash算法的计算应该是非常快的 
    一个好的hash算法应该是冲突极小化 
    如果存在冲突,应该是冲突均匀化 



为了将各元素的hashCode保存至长度为Length的key数组中，一般采用取模的方式，即index = hashCode % Length。不可避免的，存在多个不同对象的hashCode被安排在同一位置，这就是我们平时所谓的“冲突”。如果仅仅是考虑元素均匀化与冲突极小化，似乎应该将Length取为素数（尽管没有明显的理论来支持这一点，但数学家们通过大量的实践得出结论，对素数取模的产生结果的无关性要大于其它数字）。为此，Craig Larman and Rhett Guthrie《Java Performence》中对此也大加抨击。为了弄清楚这个问题，Bruce Eckel（Thinking in JAVA的作者）专程采访了java.util.hashMap的作者Joshua Bloch，并将他采用这种设计的原因放到了网上（http://www.roseindia.net/javatutorials/javahashmap.shtml） 。 

上述设计的原因在于，取模运算在包括JAVA在内的大多数语言中的效率都十分低下，而当除数为2的N次方时，取模运算将退化为最简单的位运算，其效率明显提升（按照Bruce Eckel给出的数据，大约可以提升5～8倍） 。看看JDK中是如何实现的： 

Java代码  复制代码
  1. static int indexFor(int h, int length) {   
  2.     return h & (length-1);   
  3. }  
[java]  view plain  copy
  1. static int indexFor(int h, int length) {  
  2.     return h & (length-1);  
  3. }  



当key空间长度为2的N次方时，计算hashCode为h的元素的索引可以用简单的与操作来代替笨拙的取模操作！假设某个对象的hashCode为35（二进制为100011），而hashMap采用默认的initialCapacity（16），那么indexFor计算所得结果将会是100011 & 1111 = 11，即十进制的3，是不是恰好是35 Mod 16。 

上面的方法有一个问题，就是它的计算结果仅有对象hashCode的低位决定，而高位被统统屏蔽了；以上面为例，19（10011）、35（100011）、67（1000011）等就具有相同的结果。针对这个问题， Joshua Bloch采用了“防御性编程”的解决方法，在使用各对象的hashCode之前对其进行二次Hash，参看JDK中的源码： 

Java代码  复制代码
  1. static int hash(Object x) {   
  2.         int h = x.hashCode();   
  3.         h += ~(h << 9);   
  4.         h ^=  (h >>> 14);   
  5.         h +=  (h << 4);   
  6.         h ^=  (h >>> 10);   
  7.         return h;   
  8.     }  
[java]  view plain  copy
  1. static int hash(Object x) {  
  2.         int h = x.hashCode();  
  3.         h += ~(h << 9);  
  4.         h ^=  (h >>> 14);  
  5.         h +=  (h << 4);  
  6.         h ^=  (h >>> 10);  
  7.         return h;  
  8.     }  



采用这种旋转Hash函数的主要目的是让原有hashCode的高位信息也能被充分利用，且兼顾计算效率以及数据统计的特性，其具体的原理已超出了本文的领域。 

加快Hash效率的另一个有效途径是编写良好的自定义对象的HashCode，String的实现采用了如下的计算方法： 

Java代码  复制代码
  1. for (int i = 0; i < len; i++) {   
  2. h = 31*h + val[off++];   
  3. }   
  4. hash = h;  
[java]  view plain  copy
  1. for (int i = 0; i < len; i++) {  
  2. h = 31*h + val[off++];  
  3. }  
  4. hash = h;  



这种方法HashCode的计算方法可能最早出现在Brian W. Kernighan和Dennis M. Ritchie的《The C Programming Language》中，被认为是性价比最高的算法（又被称为times33算法，因为C中乘数常量为33，JAVA中改为31），实际上，包括List在内的大多数的对象都是用这种方法计算Hash值。 

另一种比较特殊的hash算法称为布隆过滤器，它以牺牲细微精度为代价，换来存储空间的大量节俭，常用于诸如判断用户名重复、是否在黑名单上等等，可以参考李开复的数学之美系列第13篇（http://googlechinablog.com/2006/08/blog-post.html） 

Fail-Fast机制 

众所周知，HashMap不是线程安全的集合类。但在某些容错能力较好的应用中，如果你不想仅仅因为1%的可能性而去承受hashTable的同步开销，则可以考虑利用一下HashMap的Fail-Fast机制，其具体实现如下： 

Java代码  复制代码
  1. Entry<K,V> nextEntry() {    
  2. if (modCount != expectedModCount)   
  3.     throw new ConcurrentModificationException();   
  4.                      ……   
  5. }  
[java]  view plain  copy
  1. Entry<K,V> nextEntry() {   
  2. if (modCount != expectedModCount)  
  3.     throw new ConcurrentModificationException();  
  4.                      ……  
  5. }  



其中modCount为HashMap的一个实例变量，并且被声明为volatile，表示任何线程都可以看到该变量被其它线程修改的结果（根据JVM内存模型的优化，每一个线程都会存一份自己的工作内存，此工作内存的内容与本地内存并非时时刻刻都同步，因此可能会出现线程间的修改不可见的问题） 。使用Iterator开始迭代时，会将modCount的赋值给expectedModCount，在迭代过程中，通过每次比较两者是否相等来判断HashMap是否在内部或被其它线程修改。HashMap的大多数修改方法都会改变ModCount，参考下面的源码：

Java代码  复制代码
  1. public V put(K key, V value) {   
  2.     K k = maskNull(key);   
  3.         int hash = hash(k);   
  4.         int i = indexFor(hash, table.length);   
  5.         for (Entry<K,V> e = table[i]; e != null; e = e.next) {   
  6.             if (e.hash == hash && eq(k, e.key)) {   
  7.                 V oldValue = e.value;   
  8.                 e.value = value;   
  9.                 e.recordAccess(this);   
  10.                 return oldValue;   
  11.             }   
  12.         }   
  13.         modCount++;   
  14.         addEntry(hash, k, value, i);   
  15.         return null;   
  16.     }  
[java]  view plain  copy
  1. public V put(K key, V value) {  
  2.     K k = maskNull(key);  
  3.         int hash = hash(k);  
  4.         int i = indexFor(hash, table.length);  
  5.         for (Entry<K,V> e = table[i]; e != null; e = e.next) {  
  6.             if (e.hash == hash && eq(k, e.key)) {  
  7.                 V oldValue = e.value;  
  8.                 e.value = value;  
  9.                 e.recordAccess(this);  
  10.                 return oldValue;  
  11.             }  
  12.         }  
  13.         modCount++;  
  14.         addEntry(hash, k, value, i);  
  15.         return null;  
  16.     }  



以put方法为例，每次往HashMap中添加元素都会导致modCount自增。其它诸如remove、clear方法也都包含类似的操作。 
从上面可以看出，HashMap所采用的Fail-Fast机制本质上是一种乐观锁机制，通过检查状态——没有问题则忽略——有问题则抛出异常的方式，来避免线程同步的开销，下面给出一个在单线程环境下发生Fast-Fail的例子： 

Java代码  复制代码
  1. class Test {     
  2.     public static void main(String[] args) {                
  3.         java.util.HashMap<Object,String> map=new java.util.HashMap<Object,String>();     
  4.        map.put(new Object(), "a");     
  5.        map.put(new Object(), "b");     
  6.        java.util.Iterator<Object> it=map.keySet().iterator();     
  7.        while(it.hasNext()){     
  8.            it.next();     
  9.            map.put("", "");          
  10.         System.out.println(map.size());     
  11.     }     
  12. }  
[java]  view plain  copy
  1. class Test {    
  2.     public static void main(String[] args) {               
  3.         java.util.<span class="hilite1">HashMap</span><Object,String> map=new java.util.<span class="hilite1">HashMap</span><Object,String>();    
  4.        map.put(new Object(), "a");    
  5.        map.put(new Object(), "b");    
  6.        java.util.Iterator<Object> it=map.keySet().iterator();    
  7.        while(it.hasNext()){    
  8.            it.next();    
  9.            map.put("", "");         
  10.         System.out.println(map.size());    
  11.     }    
  12. }  



运行上面的代码会抛出java.util.ConcurrentModificationException，因为在迭代过程中修改了HashMap内部的元素导致modCount自增。若将上面代码中 map.put(new Object(), "b") 这句注释掉，程序会顺利通过，因为此时HashMap中只包含一个元素，经过一次迭代后已到了尾部，所以不会出现问题，也就没有抛出异常的必要了。 
在通常并发环境下，还是建议采用同步机制。这一般通过对自然封装该映射的对象进行同步操作来完成。如果不存在这样的对象，则应该使用 Collections.synchronizedMap 方法来“包装”该映射。最好在创建时完成这一操作，以防止意外的非同步访问。 

LinkedHashMap 

遍历HashMap所得到的数据是杂乱无章的，这在某些情况下客户需要特定遍历顺序时是十分有用的。比如，这种数据结构很适合构建 LRU 缓存。调用 put 或 get 方法将会访问相应的条目（假定调用完成后它还存在）。putAll 方法以指定映射的条目集合迭代器提供的键-值映射关系的顺序，为指定映射的每个映射关系生成一个条目访问。Sun提供的J2SE说明文档特别规定任何其他方法均不生成条目访问，尤其，collection 集合类的操作不会影响底层映射的迭代顺序。 

LinkedHashMap的实现与 HashMap 的不同之处在于，前者维护着一个运行于所有条目的双重链接列表。此链接列表定义了迭代顺序，该迭代顺序通常就是集合中元素的插入顺序。该类定义了header、before与after三个属性来表示该集合类的头与前后“指针”，其具体用法类似于数据结构中的双链表，以删除某个元素为例： 

Java代码  复制代码
  1. private void remove() {   
  2.        before.after = after;   
  3.        after.before = before;   
  4. }  
[java]  view plain  copy
  1. private void remove() {  
  2.        before.after = after;  
  3.        after.before = before;  
  4. }  



实际上就是改变前后指针所指向的元素。 

显然，由于增加了维护链接列表的开支，其性能要比 HashMap 稍逊一筹，不过有一点例外：LinkedHashMap的迭代所需时间与其的所包含的元素成比例；而HashMap 迭代时间很可能开支较大，因为它所需要的时间与其容量（分配给Key空间的长度）成比例。一言以蔽之，随机存取用HashMap，顺序存取或是遍历用LinkedHashMap。 

LinkedHashMap还重写了removeEldestEntry方法以实现自动清除过期数据的功能，这在HashMap中是无法实现的，因为后者其内部的元素是无序的。默认情况下，LinkedHashMap中的removeEldestEntry的作用被关闭，其具体实现如下： 

Java代码  复制代码
  1. protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {   
  2.     return false;   
  3. }  
[java]  view plain  copy
  1. protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {  
  2.     return false;  
  3. }  



可以使用如下的代码覆盖removeEldestEntry： 

Java代码  复制代码
  1. private static final int MAX_ENTRIES = 100;   
  2.   
  3. protected boolean removeEldestEntry(Map.Entry eldest) {   
  4.     return size() > MAX_ENTRIES;   
  5. }  
[java]  view plain  copy
  1. private static final int MAX_ENTRIES = 100;  
  2.   
  3. protected boolean removeEldestEntry(Map.Entry eldest) {  
  4.     return size() > MAX_ENTRIES;  
  5. }  



它表示，刚开始，LinkedHashMap中的元素不断增长；当它内部的元素超过MAX_ENTRIES（100）后，每当有新的元素被插入时，都会自动删除双链表中最前端（最旧）的元素，从而保持LinkedHashMap的长度稳定。 

缺省情况下，LinkedHashMap采取的更新策略是类似于队列的FIFO，如果你想实现更复杂的更新逻辑比如LRU（最近最少使用） 等，可以在构造函数中指定其accessOrder为true，因为的访问元素的方法（get）内部会调用一个“钩子”，即recordAccess，其具体实现如下： 

Java代码  复制代码
  1. void recordAccess(HashMap<K,V> m) {   
  2.     LinkedHashMap<K,V> lm = (LinkedHashMap<K,V>)m;   
  3.     if (lm.accessOrder) {   
  4.         lm.modCount++;   
  5.         remove();   
  6.         addBefore(lm.header);   
  7.     }   
  8. }  
[java]  view plain  copy
  1. void recordAccess(<span class="hilite1">HashMap</span><K,V> m) {  
  2.     LinkedHashMap<K,V> lm = (LinkedHashMap<K,V>)m;  
  3.     if (lm.accessOrder) {  
  4.         lm.modCount++;  
  5.         remove();  
  6.         addBefore(lm.header);  
  7.     }  
  8. }  



上述代码主要实现了这样的功能：如果accessOrder被设置为true，则每次访问元素时，都将该元素移至headr的前面，即链表的尾部。将removeEldestEntry与accessOrder一起使用，就可以实现最基本的内存缓存，具体代码可参考http://bluepopopo.javaeye.com/blog/180236。 

WeakHashMap 

99%的JAVA教材教导我们不要去干预JVM的垃圾回收机制，但JAVA中确实存在着与其密切相关的四种引用：强引用、软引用、弱引用以及幻象引用。 

JAVA中默认的HashMap采用的是采用类似于强引用的强键来管理的，这意味着即使作为key的对象已经不存在了（指没有任何一个引用指向它），也仍然会保留在HashMap中，在某些情况下（例如内存缓存）中，这些过期的条目可能会造成内存泄漏等问题。 

WeakHashMap采用的策略是，只要作为key的对象已经不存在了（超出生命周期），就不会阻止垃圾收集器清空此条目，即使当前机器的内存并不紧张。不过，由于GC是一个优先级很低的线程，因此不一定会很快发现那些只具有弱引用的对象，除非你显示地调用它，可以参考下面的例子： 

Java代码  复制代码
  1. public static void main(String[] args) {   
  2.     Map<String, String>map = new WeakHashMap<String, String>();   
  3.     map.put(new String("Alibaba"), "alibaba");   
  4.     while (map.containsKey("Alibaba")) {   
  5.         try {   
  6.             Thread.sleep(500);   
  7.          } catch (InterruptedException ignored) {   
  8.          }   
  9.          System.out.println("Checking for empty");   
  10.          System.gc();   
  11.     }  
[java]  view plain  copy
  1. public static void main(String[] args) {  
  2.     Map<String, String>map = new WeakHashMap<String, String>();  
  3.     map.put(new String("Alibaba"), "alibaba");  
  4.     while (map.containsKey("Alibaba")) {  
  5.         try {  
  6.             Thread.sleep(500);  
  7.          } catch (InterruptedException ignored) {  
  8.          }  
  9.          System.out.println("Checking for empty");  
  10.          System.gc();  
  11.     }  



上述代码输出一次Checking for empty就退出了主线程，意味着GC在最近的一次垃圾回收周期中清除了new String(“Alibaba”),同时WeakHashMap也做出了及时的反应，将该键对应的条目删除了。如果将map的类型改为HashMap的话，由于其内部采用的是强引用机制，因此即使GC被显示调用，map中的条目依然存在，程序会不断地打出Checking for empty字样。另外，在使用WeakHashMap的情况下，若是将 

Java代码  复制代码
  1. map.put(new String("Alibaba"), "alibaba");   
[java]  view plain  copy
  1. map.put(new String("Alibaba"), "alibaba");   



改为 

Java代码  复制代码
  1. map.put("Alibaba", "alibaba");   
[java]  view plain  copy
  1. map.put("Alibaba", "alibaba");   



程序还是会不断输出Checking for empty。这与前面我们分析的WeakHashMap的弱引用机制并不矛盾，因为JVM为了减小重复创建和维护多个相同String的开销，其内部采用了蝇量模式（《JAVA与模式》），此时的“Alibaba”是存放在常量池而非堆中的，因此即使没有对象指向“Alibaba”，它也不会被GC回收。弱引用特别适合以下对象：占用大量内存，但通过垃圾回收功能回收以后很容易重新创建。 

介于HashMap和WeakHashMap之中的是SoftHashMap，它所采用的软引用的策略指的是，垃圾收集器并不像其收集弱可及的对象一样尽量地收集软可及的对象，相反，它只在真正 “需要” 内存时才收集软可及的对象。软引用对于垃圾收集器来说是一种“睁一只眼，闭一只眼”方式，即 “只要内存不太紧张，我就会保留该对象。但是如果内存变得真正紧张了，我就会去收集并处理这个对象。” 就这一点看，它其实要比WeakHashMap更适合于实现缓存机制。遗憾的是，JAVA中并没有实现相关的SoftHashMap类（Apache和Google提供了第三方的实现），但它却是提供了两个十分重要的类java.lang.ref.SoftReference以及ReferenceQueue，可以在对象应用状态发生改变是得到通知，可以参考com.alibaba.common.collection.SofthashMap中processQueue方法的实现: 

Java代码  复制代码
  1. private ReferenceQueue queue = new ReferenceQueue();   
  2. ValueCell vc;   
  3. Map hash = new HashMap(initialCapacity, loadFactor);   
  4. ……   
  5. while ((vc = (ValueCell) queue.poll()) != null) {   
  6. if (vc.isValid()) {   
  7.           hash.remove(vc.key);   
  8.            } else {   
  9.              valueCell.dropped--;   
  10.            }   
  11. }   
  12. }  
[java]  view plain  copy
  1. private ReferenceQueue queue = new ReferenceQueue();  
  2. ValueCell vc;  
  3. Map hash = new HashMap(initialCapacity, loadFactor);  
  4. ……  
  5. while ((vc = (ValueCell) queue.poll()) != null) {  
  6. if (vc.isValid()) {  
  7.           hash.remove(vc.key);  
  8.            } else {  
  9.              valueCell.dropped--;  
  10.            }  
  11. }  
  12. }  



processQueue方法会在几乎所有SoftHashMap的方法中被调用到，JVM会通过ReferenceQueue的poll方法通知该对象已经过期并且当前的内存现状需要将它释放，此时我们就可以将其从hashMap中剔除。事实上，默认情况下，Alibaba的MemoryCache所使用的就是SoftHashMap。 

原址：http://grunt1223.javaeye.com/blog/544497

菜腿求虐
关注
专栏目录
HashMap 源码分析
12-22
《HashMap 源码解析——JDK11版本》 HashMap是Java中广泛使用的非同步散列表，其设计和实现是高效且灵活的。在JDK1.8之前，HashMap的底层数据结构采用的是数组+链表的方式，这种方式称为“拉链法”来解决哈希冲突。...
用JavaScript实现JavaScript文件的版本管理和加载
weixin_33752045的博客
04-14 171
2019独角兽企业重金招聘Python工程师标准>>> ...
前端开发静态文件自动添加版本号解决方案
sun_nan_vip的博客
07-31 6083
web开发时经常遇到这种情况：开发人员修改了静态资源，浏览器缓存过该静态资源，用户再次访问时，js css修改了，用户客户端乱了。其实只要清一下缓存就好了，但是我们不能要求用户去清缓存。那么就需要开发人员给静态资源加版本号，来判断该静态资源是否被修改过。
HashMap的存储原理
风泊月
02-22 604
import java.util.HashMap; /** * * 创建对象HashMap&lt;String,String&gt; map = new HashMap&lt;String ,String&gt;(); * * static final int DEFAULT_INITIAL_CAPACITY = 16; * static final float DEFAULT_L...
HashMap底层存储原理
鸡蛋达芬奇
11-29 1万+
HashMap在日常工作中使用场景非常多，程序员都知道是HashMap是线程非安全的，但是底层是以什么方式存储的？本人仔细研读了一下源码，也只是掌握了核心的存储功能，并没有把全部代码看明白，但是对于理解hashMap的存储结构完全够了。存储结构 hashmap底层是以数组方式进行存储。将key-value对作为数组中的一个元素进行存储。 key-value都是Map.Entry中的属性。其中将key
易语言-HashMap模块源码—— 高效随机存取数据结构 ,文本索引必备
07-02
2、相比网站上发布过的hashtable之类的源码: 此HashMap寻址方法是拉链法.比开放寻址法对连续内存要求更低 哈希函数用的是java中String.hashCode()算法(经实际验证其碰撞率极低且相近的文本散列值相邻,存取的效率更高...
Java——HashMap
12-21
Java——HashMap HashMap 底层: 哈希表存储(数组+链表+红黑树) 特点: 查询,增删效率高,但是无序,存储键值对的值 去重: 根据key做去重,根据key计算桶的位置 扩容: 初始容量: 默认初始用量为16 加载因子: 0.75 当16*...
hashMap1.8源码
01-19
HashMap是Java编程语言中最常用的集合类之一，它提供了一种基于键值对（key-value pair）的数据存储方式，具有高效查找、插入和删除操作。...对于学习者来说，阅读源码并结合实践是掌握HashMap的最好方式。
HashMap之resize()方法源码解读.docx
06-17
HashMap之resize()方法源码解读 HashMap的resize()方法是HashMap中最核心的方法之一，该方法负责扩容HashMap的容量，以便存储更多的键值对。下面我们将对HashMap的resize()方法进行源码解读，了解其扩容机制和原理...
HashMap源码深入解析
漫长学习路
07-25 2086
HashMap是Java Colletion Framework的重要成员，HashMap是Map接口的常用实现类，在我们平常开发时会经常使用到Map，在我们面试的时候也会问到map的存储原理，今天特地来总结一下； 创建HashMap HashMap map = new HashMap(); 使用HashMap那么首先你得去创建一个HashMap，在创建的时候会发生什么事情啦？让我们跟着源码去
Object类有哪些公用方法？
热门推荐
donghaol的专栏
10-19 1万+
Object是所有类的父类，任何类都默认继承Object。
HashMap设计原理、HashMap的数据结构、HashMap源码实现
此处省略三千字
08-30 7402
1. HashMap的设计原理 HashMap设计思路      Map&lt;K,V&gt;是一种以键值对存储数据的容器，而HashMap则是借助了键值Key的hashcode值来组织存储，使得可以非常快速和高效地地根据键值key进行数据的存取。      对于键值对&lt;Key,Value&gt;，HashMap内部会将其封装成一个对应的Entry&lt;Key,Value&gt;对象，...
HashMap的实现原理总结
HelloWorld
04-27 2285
转自：http://www.cnblogs.com/xwdreamer/archive/2012/06/03/2532832.html 1. HashMap概述： 　　HashMap是基于哈希表的Map接口的非同步实现（Hashtable跟HashMap很像，唯一的区别是Hashtalbe中的方法是线程安全的，也就是同步的）。此实现提供所有可选的映射操作，并允许使用null值和
JAVA核心类学习
gakki_wife的博客
03-11 192
JAVA核心类（1） Object： 静态代码块： private static native void registerNatives(); static { registerNatives(); } 要为你自己的类注册本地函数，你必须RegisterNatives从你自己的库中的本机代码调用JNI函数。 native方法： public final nati...
【变压器】基于matlab周期图法和多椎体法变压器噪声信号频谱分析【Matlab仿真 4203期】.zip
11-10
CSDN Matlab武动乾坤上传的资料均有对应的代码，代码均可运行，亲测可用，适合小白； 1、代码压缩包内容 主函数：main.m； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2019b；若运行有误，根据提示修改；若不会，私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开main.m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主或扫描博客文章底部QQ名片； 4.1 博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作
【信道估计】基于matlab OFDM系统LS和DFT和MMSE信道估计（含信噪比）【Matlab仿真 5069期】.zip
最新发布
11-10
【信道估计】基于matlab OFDM系统LS和DFT和MMSE信道估计（含信噪比）【Matlab仿真 5069期】.zip
【信息融合】基于matlab无迹卡尔曼滤波UKF无反馈最优分布式融合【含Matlab源码 9099期】.mp4
11-10
Matlab领域上传的视频均有对应的完整代码，皆可运行，亲测可用，适合小白； 1、代码压缩包内容 主函数：main.m； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2019b；若运行有误，根据提示修改；若不会，私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开main.m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主； 4.1 博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作
【液面控制】基于matlab倒锥形水箱液面模糊控制【Matlab仿真 4253期】.zip
11-10
CSDN Matlab武动乾坤上传的资料均有对应的代码，代码均可运行，亲测可用，适合小白； 1、代码压缩包内容 主函数：main.m； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2019b；若运行有误，根据提示修改；若不会，私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开main.m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主或扫描博客文章底部QQ名片； 4.1 博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值