java开发岗位面试题汇总及解析1

在网上搜集很多面试题，发现这套题挺不错的，但是没有给出解答。这里自己查阅资料进行补充。

一、Java基础
1. String类为什么是final的。
答：final类是不允许继承，这点是关键。然后延伸下为什么这么做喃？
首先上String源代码

public final class String
    implements java.io.Serializable, Comparable, CharSequence {
    /** The value is used for character storage. */
    private final char value[];

    /** Cache the hash code for the string */
    private int hash; // Default to 0
    ..
    ..
    }

然后发现String主要成员是一个字符数组，并且是私有和final的，这里作为切入点。这里不难理解，final保证了字符数组的引用不会被修改，而私有保证了隐秘外界无法访问也就无法对内容再进行篡改。这就保证了安全的目的。
ps:单纯final修饰的数组，不允许引用修改，如

final int[] a = {1,2};
int[] b = {3,4};
a= b;//编辑器会报错，final不可变

虽然引用不能变，但不能保证引用的内容不能变。
可以通过

a[1] = 3;

或者通过反射进行修改

Array.set(a,1,3);

都能达到 a的内容变成[1,3]的效果。
2. HashMap的源码，实现原理，底层结构。
答：
1) 源码

/** since   1.2
**/
public class HashMap<K,V> extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable {
    ..
    }

1.1 主要属性

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; //默认容量为16
static final int MAXIMUM_CAPACITY = 1 << 30;//最大容量
static final float DEFAULT_LOAD_FACTOR = 0.75f;//默认负载因子值（0~1），值越大填的越密集
int threshold; 
/**
    * 临界值   当实际大小超过临界值时，会进行扩容
    * threshold = 加载因子*容量
*/
transient int modCount;//被修改的次数
transient int size;//存放元素的个数

其中loadFactor加载因子是表示Hsah表中元素的填满的程度.
若:加载因子越大,填满的元素越多,好处是,空间利用率高了,但:冲突的机会加大了.链表长度会越来越长,查找效率降低。
反之,加载因子越小,填满的元素越少,好处是:冲突的机会减小了,但:空间浪费多了.表中的数据将过于稀疏（很多空间还没用，就开始扩容了）
冲突的机会越大,则查找的成本越高.
因此,必须在 “冲突的机会”与”空间利用率”之间寻找一种平衡与折衷. 这种平衡与折衷本质上是数据结构中有名的”时-空”矛盾的平衡与折衷.
如果机器内存足够，并且想要提高查询速度的话可以将加载因子设置小一点；相反如果机器内存紧张，并且对查询速度没有什么要求的话可以将加载因子设置大一点。不过一般我们都不用去设置它，让它取默认值0.75就好了。
1.2 构造方法　
　

public HashMap(int initialCapacity, float loadFactor) {
          //确保数字合法
          if (initialCapacity < 0)
              throw new IllegalArgumentException("Illegal initial capacity: " +
                                                initialCapacity);
          if (initialCapacity > MAXIMUM_CAPACITY)
              initialCapacity = MAXIMUM_CAPACITY;
          if (loadFactor <= 0 || Float.isNaN(loadFactor))
              throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);

         // Find a power of 2 >= initialCapacity
         int capacity = 1;   //初始容量
         while (capacity < initialCapacity)   //确保容量为2的n次幂，使capacity为大于initialCapacity的最小的2的n次幂
             capacity <<= 1;

         this.loadFactor = loadFactor;
         threshold = (int)(capacity * loadFactor);
         table = new Entry[capacity];
        init();
    }

     public HashMap(int initialCapacity) {
         this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }

     public HashMap() {
         this.loadFactor = DEFAULT_LOAD_FACTOR;
         threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);
         table = new Entry[DEFAULT_INITIAL_CAPACITY];
        init();
     }

我们可以看到在构造HashMap的时候如果我们指定了加载因子和初始容量的话就调用第一个构造方法，否则的话就是用默认的。默认初始容量为16，默认加载因子为0.75。我们可以看到上面代码中13-15行，这段代码的作用是确保容量为2的n次幂，使capacity为大于initialCapacity的最小的2的n次幂
1.3 存储数据
　　HashMap的put方法：
　　

