SE基础篇

1.java 面向对象的特征

|

封装 | 把对象的属性和行为（数据）结合为一个独立的整体，并尽可能隐藏对象的内部实现细节，就是把不想告诉或者不该告诉别人的东西隐藏起来，把可以告诉别人的公开，别人只能用我提供的功能实现需求，而不知道是如何实现的。增加安全性。 | | | | —- | —- | —- | —- | | 继承 | 子类继承父类的数据属性和行为，并能根据自己的需求扩展出新的行为，提高了代码的复用性 | | | |

多态 | 指允许不同的对象对同一消息做出相应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式（发送消息就是函数调用）。封装和继承几乎都是为多态而准备的，在执行期间判断引用对象的实际类型，根据其实际的类型调用其相应的方法。 | | |

2.请你说说面向对象的六大原则？

3.谈谈final、finally、finalize的区别

4.请你说说java内部类和静态内部类的区别

5.请你简单讲解一下java泛型。

泛型通配符： | 符号？，可以解决当具体类型不确定的时候，这个通配符就是 ?；当操作类型时，不需要使用类型的具体功能时，只使用Object类中的功能。那么可以用 ? 通配符来表未知类型。注意：？是类型的实参，而不是类型形参。 | | | 泛型上下边界： | 上边界，即传入的类型实参必须是指定类型的子类型。
下边界，即传入的类型实参必须是指定类型的基类型。 | | |

泛型方法： | 只有在public和返回值之间声明了“”的方法才是泛型方法，泛型类中的使用了泛型的成员方法并不是泛型方法。如果静态方法要使用泛型的话，必须将静态方法也定义成泛型方法 。 | | | 泛型的数组： | 官方文档有说明，不能创建一个明确的泛型类型的数组。但是使用通配符创建泛型数组是可以的。 | |

6.请讲一下java中的==，equals与hashCode的区别与联系

hashCode和equals的关系： | 如果两个对象相同（即用equals比较返回true），那么它们的hashCode值一定要相同；
如果两个对象的hashCode相同，它们的对象并不一定相同(即用equals比较返回false) | |

7.请你讲一下int与integer的区别

自动装箱：将基本数据类型重新转化为对象

自动拆箱：将对象重新转化为基本数据类型

| | |


自动装箱/拆箱原理 | java对于Integer与int的自动装箱与拆箱的设计，是一种模式：叫享元模式（flyweight）。加大对简单数字的重利用，Java定义在自动装箱时对于值从–128到127之间的值，它们被装箱为Integer对象后，会存在内存中被重用，始终只存在一个对象。而如果超过了从–128到127之间的值，被装箱后的Integer对象并不会被重用，即相当于每次装箱时都新建一个 Integer对象。 | |

8.java中重载与重写的区别

| 重写

9.请简要谈谈java的反射机制

|

概念 | 在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制 | | | —- | —- | —- | | 实例对象的三种表达方式 | 1、类名.class；2、对象名.getClass( )；3.Class.forName(全限定类名) | | | class类的动态加载 | Class.forName(类的全称);该方法不仅表示了类的类型，还代表了动态加载类。编译时刻加载类是静态加载、运行时刻加载类是动态加载类。 | | |

获取方法信息 | getMethods( )获取所有public修饰的方法信息；
getDeclaredMethods( )获取所有方法信息包括private修饰的方法信息； | | |

获取成员变量信息 | getFileds( )获取所有public修饰的成员变量；
getDeclaredFileds( )获取所有成员变量信息包括private修饰的成员变量信息； | | | 获取构造函数信息 | getDeclaredConsttuctors（）方法 | | | 方法的反射操作 | method.invoke(对象，参数列表)； | |

10.String、StringBuffer、StringBuilder三者之间的区别（必会）

11.接口和抽象类的区别是什么？（必会）

12.string常用的方法有哪些？（了解）

13. jdk1.8的新特性（高薪常问）

