☆技术问答集锦（一）

1 hashCode和equals方法，在HashMap中如何使用？hashCode和equals方法之间的关系及为什么？

Object的equals和hashCode方法。如下：

 // hashCode()方法默认是native方法；
 public native int hashCode();
 
 // equals(obj)默认比较的是内存地址；
 public boolean equals(Object obj) {
     return (this == obj);
 }

hashCode()方法有三个关注点：

关注点1：主要是说这个hashCode方法对哪些类是有用的，并不是任何情况下都要使用这个方法（此时是根本没有必要来复写此方法），而是 当你涉及到像HashMap、HashSet(他们的内部实现中使用到了hashCode方法)等与hash有关的一些类时，才会使用到hashCode方法。

关注点2：推荐按照这样的原则来设计，即 当equals(object)相同时，hashCode()的返回值也要尽量相同，当equals(object)不相同时，hashCode()的返回没有特别的要求，但是也是尽量不相同以获取好的性能。

关注点3：默认的hashCode实现一般是内存地址对应的数字，所以不同的对象，hashCode()的返回值是不一样的。

在这种缺省实施情况下，只有它们引用真正同一个对象时这两个引用才是相等的。同样，Object提供的hashCode()的缺省实施通过将对象的内存地址对映于一个整数值来生成。

接下来HashMap的源码分析hashCode和equals方法使用过程：

 static final Entry<?,?>[] EMPTY_TABLE = {}; 
 transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;

HashMap内部是由Entry<K,V>类型的数组table来存储数据的。来看下Entry<K,V>的代码：

 static class Entry<K,V> implements Map.Entry<K,V> { 
     final K key; 
     V value; 
     Entry<K,V> next; 
     // key的hashCode方法的返回值经过hash运算得到的值
     int hash; 

     /** * Creates new entry. */ 
     Entry(int h, K k, V v, Entry<K,V> n) { 
         value = v; 
         next = n; 
         key = k; 
         hash = h; 
     }
     //略
 }

所以我们可以画出HashMap的存储结构：

HashMap存储结构

图中的每一个方格就表示一个Entry<K,V>对象，其中的横向则构成一个Entry<K,V>[] table数组，而竖向则是由Entry<K,V>的next属性形成的链表。

首先看下它HashMap是如何来添加的，即 put(K key, V value)方法：

 public V put(K key, V value) { 
     if (table == EMPTY_TABLE) { 
         inflateTable(threshold);
     } 
     if (key == null) return putForNullKey(value); 
     // 位置[1]
     int hash = hash(key);
     // 位置[2]
     int i = indexFor(hash, table.length); 
     for (Entry<K,V> e = table[i]; e != null; e = e.next) { 
         Object k; 
         // 位置[4] 遍历链表，若链表已存在一致的对象，则替换
         if (e.hash == hash && ((k = e.key) == key || key.equals(k))) { 
             V oldValue = e.value; 
             e.value = value;
             e.recordAccess(this); 
             return oldValue; 
         } 
     } 
     modCount++; 
     // 插入
     addEntry(hash, key, value, i); 
     return null; 
 }

重点关注它的存的过程，位置[1]首先就是计算key的hash值，这个hash计算的过程位置[3]便用到了key对象的hashCode方法，如下：

 final int hash(Object k) { 
     int h = hashSeed; 
     if (0 != h && k instanceof String) { 
         return sun.misc.Hashing.stringHash32((String) k); 
     } 
     // 位置[3]
     h ^= k.hashCode(); 

     h ^= (h >>> 20) ^ (h >>> 12); 
     return h ^ (h >>> 7) ^ (h >>> 4); 
 }

得到这个hash值后，位置[2]紧接着执行了int i = indexFor(hash, table.length)；就是找到这个hash值在table数组中的索引值，具体方法indexFor(hash, table.length)为：

 static int indexFor(int h, int length) { 
     return h & (length-1); 
 }

位置[4]判断是否一致的条件是：e.hash == hash && ((k = e.key) == key || key.equals(k))，一定要牢牢记住这个条件。

必须满足的条件1：hash值一样，hash值的来历就是根据key的hashCode再进行一个复杂的运算，当两个key的hashCode一致的时候，计算出来的hash也是必然一样的。

必须满足的条件2：两个key的引用一样或者equals相同。

综上所述，HashMap对于key的重复性判断是基于两个内容的判断，一个就是hash值是否一样（会演变成key的hashCode是否一样），另一个就是equals方法是否一样（引用一样则肯定一样）。

所以，hashCode的重写的原则：当equals方法返回true，则两个对象的hashCode必须一样。

