JAVA高级-面试题总结

Posted on 2018-12-10 22:30  Mr.ning  阅读(370)  评论(0)  编辑  收藏  举报

最近面试了一些公司，针对面试中遇到的问题在此记录，提升自己，造福大家

以下所有java源码相关展示均为jdk1.8版本中内容

一、java源码相关

  1.  ArrayList创建和add等各种api使用原理

    • ArrayList 是一种变长的集合类，基于定长数组实现。
    • ArrayList 允许空值和重复元素，当往 ArrayList 中添加的元素数量大于其底层数组容量时，其会通过扩容机制重新生成一个更大的数组。
    • ArrayList 是非线程安全类，并发环境下，多个线程同时操作 ArrayList，会引发不可预知的异常或错误。

    •  ArrayList创建源码

    1. 带有初始容量的构造方法  

      /** 
       * 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），
    //那么显然容量为10
          if (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)方法（在元素序列指定位置（假设该位置合理）插入）的过程大概是下面这些

      1. 检测数组是否有足够的空间(这里的实现和上面的)
      2. 将 index 及其之后的所有元素向后移一位
      3. 将新元素插入至 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开始才有的

  1. HashMap 的创建，put原理，和HashTable的区别，resize的原理，currentHashMap线程安全的具体实现，分段锁 

  2. HashMap和HashTable在1.7版本之后的区别，针对创建时和put时处理的方式不同（红黑树，CAS、ABA处理）

  3. 各种IO交互（AIO/ NIO/ BIO）

  4. ==与equals

  5. String和Stringbuffer和Stringbuilder的区别

二、 JVM相关

　　（bookname：深入理解java虚拟机）

  1. jvm分区

  2. java文件加载到gc全流程，双亲委派

  3. fullGC触发条件

  4. 内存分代逻辑

  5. gc收集算法（标记计数算法，可达性算法）gc清理逻辑

  6. G1/CMS收集器

  7. 堆栈溢出原因，处理

  8. 内存分配和回收策略

  9. 虚拟机监控和故障处理工具

  10. jvm调优

  11. web容器加载器架构实现（tomcat，jetty……）

三、多线程

  1. 线程池的创建有几种方式,队列，异常处理

  2. submit和excute使用的区别，怎样避免死锁

  3. 线程的锁机制（lock和synchronized）原子类，锁，同步锁，自旋锁，CAS

  4. 线程调度相关

  5. 线程安全，锁优化

四、数据库

  1. mysql中innodb myisam 两种引擎区别，是否支持事物，索引实现（B+，Hash）复合索引/二叉树

  2. 数据库索引，所有优缺点 最左前缀原则

  3. InnoDB聚集索引

  4. 为什么用B+树，减少io，一颗B+树的节点大小为多大

  5. 为什么一个节点为1页

  6. group by和order by

  7. 数据库调优

  8. 大量数据下分库分表处理

  9. 跨多数据库查询

  10. cap，CAP即，一致性(Consistency)， 可用性(Availability)， 分区容忍性(Partition tolerance)；

  11. redis有什么优点（单线程，分布式，持久化，事务，原子性）

  12. redis持久化，分布式锁，redis为什么快，原理？

  13. redis的主从 、哨兵的实现原理

  14. redis支持的数据操作类型，发布订阅，计数器

  15. redis作为注册中心的优点，和zk的区别

  16. 缓存更新，缓存穿透，缓存雪崩

  17. MQ，activeMQ，kafka相关

五、Spring框架相关

  1. ioc实现原理

  2. aop具体实现，动态代理

  3. 工厂bean和bean工厂

  4. 反射使用

  5. 注解实现

六、分布式

  1. dubbo具体调用原理（消费者&服务者）

  2. 多注册中心的使用场景

  3. 负载均衡策略

  4. 注册中心的注册原理（zk和redis注册中心有什么区别）

  5. 网关，配置中心，限流熔断，入伍治理

目前遇到的问题是这些，欢迎各位看官留言补充。BX