1）Lambda 表达式 ：允许把函数作为一个方法的参数。
2）方法引用 ：方法引用允许直接引用已有 Java 类或对象的方法或构造方法。比如：**System.out::println **
3）函数式接口：有且仅有一个抽象方法的接口叫做函数式接口，函数式接口可以被隐式转换为 Lambda 表达式。通常函数式接口上会添加@FunctionalInterface 注解。
4）接口允许定义默认方法和静态方法 。
5）Stream API：这种风格将要处理的元素集合看作一种流，流在管道中传输，并且可以在管道的节点上进行处理，比如筛选，排序，聚合等。
6）日期/时间类改进：
之前的 JDK 自带的日期处理类非常不方便，日期时间的创建、比较、调整、格式化、时间间隔等。 这些类都在 java.time 包下，LocalDate/LocalTime/LocalDateTime。
7）Optional 类 ：Optional 类是一个可以为 null 的容器对象。如果值存在则 isPresent()方法会返回 true，调用 get()方法会返回该对象。
8） Java8 Base64 实现 ：Java 8 内置了 Base64 编码的编码器和解码器。

14. Java的异常（必会）

Error： | 表示由JVM所侦测到的无法预期的错误，由于这是属于JVM层次的严重错误，导致JVM无法继续执行，因此，这是不可捕捉到的，无法采取任何恢复的操作，顶多只能显示错误信息。 | | | Exception： | 表示可恢复的例外，这是可捕捉到的。 | | | 运行时异常： | 都是RuntimeException类及其子类异常 | | | 非运行时异常 （编译异常）： | 是RuntimeException以外的异常 | | | 常见的RunTime异常： | 空指针引用异常 、类型强制转换异常、下标越界异常、算术运算异常等 | |

15.BIO、NIO、AIO 有什么区别？（高薪常问）

16.Threadlocal的原理（高薪常问）

ThreadLocal：为共享变量在每个线程中创建一个副本，每个线程都可以访问自己内部的副本变量。通过threadlocal保证线程的安全性。
其实在ThreadLocal类中有一个静态内部类ThreadLocalMap(其类似于Map)，用键值对的形式存储每一个线程的变量副本，ThreadLocalMap中元素的key为当前ThreadLocal对象，而value对应线程的变量副本。
ThreadLocal 本身并不存储值，它只是作为一个 key保存到ThreadLocalMap中，但是这里要注意的是它作为一个key用的是弱引用，因为没有强引用链，弱引用在GC的时候可能会被回收。这样就会在ThreadLocalMap中存在一些key为null的键值对（Entry）。因为key变成null了，我们是没法访问这些Entry的，但是这些Entry本身是不会被清除的。如果没有手动删除对应key就会导致这块内存即不会回收也无法访问，也就是内存泄漏。
使用完ThreadLocal之后，记得调用remove方法。 在不使用线程池的前提下，即使不调用remove方法，线程的”变量副本”也会被gc回收，即不会造成内存泄漏的情况。

17.同步锁、死锁、乐观锁、悲观锁 （高薪常问）

|

同步锁 | 指并发执行的多个线程，在同一时间内只允许一个线程访问共享数据。Java 中可以使用 synchronized 关键字来取得一个对象的同步锁。 | | | —- | —- | —- | | 死锁 | 多个线程同时被阻塞，它们中的一个或者全部都在等待某个资源被释放。 | | |

乐观锁 | 总是假设最好的情况，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号机制和CAS算法实现。适用于多读的应用类型。使用场景：数据库的write_conditio机制 | | |

悲观锁 | 总是假设最坏的情况，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会阻塞直到它拿到锁。使用场景：数据库的行锁，表锁等，读锁，写锁等。 | |

18.说一下 synchronized 底层实现原理？（高薪常问）

synchronized可以保证方法或者代码块在运行时，同一时刻只有一个方法可以进入到临界区，同时它还可以保证共享变量的内存可见性。
Java中每一个对象都可以作为锁，这是synchronized实现同步的基础：
· 普通同步方法，锁是当前实例对象
· 静态同步方法，锁是当前类的class对象
· 同步方法块，锁是括号里面的对象

19.synchronized 和 volatile 的区别是什么？（高薪常问）

20. synchronized 和 Lock的区别是什么？（高薪常问）

31.java中的设计模式-单例模式

1.单例模式
单例模式的五种实现方式?

• 饿汉式单例

实现：构造方法私有，提供一个静态的且被final修饰的成员变量，变量的值为私有构造创建出来的唯一实例，提供一个静态的公共方法，方法名一般为**getInstance()**,方法实现返回前面的静态变量。
三种可以破坏饿汉式单例方式：

  1. **反射破坏单例**