equals()方法，在get()方法中的使用过程分析：

 public V get(Object key) {    
     Node<K,V> e;
     return (e = getNode(hash(key), key)) == null ? null : e.value;
 }
 
 final Node<K,V> getNode(int hash, Object key) {
     Node<K,V>[] tab; 
     Node<K,V> first, e; 
     int n; K k;    
     if ((tab = table) != null && (n = tab.length) > 0 && (first = tab[(n - 1) & hash]) != null) {
         // 元素相等判断
         if (first.hash == hash && ((k = first.key) == key || (key != null && key.equals(k))))
             return first;        
         if ((e = first.next) != null) {            
             if (first instanceof TreeNode)                
                 return ((TreeNode<K,V>)first).getTreeNode(hash, key);                 
             do { 
                 // 链表上的元素相等判断           
                 if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))
                     return e;            
             } while ((e = e.next) != null);
         }
     }
     return null;
 }

为什么 Override equals()和hashCode()?

由于作为key的对象将通过计算其hashCode来确定与之对应的value的位置，因此任何作为key的对象都必须实现 hashCode和equals方法。hashCode和equals方法继承自根类Object，如果你用自定义的类当作key的话，要相当小心，按照散列函数的定义，如果两个对象相同，即obj1.equals(obj2)=true，则它们的hashCode必须相同，但如果两个对象不同，则它们的 hashCode不一定不同，如果两个不同对象的hashCode相同，这种现象称为冲突，冲突会导致操作哈希表的时间开销增大，hashCode()方法目的纯粹用于提高效率，所以尽量定义好的 hashCode()方法，能加快哈希表的操作。

如果相同的对象有不同的hashCode，对哈希表的操作会出现意想不到的结果（期待的get方法返回null），要避免这种问题，只需要牢记一条：要同时复写equals方法和hashCode方法，而不要只写其中一个。

hashcode与equals方法使用：http://my.oschina.net/xianggao/blog/90110

2 内存泄漏与内存溢出的区别？

Java虚拟机在执行Java程序的过程中把它所管理的内存划分为若干个不同的数据区域。这些区域都有各自的用途，以及创建和销毁的时间，有的区域随着虚拟机进程的启动而存在，有些区域则依赖用户线程的启动和结束而建立和销毁。如下图所示：

JVM运行时数据区域

虚拟机栈在运行时使用一种叫做栈帧的数据结构保存上下文数据。在栈帧中，存放了方法的局部变量表，操作数栈，动态连接方法和返回地址等信息。每一个方法的调用都伴随着栈帧的入栈操作。相应地，方法的返回则表示栈帧的出栈操作。如果方法调用时，方法的参数和局部变量相对较多，那么栈帧中的局部变量表就会比较大，栈帧会膨胀以满足方法调用所需传递的信息。因此，单个方法调用所需的栈空间大小也会比较多。

虚拟机栈结构

注意：函数嵌套调用的次数由栈的大小决定。栈越大，函数嵌套调用次数越多。对一个函数而言，它的参数越多，内部局部变量越多，它的栈帧就越大，其嵌套调用次数就会越少。

可达性分析：Java中对内存对象的访问，使用的是引用的方式。在Java代码中我们维护一个内存对象的引用变量，通过这个引用变量的值，我们可以访问到对应的内存地址中的内存对象空间。在Java程序中，这个引用变量本身既可以存放堆内存中，又可以放在代码栈的内存中（与基本数据类型相同）。GC线程会从代码栈中的引用变量开始跟踪，从而判定哪些内存是正在使用的。如果GC线程通过这种方式，无法跟踪到某一块堆内存，那么GC就认为这块内存将不再使用了（因为代码中已经无法访问这块内存了）。

可达性分析

通过这种有向图的内存管理方式，当一个内存对象失去了所有的引用之后，GC
就可以将其回收。反过来说，如果这个对象还存在引用，那么它将不会被GC回收，哪怕是Java虚拟机抛出OutOfMemoryError。

Java中的内存泄漏，主要指的是是在内存对象明明已经不需要的时候，还仍然保留着这块内存和它的访问方式（引用）。

在不涉及复杂数据结构的一般情况下，Java的内存泄露表现为一个内存对象的生命周期超出了程序需要它的时间长度。我们有时也将其称为“对象游离”。

3 深入HashMap，及并发读写情况下死循环问题？

深入JDK源码之HashMap类：http://my.oschina.net/xianggao/blog/386697

HashMap多线程并发问题分析：http://my.oschina.net/xianggao/blog/393990

ConcurrentHashMap深入分析：http://my.oschina.net/xianggao/blog/212060

HashMap vs ConcurrentHashMap：http://my.oschina.net/xianggao/blog/394213