public V put(K key, V value) {
     // 若“key为null”，则将该键值对添加到table[0]中。
         if (key == null) 
            return putForNullKey(value);
     // 若“key不为null”，则计算该key的哈希值，然后将其添加到该哈希值对应的链表中。
         int hash = hash(key.hashCode());
     //搜索指定hash值在对应table中的索引
         int i = indexFor(hash, table.length);
     // 循环遍历Entry数组,若“该key”对应的键值对已经存在，则用新的value取代旧的value。然后退出！
         for (Entry e = table[i]; e != null; e = e.next) { 
             Object k;
              if (e.hash == hash && ((k = e.key) == key || key.equals(k))) { //如果key相同则覆盖并返回旧值
                  V oldValue = e.value;
                 e.value = value;
                 e.recordAccess(this);
                 return oldValue;
              }
         }
     //修改次数+1
         modCount++;
     //将key-value添加到table[i]处
     addEntry(hash, key, value, i);
     return null;
}

上面程序中用到了一个重要的内部接口：Map.Entry，每个 Map.Entry 其实就是一个 key-value 对。从上面程序中可以看出：当系统决定存储 HashMap 中的 key-value 对时，完全没有考虑 Entry 中的 value，仅仅只是根据 key 来计算并决定每个 Entry 的存储位置。这也说明了前面的结论：我们完全可以把 Map 集合中的 value 当成 key 的附属，当系统决定了 key 的存储位置之后，value 随之保存在那里即可。
我们慢慢的来分析这个函数，第2和3行的作用就是处理key值为null的情况，我们看看putForNullKey(value)方法：

private V putForNullKey(V value) {
          for (Entry e = table[0]; e != null; e = e.next) {
              if (e.key == null) {   //如果有key为null的对象存在，则覆盖掉
                  V oldValue = e.value;
                  e.value = value;
                  e.recordAccess(this);
                  return oldValue;
             }
         }
         modCount++;
         addEntry(0, null, value, 0); //如果键为null的话，则hash值为0
         return null;
 }

注意：如果key为null的话，hash值为0，对象存储在数组中索引为0的位置。即table[0]
我们再回去看看put方法中第4行，它是通过key的hashCode值计算hash码，下面是计算hash码的函数：

//计算hash值的方法 通过键的hashCode来计算
     static int hash(int h) {
         // This function ensures that hashCodes that differ only by
         // constant multiples at each bit position have a bounded
         // number of collisions (approximately 8 at default load factor).
         h ^= (h >>> 20) ^ (h >>> 12);
         return h ^ (h >>> 7) ^ (h >>> 4);
     }

得到hash码之后就会通过hash码去计算出应该存储在数组中的索引，计算索引的函数如下：
　

 static int indexFor(int h, int length) { //根据hash值和数组长度算出索引值
         return h & (length-1);  //这里不能随便算取，用hash&(length-1)是有原因的，这样可以确保算出来的索引是在数组大小范围内，不会超出
     }

这个我们要重点说下，我们一般对哈希表的散列很自然地会想到用hash值对length取模（即除法散列法），Hashtable中也是这样实现的，这种方法基本能保证元素在哈希表中散列的比较均匀，但取模会用到除法运算，效率很低，HashMap中则通过h&(length-1)的方法来代替取模，同样实现了均匀的散列，但效率要高很多，这也是HashMap对Hashtable的一个改进。
接下来，我们分析下为什么哈希表的容量一定要是2的整数次幂。首先，length为2的整数次幂的话，h&(length-1)就相当于对length取模，这样便保证了散列的均匀，同时也提升了效率；其次，length为2的整数次幂的话，为偶数，这样length-1为奇数，奇数的最后一位是1，这样便保证了h&(length-1)的最后一位可能为0，也可能为1（这取决于h的值），即与后的结果可能为偶数，也可能为奇数，这样便可以保证散列的均匀性，而如果length为奇数的话，很明显length-1为偶数，它的最后一位是0，这样h&(length-1)的最后一位肯定为0，即只能为偶数，这样任何hash值都只会被散列到数组的偶数下标位置上，这便浪费了近一半的空间，因此，length取2的整数次幂，是为了使不同hash值发生碰撞的概率较小，这样就能使元素在哈希表中均匀地散列。
根据上面 put 方法的源代码可以看出，当程序试图将一个key-value对放入HashMap中时，程序首先根据该 key 的 hashCode() 返回值决定该 Entry 的存储位置：
　 如果两个 Entry 的 key 的 hashCode() 返回值相同，那它们的存储位置相同。
　　如果这两个 Entry 的 key 通过 equals 比较返回 true，新添加 Entry 的 value 将覆盖集合中原有 Entry 的 value，但key不会覆盖。　　
　　如果这两个 Entry 的 key 通过 equals 比较返回 false，新添加的 Entry 将与集合中原有 Entry 形成 Entry 链，而且新添加的 Entry 位于 Entry 链的头部——
　　具体说明继续看 addEntry() 方法的说明。
　　