解决：在构造方法里做判断，如果成员变量 !=null 抛出异常

if(instance != null){
      throw new RuntimeException(".............");
}

  2. **反序列化破坏单例**

解决：写一个**readResolve()**方法，在方法里返回成员变量

public Object readResolve(){
    return instance;
}

  3. **Unsafe破坏单例**

无预防方案。
枚举饿汉式单例：
实现：

具体实现：
public enum Singleton{
    INSTANCE;
    public static Singleton getInsatance(){
        return INSTANCE;
    }
}
原理：
enum Sex{
    MALE,FEMALE;
}
final class Sex extends Enum<Sex>{
    public static final Sex MALE;
    public static final Sex FEMALE;
    private Sex(String name,int ordinal){
        super(name,ordinal);
    }
    static{
        MALE = new Sex{"MALE",0};
        FEMALE = new Sex{"FEMALE",1}
        $VALUES = values();
    }
}

注意：反射和反序列化都不能破坏枚举创建出来的单例模式，但是unsafe可以破坏。
懒汉式单例：
实现：

public class Singleton implements Serializable{
    private Singleton(){
        return INSTANCE;
    }
    private static Singleton INSTANCE = null;
    public static synchronized Singleton getInstance(){
        if(INSTANCE == null){
            INSTANCE = new Singleton();
        }
        return INSTANCE;
    }
}

注意：**getInstance()**方法必须加锁，否则在多线程环境下就会出现重复创建实例的现象，还有一个问题：只需要在第一次创建实例时，需要互斥保护，当对象创建完毕后，就不在需要锁了，目前的解决方案性能太低。
DCL（双检索）懒汉式单例：
实现：

public class Singleton implements Serializable{
    private Singleton(){
        return INSTANCE;
    }
    private static volatile Singleton INSTANCE = null;
    public static Singleton getInstance(){
        if(INSTANCE == null){
            synchronized(Singleton.class){
                if(INSTANCE == null){
                    INSTANCE = new Singleton();
                }
            }
        }
        return INSTANCE;
    }
}

注意：**volatile**的作用是解决共享变量的可见性问题和有序性问题。在这里主要是为了保证共享变量的有序性问题。volatile给**INSTANCE = 对象**添加了一个内存屏障，阻止底层CPU指令的重排序，保证先执行构造方法，然后给对象赋值。因为底层CPU指令出于优化的目的，有可能会对指令进行重新排序，导致先给对象赋值再执行构造方法，但是在多线程环境下这样做是有问题的，比如线程A给对象赋值，但还没有执行构造方法，但是线程B已经拿着这个半成品对象走了，最终出现BUG。

懒汉式单例-内部类
实现：

public class Singleton implements Serializable{
    private Singleton(){
        return INSTANCE;
    }
    private static class Holder{
        static Singleton INSTANCE = new Singleton{};
    }
    public static Singleton getInstance(){
        return Holder.INSTANCE;
    }
}

静态代码块的线程安全问题是由JVM来保证的，即有static关键字修饰的成员变量和方法，不需要考虑线程安全。
jdk哪些地方体现了单例模式？

1. Runtime的这个类是一个典型的饿汉式单例，

   public static Runtime getRuntime(){
   return currentRuntime;
   }

2. System类是一个典型的DCL懒汉式单例： ```java private static volatile Console cons;

public static Console console(){ Console c; if((c == cons) == null){ synchronized(System.class){ if((c == cons) == null){ cons = c = SharedSecrets.getJavaIOAccess().console(); } }
} return c; }

   3. **Collections集合类有很多懒汉式单例-内部类和饿汉式单例：empty开头的变量很多都是这种单例模式**
```java
懒汉单例-内部类：
private static class EmptyNavigableSet<E> extends UnmodifiableNavigableSet<E>
            implements Serializable {
            private static final long serialVersionUID = -6291252904449939134L;
            public EmptyNavigableSet() {
                super(new TreeSet<E>());
            }
            private Object readResolve(){ 
            return EMPTY_NAVIGABLE_SET; 
            }
        }
private static final NavigableSet<?> EMPTY_NAVIGABLE_SET =
                new EmptyNavigableSet<>();
