技术问答集锦（一）

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的存储结构：

图中的每个方格就表示一个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程序的过程当中把它所管理的内存划分为若干个不一样的数据区域。这些区域都有各自的用途，以及建立和销毁的时间，有的区域随着虚拟机进程的启动而存在，有些区域则依赖用户线程的启动和结束而创建和销毁。以下图所示：

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

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

可达性分析：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