void addEntry(int hash, K key, V value, int bucketIndex) {
         Entry e = table[bucketIndex]; //如果要加入的位置有值，将该位置原先的值设置为新entry的next,也就是新entry链表的下一个节点
         table[bucketIndex] = new Entry<>(hash, key, value, e);
         if (size++ >= threshold) //如果大于临界值就扩容
             resize(2 * table.length); //以2的倍数扩容
 }

参数bucketIndex就是indexFor函数计算出来的索引值，第2行代码是取得数组中索引为bucketIndex的Entry对象，第3行就是用hash、key、value构建一个新的Entry对象放到索引为bucketIndex的位置，并且将该位置原先的对象设置为新对象的next构成链表。
第4行和第5行就是判断put后size是否达到了临界值threshold，如果达到了临界值就要进行扩容，HashMap扩容是扩为原来的两倍。
1.4 调整大小
　　

void resize(int newCapacity) {
          Entry[] oldTable = table;
          int oldCapacity = oldTable.length;
          if (oldCapacity == MAXIMUM_CAPACITY) {
              threshold = Integer.MAX_VALUE;
              return;
         }

         Entry[] newTable = new Entry[newCapacity];
         transfer(newTable);//用来将原先table的元素全部移到newTable里面
         table = newTable;  //再将newTable赋值给table
         threshold = (int)(newCapacity * loadFactor);//重新计算临界值
     }

新建了一个HashMap的底层数组，上面代码中第10行为调用transfer方法，将HashMap的全部元素添加到新的HashMap中,并重新计算元素在新的数组中的索引位置
当HashMap中的元素越来越多的时候，hash冲突的几率也就越来越高，因为数组的长度是固定的。所以为了提高查询的效率，就要对HashMap的数组进行扩容，数组扩容这个操作也会出现在ArrayList中，这是一个常用的操作，而在HashMap数组扩容之后，最消耗性能的点就出现了：原数组中的数据必须重新计算其在新数组中的位置，并放进去，这就是resize。
那么HashMap什么时候进行扩容呢？当HashMap中的元素个数超过数组大小*loadFactor时，就会进行数组扩容，loadFactor的默认值为0.75，这是一个折中的取值。也就是说，默认情况下，数组大小为16，那么当HashMap中元素个数超过16*0.75=12的时候，就把数组的大小扩展为 2*16=32，即扩大一倍，然后重新计算每个元素在数组中的位置，扩容是需要进行数组复制的，复制数组是非常消耗性能的操作，所以如果我们已经预知HashMap中元素的个数，那么预设元素的个数能够有效的提高HashMap的性能。
1.5 取数据

public V get(Object key) {   
    if (key == null)   
        return getForNullKey();   
    int hash = hash(key.hashCode());   
    for (Entry e = table[indexFor(hash, table.length)];   
        e != null;   
        e = e.next) {   
        Object k;   
        if (e.hash == hash && ((k = e.key) == key || key.equals(k)))   
            return e.value;   
    }   
    return null;   
}