反向比较器：
public static <T> Comparator<T> reverseOrder() {
        return (Comparator<T>) ReverseComparator.REVERSE_ORDER;
    }
    private static class ReverseComparator
        implements Comparator<Comparable<Object>>, Serializable {
        private static final long serialVersionUID = 7207038068494060240L;
        static final ReverseComparator REVERSE_ORDER
            = new ReverseComparator();
        public int compare(Comparable<Object> c1, Comparable<Object> c2) {
            return c2.compareTo(c1);
        }
        private Object readResolve() { return Collections.reverseOrder(); }
        @Override
        public Comparator<Comparable<Object>> reversed() {
            return Comparator.naturalOrder();
        }
    }
饿汉单例：
public static final Set EMPTY_SET = new EmptySet<>();
public static final List EMPTY_LIST = new EmptyList<>();
public static final Map EMPTY_MAP = new EmptyMap<>();

1. Comparators枚举饿汉式单例：

   枚举饿汉式单例：
   private Comparators() {
     throw new AssertionError("no instances");
   }
   enum NaturalOrderComparator implements Comparator<Comparable<Object>> {
     INSTANCE;
     @Override
     public int compare(Comparable<Object> c1, Comparable<Object> c2) {
         return c1.compareTo(c2);
     }
     @Override
     public Comparator<Comparable<Object>> reversed() {
         return Comparator.reverseOrder();
     }
   }

   多线程篇

   1.java的线程状态有哪些？

   
   新建（NEW）：线程对象创建的时刻；
   可运行（RUNNABLE）:线程状态调用**start()**方法；
   终结（TERMINATED）：线程把代码运行完毕时；
   阻塞（BLOCKED）:线程争抢锁失败时，进入这个状态；当线程获取锁成功时，就会进入可运行状态；
   等待（WAITING）：当线程获得锁之后，发现还需要一些条件才能继续执行，调用**wait()**方法进入该状态并且释放锁，当条件满足时调用**notify()**方法唤醒该线程重新争抢锁。注意：不调用notify方法，将一直不执行；
   有时限的等待（TIMED_WAITING）：第一种，获得锁后线程对象调用**wait(long time)**方法并加入时间的参数，进入睡眠状态；当时间到或者调**notify()**方法唤醒它，继续执行下去；第二种，调用**sleep(long time)**方法并加入时间参数，进入睡眠状态；当时间结束，继续执行，这种方式在睡眠期间无法被唤醒。

   2.java线程池的核心参数有哪些？工作流程是怎样的？

   核心参数：
   corePoolSize（核心线程数目）：最多保留的线程数
   maximumPoolSize（最大线程数目）：核心线程+救急线程
   keepAliveTime（生存时间）：针对救急线程
   unit（时间单位）：针对救急线程
   workQueue（阻塞队列）：阻塞队列
   threadFactory（线程工厂）：可以为线程创建时起个好的名字
   handler（拒绝策略）：
   AbortPolicy：直接抛出一个RejectedExcutionException的RuntimeException异常；（默认）
   DiscardPolicy：直接丢弃，不给任何通知；（不负责任，不可取）
   DiscardOldestPolicy：丢弃任务队列中的头节点。
   CallerRunPolicy：谁提交谁执行。
   自定义拒绝策略：实现RejectedExecutionHandler接口来实现自己的决绝策略（推荐）

线程池的工作流程：

1. 当一个任务通过submit或者execute方法提交到线程池的时候，如果当前池中线程数（包括闲置线程）小于corePoolSize，则创建一个新的线程执行该任务;
2. 如果当前线程池中线程数已经达到coolPoolSize，则将任务放入等待队列;
3. 如果任务队列已满，则任务无法入队列，此时如果当前线程池中线程数小于maxPoolSize，则创建一个临时线程（非核心线程）执行该任务。
4. 如果当前池中线程数已经等于maxPoolSize，此时无法执行该任务，根据拒绝执行策略处理。

注意：
当池中线程数大于corePoolSize，超过keepAliveTime时间的闲置线程会被回收掉。回收的是救急线程，核心线程一般是不会回收的。如果设置allowCoreThreadTimeOut(true)，则核心线程在闲置keepAliveTime时间后也会被回收。

