JDK8对比JDK7的差别
1.HashMap的实现差别
2.支持Lambda表达式语法（如创建线程，对于接口只有一个方法需要重写的类可以用lambda方式简洁创建对象）
3.支持Stream流操作。Stream提供一种对 Java 集合的流式操作，比如filter, map, reduce, find, match, sorted等。创建Stream有两种方式：stream() 创建串行流、parallelStream() 创建可以并行计算的并行流。
List<String> stringList = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
List<String> filtered = stringList .parallelStream()
.filter(string > !string.isEmpty()) //过滤
.map(i -> i*i) // 映射
.sorted() // 排序
.limit(10) // 分页
.collect(Collectors.toList()); // 返回结果集
4.接口支持默认方法（如果实现多个接口同时都定义了相同的默认方法，则实现类必须重写该方法）
public interface Interface1{
default void helloWorld() {
System.out.println("hi i'm from Interface1");
}
}
public class MyImplement implements Interface1{
public static void main(String[] args) {
MyImplement myImplement = new MyImplement();
myImplement.helloWorld();
}
}
HashMap结构
Jdk7的实现
数组+链表组成，数组是HashMap的主体，链表用于解决Hash冲突。
Jdk8的实现
数组+红黑树。JDK8中当HashMap链表长度大于8的时候，改为红黑树结构，解决链表过长的问题，当小于6时会转换回链表。
转换阈值为什么是8
Java源码的贡献者在进行大量实验分析，hashcode碰撞次数符合泊松分布，在负载因子0.75（HashMap默认值）的情况下，单个hash槽内元素个数为8的概率为0.00000006，概率小于百万分之一，所以发生红黑树转换的情况其实并不多，设置为8可以大幅减少转换的代价。
从红黑树转换为链表的阈值为6，是为了避免元素数量在临界点来回变化导致的结构频繁转换。
以下为源码注释中的概率说明：
为什么是红黑树而不是其他树？
普通二叉树可能会出现单边长度过长的问题，红黑树属于平衡二叉树，保证树的合理高度，而相比AVL平衡二叉树具备更好的插入、删除效率。（红黑树允许局部少量的不完全平衡，这样对于效率影响不大，但省去了很多没有必要的调平衡操作，avl树调平衡有时候代价较大，所以效率不如红黑树)。
HashMap的扩容机制
当HashMap中的元素越来越多的时候，碰撞的几率也就越来越高，为了提高查询的效率，就要对HashMap的数组进行扩容（resize）。
当hashmap中的元素个数超过数组大小*loadFactor时，就会进行数组扩容，loadFactor的默认值为0.75。
扩容的大小为原数组长度的一倍。
ConcurrentHashmap实现原理
Jdk7的实现
HashTable是一个线程安全的类，它使用synchronized来锁住整张Hash表来实现线程安全，性能低下。
ConcurrentHashMap内部分为很多个Segment，每一个Segment拥有一把锁，每个段相当于一个小的Hashtable。当一个线程占用锁访问其中一个数据段时不影响其他段的访问，提高并发效率。
Jdk8的实现
table数组＋单向链表＋红黑树的结构
jdk8中取消segments字段，直接采用transient volatile HashEntry<K,V>[] table 保存数据，采用 table 数组元素作为锁，从而实现了对每一行数据进行加锁，进一步减少并发冲突的概率，代替原来的每一段加锁。
因为段的隔离级别不太容易确定，默认是16，但是很多情况下并不合适，如果太大很多空间就浪费了，如果太小每个段中可能元素过于多，所以取消segments，改成了CAS算法
ArrayList与LinkedArrayList的区别
- Array(动态数组)的数据结构，一个是Link(链表)的数据结构
- 当随机访问List时（get和set操作），ArrayList比LinkedList的效率更高
- 当对数据进行增加和删除的操作时(add和remove操作)，LinkedList比ArrayList的效率更高
List的安全实现
ArrayList不是线程安全的，有以下几种方案实List的现线程安全：
1. Vector类
Vector实现方式比较笨重，add等每个方法使用Synchronized修饰
Vector v = new Vector(3, 2);
v.addElement(new Integer(1));
v.addElement(new Integer(2));
Enumeration en=v.elements();
while(en.hasMoreElements()){
Object object=en.nextElement();
System.out.println(object);
}
2. Collections.synchronizedList
Collections.synchronizedList(List
List<String> list = Collections.synchronizedList(new ArrayList<>());
3.CopyOnWriteArrayList
List<String> list =new CopyOnWriteArrayList<String>();
list.add("1");
list.add("2");
Iterator<String> iter = list.iterator();
while(iter.hasNext()){
String o = iter.next();
System.out.println(o);
}
内部在add等方法通过ReentrantLock加锁实现。
缺点：
1.因为CopyOnWrite的写是复制机制，所以在进行写操作的时候，内存里会同时驻扎两个对象的内存，旧的对象和新写入的对象。
2.CopyOnWrite容器只能保证数据的最终一致性，不能保证数据的实时一致性。所以如果你希望写入的的数据，马上能读到，请不要使用CopyOnWrite容器。
Java的异常类别
异常分为Error和exception，其中exception分为CheckedException和RuntimeException
Error
error表示系统级的错误，是java运行环境内部错误或硬件问题，由Java虚拟机抛出，除了退出运行别无选择，如OOM(OutOfMemoryError)。
CheckedException（检查异常）
检查异常主要是指IO异常、SQL异常等。对于这种异常，JVM要求我们必须对其进行catch处理，如FileNotFoundException。
RuntimeException（运行时异常）
运行时异常一般不处理，比如NullPointerException，对于运行时异常，程序会将异常一直向上抛，一直抛到处理代码，如果没有catch块进行处理，到了最上层，如果是多线程就有Thread.run()抛出，如果不是多线程就由main.run抛出，抛出异常后线程终止。
Iterator
如有ArrayList a，内容为["a","b","c","d"]
在for 循环里遍历List，删除元素会怎样？
for (int i = 0; i < a.size(); i++) {
if (i == 1) {
a.remove(i);
} else {
System.out.println(i + a.get(i));
}
}
最终输出0a,2d，因为元素b被删除，然后c往前移位对应i=1，所以c也被跳过输出。
在iterator 循环里遍历List，删除元素会怎样？
Iterator<String> iterator = a.iterator();
while (iterator.hasNext()) {
String s = iterator.next();
if ("b".equals(s)) {
a.remove(1);
} else {
System.out.println(s);
}
}
抛出异常ConcurrentModificationException，要避免抛异常应该使用iterator.remove()进行删除。
Iterator实现原理
Iterator的实现中主要有几个变量cursor，lastRest, expectedModCount三个变量，其中cursor将记录下一个位置，lastRet记录当前位置，expectedModCount记录没有修改的List的版本号。
ArrayList作了添加或删除操作都会增加modCount版本号，这样的意思是在迭代期间，会不断检查modCount和迭代器持有的expectedModCount两者是不是相等，如果不想等就抛出异常了
Java的继承有什么缺点
- 父类向子类暴露了实现细节
- 父类更改之后子类也要同时更改
- 子类覆盖了一些方法，可能会导致其他调用了该方法的方法错误
包装类
《阿里巴巴Java手册》规定如下
对于以下语句：
Integer i01 = 59;
int i02 = 59;
Integer i03 =Integer.valueOf(59);
Integer i04 = new Integer(59);
以下输出结果为false的是：
A System.out.println(i01 == i02);
B System.out.println(i01 == i03);
C System.out.println(i03 == i04);
D System.out.println(i02 == i04);
答案为C
JVM中一个字节以下的整型数据会在JVM启动的时候加载进内存，除非用new Integer()显式的创建对象，否则都是同一个对象
所以只有i04是一个新对象，其他都是同一个对象。所有A，B选项为true
C选项i03和i04是两个不同的对象，返回false
D选项i02是基本数据类型，会触发i04自动拆箱，比较的时候比较的是数值，返回true
重写hashCode方法
为什么重写equals方法要重写hashCode方法？
当equals方法被重写时，通常有必要重写hashCode方法，以维护hashCode方法的常规约定：值相同的对象必须有相同的hashCode。
- hashCode不同时，object1.equals(object2)为false；
- hashCode相同时，object1.equals(object2)不一定为true
因为hashCode效率更高（仅为一个int值），比较起来更快，对于HashMap等很多结构是先通过对象的hashCode方法判断是否一致，然后再继续操作。
例如类Person中有属性name、idcard等字段，如果重写equals方法希望通过name、idcard字段值一致则代表该对象相等，必须同时重写hashCode方法。
class Person {
String name;
String idcard;
String sex;
@Override
public int hashCode() {
int result = 17; //任意素数
// 31 有个很好的性能，即用移位和减法来代替乘法，通常*31
result = 31*result +name.hashCode();
result = 31*result +idcard.hashCode();
return result;
}
摘自《Effective Java》中关于重写hashCode方法的习惯步骤如下：
对象引用类型及回收时机
从JDK 1.2版本开始，把对象的引用分为4种级别，从而使程序能更加灵活地控制对象的生命周期。这4种级别由高到低依次为：强引用、软引用、弱引用和虚引用。
(1)强引用（StrongReference）
强引用是我们使用的最广泛，也是最普遍的一种引用类型。即
A a = new A();
只要某个对象有强引用与之关联，JVM必定不会回收这个对象，即使在内存不足的情况下，JVM宁愿抛出OutOfMemory错误也不会回收这种对象。
如果想中断强引用和某个对象之间的关联，可以显示地将引用赋值为null，这样一来的话，JVM在合适的时间就会回收该对象。
⑵软引用（SoftReference）
软引用是用来描述一些有用但并不是必需的对象，在Java中用java.lang.ref.SoftReference类来表示。
软引用是用来描述一些有用但并不是必需的对象，在Java中用java.lang.ref.SoftReference类来表示。
软引用可以和一个引用队列（ReferenceQueue）联合使用，如果软引用所引用的对象被JVM回收，这个软引用就会被加入到与之关联的引用队列中。
对于软引用关联着的对象，只有在内存不足的时候JVM才会回收该对象。因此，这一点可以很好地用来解决OOM的问题，并且这个特性很适合用来实现缓存：比如网页缓存、图片缓存等。
⑶弱引用（WeakReference）
弱引用也是用来描述非必需对象的，当JVM进行垃圾回收时，无论内存是否充足，都会回收被弱引用关联的对象。
在java中，用java.lang.ref.WeakReference类来表示。
WeakReference<String> sr = new WeakReference<String>(new String("aaa"));
不过要注意的是，这里所说的被弱引用关联的对象是指只有弱引用与之关联，如果存在强引用同时与之关联，则进行垃圾回收时也不会回收该对象（软引用也是如此）。弱引用也可以和一个引用队列（ReferenceQueue）联合使用。
⑷虚引用（PhantomReference）
如果一个对象与虚引用关联，则跟没有引用与之关联一样，在任何时候都可能被垃圾回收器回收。在java中用java.lang.ref.PhantomReference类表示。
ReferenceQueue<String> queue = new ReferenceQueue<String>();
PhantomReference<String> pr = new PhantomReference<String>(new String("aaa"), queue);
虚引用必须和引用队列关联使用，当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会把这个虚引用加入到与之关联的引用队列中。