　有了上面存储时的hash算法作为基础，理解起来这段代码就很容易了。从上面的源代码中可以看出：从HashMap中get元素时，首先计算key的hashCode，找到数组中对应位置的某一元素，然后通过key的equals方法在对应位置的链表中找到需要的元素。
　　2）实现原理
　　HashMap 在底层将 key-value 当成一个整体进行处理，这个整体就是一个 Entry 对象。HashMap 底层采用一个 Entry[] 数组来保存所有的 key-value 对，当需要存储一个 Entry 对象时，会根据hash算法来决定其在数组中的存储位置，在根据equals方法决定其在该数组位置上的链表中的存储位置；当需要取出一个Entry时，也会根据hash算法找到其在数组中的存储位置，再根据equals方法从该位置上的链表中取出该Entry。
　　3）数据结构
　　数组+链表
3. 说说你知道的几个Java集合类：list、set、queue、map实现类咯。。。
答: list 线性表 实现类主要有
ArrayList 以数组为数据结构，便于查询
LinkedList 以双向链表为数据结构，便于插入
Vector 以数组为数据结构，同步锁机制保证线性安全的
Set 实现类为
HashSet
TreeSet 存储非重复且默认按照字典序排列
Queue 队列 实现类有
PriorityQueue
ps: PriorityQueue不允许插入null元素，还要对队列元素进行排序，两种排序方式：
自然排序：集合中的元素必须实现Comparable接口，而且应该是同一个类的多个实例，否则可能导致ClassCastException异常。
定制排序：创建队列时，传入一个Comparator对象，该对象负责对队列中的所有元素进行排序。采用定制排序时不需要元素实现Comparable接口。
deque接口的实现ArrayDeque
Deque接口是Queue接口的子接口，代表一个双端队列。同时Deque不仅可以作为双端队列使用，而且可以被当成栈来使用，所以可以使用出栈，入栈的方法。
LinkedList类是List接口的实现类，但是同时也是Deque接口实现类，所以LinkedList既可以当做双端队列来使用，也可以当做栈来使用
Map 实现类有
HashMap
TreeMap

4. 描述一下ArrayList和LinkedList各自实现和区别
答：
实现：
ArrayList主要成员是

transient Object[] elementData;

构造函数初始化这个对象数组，存放数据就是指定数组下标存放指定的数组，并返回旧值；取数据就是返回指定下标对应的值。
LinkedList 主要成员是

transient Node first;
private static class Node {
        E item;
        Node next;
        Node prev;

        Node(Node prev, E element, Node next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }

这个Node是一个双向链表，存放数据就是遍历指针，找到相应的位置

 Node node(int index) {
        // assert isElementIndex(index);

        if (index < (size >> 1)) {
            Node x = first;
            for (int i = 0; i < index; i++)
                x = x.next;
            return x;
        } else {
            Node x = last;
            for (int i = size - 1; i > index; i--)
                x = x.prev;
            return x;
        }
    }

注意这里根据指定的下标与中间位置的比较，来分别从头或者尾来进行索引。找到指定位置，记住前后元素并插入新值。
区别：
1.ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。
2.对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。
3.对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据。
ps:LinkedList的方法比较多：
peek :返回first元素值
element:也是返回first元素值
poll:弹出first元素

private E unlinkFirst(Node f) {
        // assert f == first && f != null;
        final E element = f.item;
        //记住first的下一个元素next
        final Node next = f.next;
        //first元素置空以备gc
        f.item = null;
        f.next = null; // help GC
        //开始指针指向上面记录的next
        first = next;
        if (next == null)
            last = null;
        else
            next.prev = null;
        size--;
        //修改次数加一
        modCount++;
        return element;
    }

getFirst()getLast()addFirst(E)addLast(E)
set(int, E)指定下标覆盖
offer(E) == add(E)
offerFirst(E)offerLast(E)peekFirst()peekLast()pollFirst()pollLast()
栈操作push(E)=addFirst(E),pop()=removeFirst()
5. Java中的队列都有哪些，有什么区别。
答：
看上面图，queue接口有实现类PriorityQueue(标准的先进先出的队列，不允许放空值)，子接口Deque及相应实现类ArrayDeque(数组)和LinkedList(双向链表)
6. 反射中，Class.forName和classloader的区别
答：
都是将指定的.class文件的二进制加载到内存的方法区，然后在堆中开辟对象空间，区别在于Claas.forName方法还会做额外的工作：解析并初始化静态代码块，而classloader是在newInstance的时候才会做这一步。
7. Java7、Java8的新特性(baidu问的,好BT)
答：
Java7主要有：
1）switch不但可以指定byte,short,int,chr,也可以指定String
2)泛型实例化时类型可以自动推断，光写<>

List<String> tempList = new ArrayList<>();