并发场景：
场景一：并发任务小于等于核心任务数情况；
线程池初始化核心线程数为0（性能考虑，按需加载）；当线程池内线程数量未达到核心线程数时，如有新的任务加入，不用复用此时的空闲线程；
场景二：并发任务数大于核心线程数 ，且小于等于核心线程数+任务队列长度
当线程达到核心线程数且任务队列未满时，不会再创建新的线程对象；当全部执行完毕后，依旧会保留核心线程数
场景三：并发任务时，阻塞队列已满，且未达到最大线程数：
当并发任务数量超过核心线程数+任务队列，且小于最大线程数+任务队列时，线程池会主动创建新的线程；超过keepAliveTime设置的时间，超过核心线程的线程对象会被淘汰；
场景四：并发任务数量超过最大线程数+任务队列时的场景；
当并发任务数超过最大线程数+任务队列长度时，触发线程的拒绝策略；

3.创建线程有几种方式（必会）

1）继承Thread类并重写 run 方法创建线程，实现简单但不可以继承其他类。
2）实现Runnable接口并重写 run 方法。避免了单继承局限性，编程更加灵活，实现解耦。
3）实现 Callable接口并重写 call 方法，创建线程。可以获取线程执行结果的返回值，并且可以抛出异常。
4）使用线程池创建（使用java.util.concurrent.Executor接口）。

4.Runnable和Callable的区别？（必会）

5.如何启动一个新线程、调用start和run方法的区别？（必会）

6.线程相关的基本方法？（必会）

Join 等待其他线程终止 | 等待其他线程终止，在当前线程中调用一个线程的 join() 方 法，则当前线程转为阻塞状态，直到另一个线程结束，当前线程再由阻塞状态变为就绪状态，等待 cpu 的宠幸。 | | | 线程唤醒（notify） | Object 类中的 notify() 方法，唤醒在此对象监视器上等待的单个线程，如果存在多个线程则会选择唤醒其中一个线程，选择是任意的。notifyAll() ，唤醒再次监视器上等待的所有线程。 | |

7.wait()和sleep()的区别？（必会）

| | 是否需要捕获异常 | wait():不需要捕获异常； | sleep():需要捕获异常；** |

8.CAS原理

CAS：Compare And Swap 比较并交换，是硬件层面的原子操作
CAS的思想很简单：三个参数，一个当前内存值V、旧的预期值A、即将更新的值B，当且仅当旧的预期值A和内存值V相同时，将内存值修改为B并返回true，否则什么都不做，并返回false。如果CAS操作失败，通过自旋的方式等待并再次尝试，直到成功。
ABA问题
如果一个值原来是A，变成了B，然后又变成了A，那么在CAS检查的时候会发现没有改变，但是实质上它已经发生了改变，这就是所谓的ABA问题。对于ABA问题其解决方案是加上版本号，即在每个变量都加上一个版本号，每次改变时加1，即A —> B —> A，变成1A —> 2B —> 3A。
解决方案：AtomicStampedReference

集合篇

1.List 和 Map、Set 的区别（必会）

2.List 和 Map、Set 的实现类（必会）*

|

List（有序,可重复） | **ArrayList

| 优点: 底层数据结构是数组，查询快，增删慢。
缺点: 线程安全，效率低, 已给舍弃了 | | | | **LinkedList

| 优点: 底层数据结构是链表，查询慢，增删快。
缺点: 线程不安全，效率高 | | |

Set（无序，唯一） | HashSet | 底层数据结构是哈希表。(无序,唯一)
如何来保证元素唯一性?
依赖两个方法：hashCode()和equals() | | | |

**LinkedHashSet

** | 底层数据结构是链表和哈希表。(FIFO插入有序,唯一)
1.由链表保证元素有序
2.由哈希表保证元素唯一 | | | |

**TreeSet

** | 底层数据结构是红黑树。(唯一，有序)
1. 如何保证元素排序的呢?
自然排序；比较器排序
2.如何保证元素唯一性的呢?
依赖两个方法：hashCode()和equals() | | |

Map（双列数据集合） | HashMap | 基于 hash 表的 Map 接口实现，非线程安全，高效，支持 null 值和 null 键， 线程不安全 | | | | HashTable | 线程安全，低效，不支持 null 值和 null 键； | | | | LinkedHashMap | 线程不安全，是 HashMap 的一个子类，保存了记录的插入顺序； | | | | TreeMap | 能够把它保存的记录根据键排序，默认是键值的升序排序，线程不安全。 | |

