最近面试了一些公司，针对面试中遇到的问题在此记录，提升自己，造福大家
以下所有java源码相关展示均为jdk1.8版本中内容
一、java源码相关
-
ArrayList创建和add等各种api使用原理
-
ArrayList是一种变长的集合类，基于定长数组实现。ArrayList允许空值和重复元素，当往 ArrayList 中添加的元素数量大于其底层数组容量时，其会通过扩容机制重新生成一个更大的数组。ArrayList是非线程安全类，并发环境下，多个线程同时操作 ArrayList，会引发不可预知的异常或错误。-
ArrayList创建源码
-
带有初始容量的构造方法
/**
* Shared empty array instance used for empty instances.
*/
private static final Object[] EMPTY_ELEMENTDATA = {};
/** * Constructs an empty list with the specified initial capacity. * * @param initialCapacity the initial capacity of the list * @throws IllegalArgumentException if the specified initial capacity * is negative */ public ArrayList(int initialCapacity) {
// 参数大于0，elementData初始化为initialCapacity大小的数组，即根据传入的参数大小创建数组 if (initialCapacity > 0) { this.elementData = new Object[initialCapacity];
// 参数等于0，创建空数组 } else if (initialCapacity == 0) { this.elementData = EMPTY_ELEMENTDATA;
// 否则抛出异常，参数异常，初始化容量异常 } else { throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity); } }无参构造方法，即使用默认的size为10的空数组，在构造方法中没有对数组长度进行设置，会在后续调用add方法的时候进行扩容
/**
* Shared empty array instance used for default sized empty instances. We
* distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when
* first element is added.
*/
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
/** * Constructs an empty list with an initial capacity of ten. */ public ArrayList() { this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA; }参数为集合的构造方法，将一个参数为Collection的集合转变为ArrayList（实际上就是将集合中的元素换为了数组的形式）。
/** * Constructs a list containing the elements of the specified * collection, in the order they are returned by the collection's * iterator. * * @param c the collection whose elements are to be placed into this list * @throws NullPointerException if the specified collection is null */ public ArrayList(Collection<? extends E> c) {
// 如果传入的集合为空，则c.toArray()抛出空指针异常 elementData = c.toArray();
// 如果传入的数组容量不为0 而且toArray之后不为对象数组的话，就通过数组复制修改为底层结构是对象数组的集合 if ((size = elementData.length) != 0) { // c.toArray might (incorrectly) not return Object[] (see 6260652) if (elementData.getClass() != Object[].class) elementData = Arrays.copyOf(elementData, size, Object[].class); } else { // replace with empty array. this.elementData = EMPTY_ELEMENTDATA; } }
-
-
ArrayList的add方法源码
-
/** * Appends the specified element to the end of this list. * 将指定元素添加到list的结尾 * @param e element to be appended to this list * @return <tt>true</tt> (as specified by {@link Collection#add}) */ public boolean add(E e) {
// 添加前先要扩容数组 ensureCapacityInternal(size + 1); // Increments modCount!! // 将元素添加到数组最后一个位置
elementData[size++] = e; return true; }ensureCapacityInternal方法分析
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
// 计算出最少需要的容量
private static int calculateCapacity(Object[] elementData, int minCapacity) {//这里就是判断elementData数组是不是为空数组 //（使用的无参构造的时候，elementData=DEFAULTCAPACITY_EMPTY_ELEMENTDATA） //如果是，那么比较size+1(第一次调用add的时候size+1=1)和DEFAULT_CAPACITY（为10）， //那么显然容量为10if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
return minCapacity;
}private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// overflow-conscious code 最少需要的容量大于元素总的数量
if (minCapacity - elementData.length > 0)
// 执行扩容方法
grow(minCapacity);
}/**最大容量
* The maximum size of array to allocate.
* Some VMs reserve some header words in an array.
* Attempts to allocate larger arrays may result in
* OutOfMemoryError: Requested array size exceeds VM limit
*/
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
/**
* Increases the capacity to ensure that it can hold at least the
* number of elements specified by the minimum capacity argument.
* 扩容函数，保证扩容后的容量大于需要的最小容量，又小于Integer.MAX_VALUE
* @param minCapacity the desired minimum capacity
*/private void grow(int minCapacity) {
// overflow-conscious code 获取旧数组的容量
int oldCapacity = elementData.length;
// 新数组的容量 = old+old/2,即扩容1.5倍
int newCapacity = oldCapacity + (oldCapacity >> 1);
// 如果新数组的容量比要求的最低容量还少，就使用最低容量作为新数组的容量
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
// 如果旧数组扩容1.5倍之后，比Integer.MAX_VALUE-8大，使用hugeCapacity比较二者
// 如果要求的最小容量大于Integer.MAX_VALUE-8就使用Integer.MAX_VALUE作为扩容后的容量，否则使用Integer.MAX_VALUE-8作为扩容后的容量if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity)；
// minCapacity is usually close to size, so this is a win: 数组复制
elementData = Arrays.copyOf(elementData, newCapacity);}
// 判断得出新数组的容量需要扩容到多少
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();//对minCapacity和MAX_ARRAY_SIZE进行比较 //若minCapacity大，将Integer.MAX_VALUE作为新数组的大小 //若MAX_ARRAY_SIZE大，将MAX_ARRAY_SIZE作为新数组的大小 //MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;}
当 要 add 进第1个元素时，minCapacity为(size+1=0+1=)1，在Math.max()方法比较后，minCapacity 为10。然后紧接着调用ensureExplicitCapacity更新modCount的值，并判断是否需要扩容
add方法执行流程总结
我们用一幅图来简单梳理一下，当使用无参构造的时候，在第一次调用add方法之后的执行流程
这是第一次调用add方法的过程，当扩容值capacity为10之后，
-
继续添加第2个元素（先注意调用ensureCapacityInternal方法传递的参数为size+1=1+1=2）
- 在ensureCapacityInternal方法中，elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA不成立，所以直接执行ensureExplicitCapacity方法
- ensureExplicitCapacity方法中minCapacity为刚刚传递的2，所以第二个if判断（2-10=-8）不会成立，即newCapacity 不比 MAX_ARRAY_SIZE大，则不会进入
grow方法。数组容量为10，add方法中 return true,size增为1。 - 假设又添加3、4......10个元素（其中过程类似，但是不会执行grow扩容方法）
-
当add第11个元素时候，会进入grow方法时，计算newCapacity为15，比minCapacity（为10+1=11）大，第一个if判断不成立。新容量没有大于数组最大size，不会进入hugeCapacity方法。数组容量扩为15，add方法中return true,size增为11。
-
-
add(int index,E element)方法
//在元素序列 index 位置处插入 public void add(int index, E element) { rangeCheckForAdd(index); //校验传递的index参数是不是合法 // 1. 检测是否需要扩容 ensureCapacityInternal(size + 1); // Increments modCount!! // 2. 将 index 及其之后的所有元素都向后移一位 System.arraycopy(elementData, index, elementData, index + 1, size - index); // 3. 将新元素插入至 index 处 elementData[index] = element; size++; } private void rangeCheckForAdd(int index) { if (index > size || index < 0) //这里判断的index>size（保证数组的连续性），index小于0 throw new IndexOutOfBoundsException(outOfBoundsMsg(index)); }add(int index, E element)方法（在元素序列指定位置（
假设该位置合理）插入）的过程大概是下面这些- 检测数组是否有足够的空间(这里的实现和上面的)
- 将 index 及其之后的所有元素向后移一位
- 将新元素插入至 index 处.
将新元素插入至序列指定位置，需要先将该位置及其之后的元素都向后移动一位，为新元素腾出位置。这个操作的时间复杂度为
O(N)，频繁移动元素可能会导致效率问题，特别是集合中元素数量较多时。在日常开发中，若非所需，我们应当尽量避免在大集合中调用第二个插入方法。ArrayList的remove方法ArrayList支持两种删除元素的方式
1、remove(int index) 按照下标删除
public E remove(int index) { rangeCheck(index); //校验下标是否合法（如果index>size，旧抛出IndexOutOfBoundsException异常） modCount++;//修改list结构，就需要更新这个值 E oldValue = elementData(index); //直接在数组中查找这个值 int numMoved = size - index - 1;//这里计算所需要移动的数目 //如果这个值大于0 说明后续有元素需要左移(size=index+1) //如果是0说明被移除的对象就是最后一位元素(不需要移动别的元素) if (numMoved > 0) //索引index只有的所有元素左移一位 覆盖掉index位置上的元素 System.arraycopy(elementData, index+1, elementData, index, numMoved); //移动之后，原数组中size位置null elementData[--size] = null; // clear to let GC do its work //返回旧值 return oldValue; }//src:源数组 //srcPos:从源数组的srcPos位置处开始移动 //dest:目标数组 //desPos:源数组的srcPos位置处开始移动的元素，这些元素从目标数组的desPos处开始填充 //length:移动源数组的长度 public static native void arraycopy(Object src, int srcPos, Object dest, int destPos, int length); 删除过程如下图所示
2、remove(Object o) 按照元素删除，会删除和参数匹配的第一个元素
public boolean remove(Object o) { //如果元素是null 遍历数组移除第一个null if (o == null) { for (int index = 0; index < size; index++) if (elementData[index] == null) { //遍历找到第一个null元素的下标 调用下标移除元素的方法 fastRemove(index); return true; } } else { //找到元素对应的下标 调用下标移除元素的方法 for (int index = 0; index < size; index++) if (o.equals(elementData[index])) { fastRemove(index); return true; } } return false; } //按照下标移除元素（通过数组元素的位置移动来达到删除的效果） private void fastRemove(int index) { modCount++; int numMoved = size - index - 1; if (numMoved > 0) System.arraycopy(elementData, index+1, elementData, index, numMoved); elementData[--size] = null; // clear to let GC do its work }ArrayList的其他方法
ensureCapacity方法
最好在 add 大量元素之前用 ensureCapacity 方法，以减少增量从新分配的次数
public void ensureCapacity(int minCapacity) { int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA) // any size if not default element table ? 0 // larger than default for default empty table. It's already // supposed to be at default size. : DEFAULT_CAPACITY; if (minCapacity > minExpand) { ensureExplicitCapacity(minCapacity); } }ArrayList总结
（1）
ArrayList是一种变长的集合类，基于定长数组实现，使用默认构造方法初始化出来的容量是10（1.7之后都是延迟初始化，即第一次调用add方法添加元素的时候才将elementData容量初始化为10）。（2）
ArrayList允许空值和重复元素，当往 ArrayList 中添加的元素数量大于其底层数组容量时，其会通过扩容机制重新生成一个更大的数组。ArrayList扩容的长度是原长度的1.5倍（3）由于
ArrayList底层基于数组实现，所以其可以保证在O(1)复杂度下完成随机查找操作。（4）
ArrayList是非线程安全类，并发环境下，多个线程同时操作 ArrayList，会引发不可预知的异常或错误。（5）顺序添加很方便
（6）删除和插入需要复制数组，性能差（可以使用LinkindList）
（7）Integer.MAX_VALUE - 8 ：主要是考虑到不同的JVM,有的JVM会在加入一些数据头,当扩容后的容量大于MAX_ARRAY_SIZE,我们会去比较最小需要容量和MAX_ARRAY_SIZE做比较,如果比它大, 只能取Integer.MAX_VALUE,否则是Integer.MAX_VALUE -8。 这个是从jdk1.7开始才有的
-
-
HashMap 的创建，put原理，和HashTable的区别，resize的原理，currentHashMap线程安全的具体实现，分段锁
-
HashMap和HashTable在1.7版本之后的区别，针对创建时和put时处理的方式不同（红黑树，CAS、ABA处理）
-
各种IO交互（AIO/ NIO/ BIO）
-
==与equals
-
String和Stringbuffer和Stringbuilder的区别
二、 JVM相关
（bookname：深入理解java虚拟机）
-
jvm分区
-
java文件加载到gc全流程，双亲委派
-
fullGC触发条件
-
内存分代逻辑
-
gc收集算法（标记计数算法，可达性算法）gc清理逻辑
-
G1/CMS收集器
-
堆栈溢出原因，处理
-
内存分配和回收策略
-
虚拟机监控和故障处理工具
-
jvm调优
-
web容器加载器架构实现（tomcat，jetty……）
三、多线程
-
线程池的创建有几种方式,队列，异常处理
-
submit和excute使用的区别，怎样避免死锁
-
线程的锁机制（lock和synchronized）原子类，锁，同步锁，自旋锁，CAS
-
线程调度相关
-
线程安全，锁优化
四、数据库
-
mysql中innodb myisam 两种引擎区别，是否支持事物，索引实现（B+，Hash）复合索引/二叉树
-
数据库索引，所有优缺点 最左前缀原则
-
InnoDB聚集索引
-
为什么用B+树，减少io，一颗B+树的节点大小为多大
-
为什么一个节点为1页
-
group by和order by
-
数据库调优
-
大量数据下分库分表处理
-
跨多数据库查询
-
cap，CAP即，一致性(Consistency)， 可用性(Availability)， 分区容忍性(Partition tolerance)；
-
redis有什么优点（单线程，分布式，持久化，事务，原子性）
-
redis持久化，分布式锁，redis为什么快，原理？
-
redis的主从 、哨兵的实现原理
-
redis支持的数据操作类型，发布订阅，计数器
-
redis作为注册中心的优点，和zk的区别
-
缓存更新，缓存穿透，缓存雪崩
-
MQ，activeMQ，kafka相关
五、Spring框架相关
-
ioc实现原理
-
aop具体实现，动态代理
-
工厂bean和bean工厂
-
反射使用
-
注解实现
六、分布式
-
dubbo具体调用原理（消费者&服务者）
-
多注册中心的使用场景
-
负载均衡策略
-
注册中心的注册原理（zk和redis注册中心有什么区别）
-
网关，配置中心，限流熔断，入伍治理
目前遇到的问题是这些，欢迎各位看官留言补充。BX