3)集合可以用[] {} 直接存入数据

      List list=["item"]; //向List集合中添加元素
      String item=list[0]; //从List集合中获取元素

      Set set={"item"}; //向Set集合对象中添加元素

      Map map={"key":1}; //向Map集合中添加对象
      int value=map["key"]; //从Map集合中获取对象

4)数值可以加下横线

int one_million = 1_000_000;

5）支持二进制文字

int binary = 0b1001_1001

6）新增一些取环境信息的工具方法

File System.getJavaIoTempDir() // IO临时文件夹

File System.getJavaHomeDir() // JRE的安装目录

File System.getUserHomeDir() // 当前用户目录

File System.getUserDir() // 启动java进程时所在的目录

Java8主要有：
1）接口的默认方法
Java 8允许我们给接口添加一个非抽象的方法实现，只需要使用 default关键字即可，这个特征又叫做扩展方法，示例如下：

interface Formula {
    double calculate(int a); 
    default double sqrt(int a) {
        return Math.sqrt(a);
    }
}

Formula接口在拥有calculate方法之外同时还定义了sqrt方法，实现了Formula接口的子类只需要实现一个calculate方法，默认方法sqrt将在子类上可以直接使用。
代码如下:

Formula formula = new Formula() {
    @Override
    public double calculate(int a) {
        return sqrt(a * 100);
    }
}; 
formula.calculate(100);     // 100.0
formula.sqrt(16);           // 4.0

2)Lambda 表达式
首先看看在老版本的Java中是如何排列字符串的：

List<String> names = Arrays.asList("peter", "anna", "mike", "xenia"); 
Collections.sort(names, new Comparator<String>() {
    @Override
    public int compare(String a, String b) {
        return b.compareTo(a);
    }
});

只需要给静态方法 Collections.sort 传入一个List对象以及一个比较器来按指定顺序排列。通常做法都是创建一个匿名的比较器对象然后将其传递给sort方法。
在Java 8 中你就没必要使用这种传统的匿名对象的方式了，Java 8提供了更简洁的语法，lambda表达式：

Collections.sort(names, (String a, String b) -> {
    return b.compareTo(a);
});

或者

Collections.sort(names, (String a, String b) -> b.compareTo(a));

或者更简洁

Collections.sort(names, (a, b) -> b.compareTo(a));

Java编译器可以自动推导出参数类型，所以你可以不用再写一次类型
3）函数式接口
“函数式接口”是指仅仅只包含一个抽象方法的 接口，每一个该类型的lambda表达式都会被匹配到这个抽象方法。因为 默认方法 不算抽象方法，所以你也可以给你的函数式接口添加默认方法。
将lambda表达式当作任意只包含一个抽象方法的接口类型，确保你的接口一定达到这个要求，你只需要给你的接口添加 @FunctionalInterface 注解，编译器如果发现你标注了这个注解的接口有多于一个抽象方法的时候会报错的。

@FunctionalInterface
interface Converter {
    T convert(F from);
}
Converter converter = (from) -> Integer.valueOf(from);
Integer converted = converter.convert("123");
System.out.println(converted);    // 123

4）方法与构造函数引用
上面示例可以通过静态方法引用来表示

Converter<String, Integer> converter = Integer::valueOf;
Integer converted = converter.convert("123");
System.out.println(converted);   // 123

Java 8 允许你使用 :: 关键字来传递方法或者构造函数引用，上面的代码展示了如何引用一个静态方法，我们也可以引用一个对象的方法：

converter = something::startsWith;
String converted = converter.convert("Java");
System.out.println(converted);    // "J"

构造函数是如何使用::关键字来引用的，首先我们定义一个包含多个构造函数的简单类：

class Person {
    String firstName;
    String lastName;
    Person() {}

    Person(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }
}

接下来我们指定一个用来创建Person对象的对象工厂接口：

interface PersonFactory<P extends Person> {
    P create(String firstName, String lastName);
}

这里我们使用构造函数引用来将他们关联起来，而不是实现一个完整的工厂：

PersonFactory personFactory = Person::new;
Person person = personFactory.create("Peter", "Parker");

我们只需要使用 Person::new 来获取Person类构造函数的引用，Java编译器会自动根据PersonFactory.create方法的签名来选择合适的构造函数。
5）Lambda 作用域
在lambda表达式中访问外层作用域和老版本的匿名对象中的方式很相似。你可以直接访问标记了final的外层局部变量，或者实例的字段以及静态变量。
6）访问局部变量
我们可以直接在lambda表达式中访问外层的局部变量：