3.HashMap和HashTable ConcurrentHashMap区别（高薪常问）*

4.HashMap的面试点*

底层数据结构，1.7与1.8有何不同？
1.7是数组+链表，1.8是数组+（链表（变量node）|红黑树（treenode））
桶下标是对元素计算哈希值对对度取模运算，比如当前数组长度为16，哈希值为97，索引下标为1，引入哈希表就是为了提高查询效率。
当元素个数超过数组长度的4/3，数组就会扩容，长度是原来的两倍。扩容之后也会减少链表的长度。注意：当n个元素的哈希值一样，就算扩容他们的链表长度还是不会减少。

为何要用红黄黑树，为何一上来不树化，树化阈值为何是8，何时会树化，何时会退化为链表？
红黑树主要是用来避免DOS攻击，防止链表超长时性能下降，树化应当是偶然情况：

  - **hash表的查找，更新的时间复杂度是O(1)，而红黑树的查找，更新的时间复杂度是O(**log₂n**)，Treenode占用空间也比普通Node的大，如非必要，尽量还是使用链表。**
  - **hash值如果足够随机，则在hash表内按泊松分布，在负载因子0.75的情况下，长度超过8的链表出现概率是0.00000006（亿分之六），选择8就是为了让树化的几率足够小**

树化的两个条件：链表长度超过树化阈值；数组容量大于等于64，链表长度是有可能超过8的。。
退化情况1：在扩容时如果拆分树时，树元素个数小于等于6则会退化为链表；
退化情况2：remove树节点时，若root、root.left、root.right、root.left.left有一个为null，也会退化为链表。注意：是在移除之前进行检查的。

索引如何计算？hashCode都有了，为何还要提供hash( )方法？数组容量为何是2的N次幂？

• 计算对象的hashCode( )，在进行调用HashMap的hash( )方法进行二次哈希，最后&(capacity-1)得到索引下标；注意：位与运算比普通取模运算效率更高，但是capacity必须是2的N次幂。
• 二次hash( )是为了综合高位数据，让哈希分布更为均匀；hash^hash>>>16
• 计算索引时，如果是2的N次幂可以使用位与运算代替取模，效率更高；扩容时hash(原始哈希值)&oldCap(旧数组长度)==0的元素留在原来的位置，否则新位置=旧位置+oldCap(旧数组长度)；
• 但以上三点都是为了配合容量为2的N次幂时的优化手段，例如HashTable的容量就不是2的N次幂，并不能说哪种设计更优，应该是设计者综合了各种因素，最终选择了使用2的N次幂作为容量。
  • 如果追求分布更加均匀，数组容量应该选择质数，如果追求性能数组容量就要选择2的N次幂。

介绍一下put方法流程，1.7与1.8有何不同？
put的流程：

1. HashMap是懒惰创建数组的，首次使用才创建数组；
2. 计算索引（桶下标）；
3. 如果桶下标还没人占用，创建Node占位返回；
4. 如果桶下标已经有人占用：
   1. 已经是TreeNode节点走红黑树的添加或更新逻辑；
   2. 是普通Ndoe节点，走链表的添加或更新逻辑，如果链表长度超过树化阈值，走树化逻辑；
5. 返回前检查容量是否超过阈值，一旦超过进行扩容。

注意：HashMap的扩容是在添加元素以后，才进行扩容的。
1.7与1.8的不同：

1. 链表插入节点时，1.7是头插法，1.8是尾插法；
2. 1.7是大于等于阈值且没有空位时才扩容，而1.8是大于阈值就扩容；
3. 1.8在扩容计算node索引时，会优化。

加载因子为何默认是0.75f？

1. 在空间占用与查询时间之间取得较好的权衡；
2. 大于这个值，空间节省了，但链表就会比较长会影响性能；
3. 小于这个值，冲突减少了，但扩容就会更频繁，空间占用多。

多线程下会有啥问题？

1. 1.7会出现扩容死链
2. 1.7和1.8都会出现数据错乱

key能否为null，作为key的对象有什么要求？

1. HashMap的key可以为null，但Map的其他实现则不然；
2. 作为key的对象，必须实现hashCode（让哈希分布更加均匀，增加查询效率）和equals（当key的哈希值一样时，使用equals比较对象的内容是否一样），并且key的内容不能修改（不可变）。

String对象的hashCode( )如何设计的，为啥每次乘的是31？
目标是达到均匀的散列效果，每个字符串的hashCode足够独特。

1. 字符串中的每个字符都可以表现为一个数字，称为Si，其中i的范围是0~n-1；
   • 散列公式为：
   • 
2. 31代入公式有较好的散列特性，并且31*h可以被优化为：
   1. 即32*h-h
   2. 即2的5次幂*h-h
   3. 即h<<5-h

      5.请简要谈谈ArrayList*

• 1.ArrayList是基于数组实现的，它的内部存储元素的数组为 elementData;elementData的声明为：transient Object[] elementData;查询快，增删慢；
• 2.ArrayList中EMPTYELEMENTDATA和DEFAULTCAPACITYEMPTY_ELEMENTDATA的使用；这两个常量，使用场景不同。前者是用在用户通过ArrayList(int initialCapacity)该构造方法直接指定初始容量为0时，后者是用户直接使用无参构造创建ArrayList时。
• 3.ArrayList默认容量为10。调用无参构造新建一个ArrayList时，它的elementData = DEFAULTCAPACITYEMPTYELEMENTDATA, 当第一次使用 add() 添加元素时，ArrayList的容量会为 10。
• 4.ArrayList的扩容计算为 newCapacity = oldCapacity + (oldCapacity >> 1);且扩容并非是无限制的，有内存限制，虚拟机限制。
• 5.ArrayList的toArray()方法和subList()方法，在源数据和子数据之间的区别；

• 6.注意扩容方法ensureCapacityInternal()。ArrayList在每次增加元素（可能是1个，也可能是一组）时，都要调用该方法来确保足够的容量。当容量不足以容纳当前的元素个数时，就设置新的容量为旧的容量的1.5倍加1，如果设置后的新容量还不够，则直接新容量设置为传入的参数（也就是所需的容量），而后用Arrays.copyof()方法将元素拷贝到新的数组。从中可以看出，当容量不够时，每次增加元素，都要将原来的元素拷贝到一个新的数组中，非常之耗时，也因此建议在事先能确定元素数量的情况下，才使用ArrayList，否则不建议使用。

  6.请简要谈谈LinkedList的底层实现*

  添加节点：

• 1.记录当前末尾节点，通过构造另外一个指向末尾节点的指针l

• 2.产生新的节点：注意的是由于是添加在链表的末尾，next是为null的
• 3.last指向新的节点
• 4.这里有个判断，我的理解是判断是否为第一个元素(当l==null时，表示链表中是没有节点的)， 那么就很好理解这个判断了，如果是第一节点，则使用first指向这个节点，若不是则当前节点的next指向新增的节点
• 5.size增加 例如，在上面提到的LinkedList[“A”,”B”,”C”]中添加元素“D”，过程大致如图所示

删除节点

• 1.获取到需要删除元素当前的值，指向它前一个节点的引用，以及指向它后一个节点的引用。
• 2.判断删除的是否为第一个节点，若是则first向后移动，若不是则将当前节点的前一个节点next指向当前节点的后一个节点
• 3.判断删除的是否为最后一个节点，若是则last向前移动，若不是则将当前节点的后一个节点的prev指向当前节点的前一个节点
• 4.将当前节点的值置为null
• 5.size减少并返回删除节点的值

  12.ArrayList与LinkedList的区别是什么？

  |
  | ArrayList | LinkedList | | —- | —- | —- | | 相同点 | 接口实现：都实现了List接口，都是线性列表的实现
  都是线程不安全的 | | |

不同点 | ArrayList内部是数组实现 | LinkedList是内部实现是双向链表结构 | | | ArrayList实现了RandomAccess可以支持随机访问 | LinkedList实现了Deque可以当做队列使用 | | | 新增、删除元素时ArrayList需要使用到拷贝原数组，查找元素时ArrayList支持随机元素访问 | 新增、删除元素时LinkedList只需要移动指针，查找元素时LinkedList只能一个节点的去遍历 |