final int num = 1;
Converter<Integer, String> stringConverter =
        (from) -> String.valueOf(from + num);
stringConverter.convert(2);     // 3

但是和匿名对象不同的是，这里的变量num可以不用声明为final

int num = 1;
Converter<Integer, String> stringConverter =
        (from) -> String.valueOf(from + num);
stringConverter.convert(2);     // 3

不过这里的num必须不可被后面的代码修改（即隐性的具有final的语义）
lambda内部对于实例的字段以及静态变量是即可读又可写

class Lambda4 {
    static int outerStaticNum;
    int outerNum;
    void testScopes() {
        Converter stringConverter1 = (from) -> {
            outerNum = 23;
            return String.valueOf(from);
        };

        Converter stringConverter2 = (from) -> {
            outerStaticNum = 72;
            return String.valueOf(from);
        };
    }
}

8. Java数组和链表两种结构的操作效率，在哪些情况下(从开头开始，从结尾开始，从中间开始)，哪些操作(插入，查找，删除)的效率高
答：
数组 查找效率高，尾部插入影响小
链表 插入删除快，查询一般
9. Java内存泄露的问题调查定位：jmap，jstack的使用等等
答：
jps : 查看当前jvm线程
jinfo :查看当前jvm属性和参数值
jstat: 实时显示本地或远程jvm进程的类装载、内存、垃圾回收、jit编译等
jmap:当前jvm堆和年老代的详细信息
jhat:分析jmap生成的dump文件
jstack:生成当前所有jvm线程的快照，可以定位长时间卡顿
10. string、stringbuilder、stringbuffer区别
答：
都是操作字符串类，区别在于
1.String不可变，字符追加时是开辟新的内存空间，然后将前一个str复制过来，然后追加的
2.StringBuilder是通过char[]方式实现，线程不安全，效率高
3.StringBuffer也是Char[]实现，线程安全，功能和StringBuilder基本一致。
11. hashtable和hashmap的区别
答：
它们都是Map的实现类，HashMap是HashTable轻量级实现。主要区别在于1）HashTable是线程同步的，而HashMap是非线程安全的
2）HashMap允许空键值对，而HashTable不允许
3）HashTable的contains方法，在HashMap替换成containsKey和containsValue
12 .异常的结构，运行时异常和非运行时异常，各举个例子
答：

jvm编译器要求非运行时异常必须捕获处理，否则编译通不过。
13. String a= “abc” String b = “abc” String c = new String(“abc”) String d = “ab” + “c” .他们之间用 == 比较的结果
答：只有new出来的是新地址，其它都是一个另外地址
14. String 类的常用方法
答：
equals //两个字符串是否相等
length //字符串长度
substring //字符串截取
indexOf //指定字符下标
replace //字符串替换
match //根据正则表达式匹配

 public boolean matches(String regex) {
        return Pattern.matches(regex, this);
    }

15. Java 的引用类型有哪几种
答： 强引用，软引用，弱引用，虚引用
Java中提供这四种引用类型主要有两个目的：
第一是可以让程序员通过代码的方式决定某些对象的生命周期；
第二是有利于JVM进行垃圾回收。
强引用是指创建一个对象并把这个对象赋给一个引用变量。
强引用有引用变量指向时永远不会被垃圾回收，JVM宁愿抛出OutOfMemory错误也不会回收这种对象
如果想中断强引用和某个对象之间的关联，可以显示地将引用赋值为null，这样一来的话，JVM在合适的时间就会回收该对象。

MyObject aRef = new  MyObject();  
SoftReference aSoftRef=new SoftReference(aRef);  

对于这个MyObject对象，有两个引用路径，一个是来自SoftReference对象的软引用，一个来自变量aRef的强引用，所以这个MyObject对象是强可及对象。
Java虚拟机的垃圾收集线程对软可及对象和其他一般Java对象进行了区别对待:软可及对象的清理是由垃圾收集线程根据其特定算法按照内存需求决定的。
弱引用也是用来描述非必需对象的，当JVM进行垃圾回收时，无论内存是否充足，都会回收被弱引用关联的对象
虚引用和前面的软引用、弱引用不同，它并不影响对象的生命周期。在java中用java.lang.ref.PhantomReference类表示。如果一个对象与虚引用关联，则跟没有引用与之关联一样，在任何时候都可能被垃圾回收器回收
16. 抽象类和接口的区别
答：
抽象类强调类继承性，将类的公共特性抽象出来
接口强调功能性，只能有抽象的行为和常量
17. java的基础类型和字节大小。
char 2
byte 1
short 2
int 4
float 4
double 8
long 8
boolean 1
18. Hashtable,HashMap,ConcurrentHashMap 底层实现原理与线程安全问题（建议熟悉 jdk 源码，才能从容应答）
答：
HashTable及HashMap见上面分析
ConcurentHashMap是通过数据区分段加锁实现的，线程安全的，效率更高
20. 如果不让你用Java Jdk提供的工具，你自己实现一个Map，你怎么做。说了好久，说了HashMap源代码，如果我做，就会借鉴HashMap的原理，说了一通HashMap实现
答：见上面HashMap源码
21. Hash冲突怎么办？哪些解决散列冲突的方法？
1）链地址法
这种方法的基本思想是将所有哈希地址为i的元素构成一个称为同义词链的单链表，并将单链表的头指针存在哈希表的第i个单元中，因而查找、插入和删除主要在同义词链中进行。链地址法适用于经常进行插入和删除的情况。
2）再哈希法
这种方法是同时构造多个不同的哈希函数：
Hi=RH1（key） i=1，2，…，k
当哈希地址Hi=RH1（key）发生冲突时，再计算Hi=RH2（key）……，直到冲突不再产生。这种方法不易产生聚集，但增加了计算时间。
3）再散列法
基本思想是：当关键字key的哈希地址p=H（key）出现冲突时，以p为基础，产生另一个哈希地址p1，如果p1仍然冲突，再以p为基础，产生另一个哈希地址p2，…，直到找出一个不冲突的哈希地址pi ，将相应元素存入其中。这种方法有一个通用的再散列函数形式：
Hi=（H（key）+di）% m i=1，2，…，n
其中H（key）为哈希函数，m 为表长，di称为增量序列。增量序列的取值方式不同，相应的再散列方式也不同。主要有以下三种：
线性探测再散列
dii=1，2，3，…，m-1
这种方法的特点是：冲突发生时，顺序查看表中下一单元，直到找出一个空单元或查遍全表。
二次探测再散列
di=12，-12，22，-22，…，k2，-k2 ( k<=m/2 )
这种方法的特点是：冲突发生时，在表的左右进行跳跃式探测，比较灵活。
伪随机探测再散列
di=伪随机数序列。

具体实现时，应建立一个伪随机数发生器，（如i=(i+p) % m），并给定一个随机数做起点。
例如，已知哈希表长度m=11，哈希函数为：H（key）= key % 11，则H（47）=3，H（26）=4，H（60）=5，假设下一个关键字为69，则H（69）=3，与47冲突。
如果用线性探测再散列处理冲突，下一个哈希地址为H1=（3 + 1）% 11 = 4，仍然冲突，再找下一个哈希地址为H2=（3 + 2）% 11 = 5，还是冲突，继续找下一个哈希地址为H3=（3 + 3）% 11 = 6，此时不再冲突，将69填入5号单元。
如果用二次探测再散列处理冲突，下一个哈希地址为H1=（3 + 12）% 11 = 4，仍然冲突，再找下一个哈希地址为H2=（3 - 12）% 11 = 2，此时不再冲突，将69填入2号单元。
如果用伪随机探测再散列处理冲突，且伪随机数序列为：2，5，9，……..，则下一个哈希地址为H1=（3 + 2）% 11 = 5，仍然冲突，再找下一个哈希地址为H2=（3 + 5）% 11 = 8，此时不再冲突，将69填入8号单元。
22. HashMap冲突很厉害，最差性能，你会怎么解决?从O（n）提升到log（n）咯
答：
JDK8 中哈希冲突过多，链表会转红黑树，时间复杂度是O(logn)，不会是O(n)
23. rehash
答：
见上面再哈希法
24. hashCode() 与 equals() 生成算法、方法怎么重写
答：

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

 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;
        }