据说这十道面试题，把百分之八十的程序员都淘汰了？不是吧，阿sir

想在面试、工做中脱颖而出？想在最短的时间内快速掌握 Java 的核心基础知识点？想要成为一位优秀的 Java工程师？本篇文章能助你一臂之力！正所谓万丈高楼平地起，只有把基础掌握的牢固，才能走的更远，面对不断更新的技术才能快速掌握，同时在面试、工做中也更能脱颖而出！

说明：如下全部答案均为我的的理解和网上的一些资料的整合

1.List 和 Set 的区别

另外本人整理了20年面试题大全，包含spring、并发、数据库、Redis、分布式、dubbo、JVM、微服务等方面总结，下图是部分截图，须要的话点这里点这里，暗号博客园。

List , Set 都是继承自 Collection 接口 List 特色：元素有放入顺序，元素可重复 。

Set 特色：元素无放入顺序，元素不可重复，重复元素会覆盖掉，（元素虽然无放入顺序，可是元素在set中的位置是有该元素的 HashCode 决定的，其位置实际上是固定的，加入Set 的 Object 必须定义 equals ()方法 ，另外list支持for循环，也就是经过下标来遍历，也能够用迭代器，可是set只能用迭代，由于他无序，没法用下标来取得想要的值。）

Set和List对比

• Set：检索元素效率低下，删除和插入效率高，插入和删除不会引发元素位置改变。
• List：和数组相似，List能够动态增加，查找元素效率高，插入删除元素效率低，由于会引发其余元素位置改变

2.HashSet 是如何保证不重复的

向 HashSet 中 add ()元素时，判断元素是否存在的依据，不只要比较hash值，同时还要结合 equles 方法比较。HashSet 中的 add ()方法会使用 HashMap 的 add ()方法。如下是 HashSet 部分源码：

private static final Object PRESENT = new Object(); private transient HashMap<E,Object> map; public HashSet() { map = new HashMap<>(); } public boolean add(E e) { return map.put(e, PRESENT)==null; }

HashMap 的 key 是惟一的，由上面的代码能够看出 HashSet 添加进去的值就是做为 HashMap 的key。因此不会重复（ HashMap 比较key是否相等是先比较 hashcode 在比较 equals ）。

3.HashMap 是线程安全的吗，为何不是线程安全的（最好画图说明多线程 环境下不安全）?

不是线程安全的；

若是有两个线程A和B，都进行插入数据，恰好这两条不一样的数据通过哈希计算后获得的哈希码是同样的，且该位置尚未其余的数据。因此这两个线程都会进入我在上面标记为1的代码中。假设一种状况，线程A经过if判断，该位置没有哈希冲突，进入了if语句，尚未进行数据插入，这时候 CPU 就把资源让给了线程B，线程A停在了if语句里面，线程B判断该位置没有哈希冲突（线程A的数据还没插入），也进入了if语句，线程B执行完后，轮到线程A执行，如今线程A直接在该位置插入而不用再判断。这时候，你会发现线程A把线程B插入的数据给覆盖了。发生了线程不安全状况。原本在 HashMap 中，发生哈希冲突是能够用链表法或者红黑树来解决的，可是在多线程中，可能就直接给覆盖了。

上面所说的是一个图来解释可能更加直观。以下面所示，两个线程在同一个位置添加数据，后面添加的数据就覆盖住了前面添加的。

若是上述插入是插入到链表上，如两个线程都在遍历到最后一个节点，都要在最后添加一个数据，那么后面添加数据的线程就会把前面添加的数据给覆盖住。则

在扩容的时候也可能会致使数据不一致，由于扩容是从一个数组拷贝到另一个数组。

4.HashMap 的扩容过程

当向容器添加元素的时候，会判断当前容器的元素个数，若是大于等于阈值(知道这个阈字怎么念吗？不念 fa 值，念 yu 值四声)—即当前数组的长度乘以加载因子的值的时候，就要自动扩容啦。

扩容( resize )就是从新计算容量，向 HashMap 对象里不停的添加元素，而 HashMap 对象内部的数组没法装载更多的元素时，对象就须要扩大数组的长度，以便能装入更多的元素。固然 Java 里的数组是没法自动扩容的，方法是使用一个新的数组代替已有的容量小的数组，就像咱们用一个小桶装水，若是想装更多的水，就得换大水桶。

HashMap hashMap=new HashMap(cap);

cap =3， hashMap 的容量为4；
cap =4， hashMap 的容量为4；

cap =5， hashMap 的容量为8；
cap =9， hashMap 的容量为16；
若是 cap 是2的n次方，则容量为 cap ，不然为大于 cap 的第一个2的n次方的数。

5.HashMap 1.7 与 1.8 的 区别，说明 1.8 作了哪些优化，如何优化的？

HashMap结构图

在 JDK1.7 及以前的版本中， HashMap 又叫散列链表：基于一个数组以及多个链表的实现，hash值冲突的时候，就将对应节点以链表的形式存储。

JDK1.8 中，当同一个hash值（ Table 上元素）的链表节点数不小于8时，将再也不以单链表的形式存储了，会被调整成一颗红黑树。这就是 JDK7 与 JDK8 中 HashMap 实现的最大区别。
其下基于 JDK1.7.0_80 与 JDK1.8.0_66 作的分析

JDK1.7中

使用一个 Entry 数组来存储数据，用key的 hashcode 取模来决定key会被放到数组里的位置，若是 hashcode 相同，或者 hashcode 取模后的结果相同（ hash collision ），那么这些 key 会被定位到 Entry 数组的同一个格子里，这些 key 会造成一个链表。

在 hashcode 特别差的状况下，比方说全部key的 hashcode 都相同，这个链表可能会很长，那么 put/get 操做均可能须要遍历这个链表，也就是说时间复杂度在最差状况下会退化到 O(n)。

JDK1.8中

使用一个 Node 数组来存储数据，但这个 Node 多是链表结构，也多是红黑树结构

• 若是插入的 key 的 hashcode 相同，那么这些key也会被定位到 Node 数组的同一个格子里。
• 若是同一个格子里的key不超过8个，使用链表结构存储。
• 若是超过了8个，那么会调用 treeifyBin 函数，将链表转换为红黑树。

那么即便 hashcode 彻底相同，因为红黑树的特色，查找某个特定元素，也只须要O(log n)的开销

也就是说put/get的操做的时间复杂度最差只有 O(log n)

听起来挺不错，可是真正想要利用 JDK1.8 的好处，有一个限制：

key的对象，必须正确的实现了 Compare 接口

若是没有实现 Compare 接口，或者实现得不正确（比方说全部 Compare 方法都返回0）

那 JDK1.8 的 HashMap 其实仍是慢于 JDK1.7 的

简单的测试数据以下：
向 HashMap 中 put/get 1w 条 hashcode 相同的对象
JDK1.7: put 0.26s ， get 0.55s
JDK1.8 （未实现 Compare 接口）： put 0.92s ， get 2.1s
可是若是正确的实现了 Compare 接口，那么 JDK1.8 中的 HashMap 的性能有巨大提高，此次 put/get 100W条hashcode 相同的对象
JDK1.8 （正确实现 Compare 接口，）： put/get 大概开销都在320 ms 左右

6.final finally finalize

• final能够修饰类、变量、方法，修饰类表示该类不能被继承、修饰方法表示该方法不能被重写、修饰变量表示该变量是一个常量不能被从新赋值。
• finally通常做用在try-catch代码块中，在处理异常的时候，一般咱们将必定要执行的代码方法finally代码块中，表示无论是否出现异常，该代码块都会执行，通常用来存放一些关闭资源的代码。
• finalize是一个方法，属于Object类的一个方法，而Object类是全部类的父类，该方法通常由垃圾回收器来调用，当咱们调用 System.gc() 方法的时候，由垃圾回收器调用finalize()，回收垃圾，一个对象是否可回收的最后判断。

7.Java获取反射的三种方法

1.经过new对象实现反射机制
2.经过路径实现反射机制
3.经过类名实现反射机制

public class Student { private int id; String name; protected boolean sex; public float score; }

public class Get { //获取反射机制三种方式 public static void main(String[] args) throws ClassNotFoundException { //方式一(经过创建对象) Student stu = new Student(); Class classobj1 = stu.getClass(); System.out.println(classobj1.getName()); //方式二（所在经过路径-相对路径） Class classobj2 = Class.forName("fanshe.Student"); System.out.println(classobj2.getName()); //方式三（经过类名） Class classobj3 = Student.class; System.out.println(classobj3.getName()); } }

8.Java反射机制

Java 反射机制是在运行状态中，对于任意一个类，都可以得到这个类的全部属性和方法，对于任意一个对象都可以调用它的任意一个属性和方法。这种在运行时动态的获取信息以及动态调用对象的方法的功能称为 Java 的反射机制。

Class 类与 java.lang.reflect 类库一块儿对反射的概念进行了支持，该类库包含了Field,Method,Constructor 类 (每一个类都实现了 Member 接口)。这些类型的对象时由 JVM 在运行时建立的，用以表示未知类里对应的成员。

这样你就可使用 Constructor 建立新的对象，用 get() 和 set() 方法读取和修改与 Field 对象关联的字段，用invoke() 方法调用与 Method 对象关联的方法。另外，还能够调用 getFields() getMethods() 和
getConstructors() 等很便利的方法，以返回表示字段，方法，以及构造器的对象的数组。这样匿名对象的信息就能在运行时被彻底肯定下来，而在编译时不须要知道任何事情。

import java.lang.reflect.Constructor; public class ReflectTest { public static void main(String[] args) throws Exception { Class clazz = null; clazz = Class.forName("com.jas.reflect.Fruit"); Constructor<Fruit> constructor1 = clazz.getConstructor(); Constructor<Fruit> constructor2 = clazz.getConstructor(String.class); Fruit fruit1 = constructor1.newInstance(); Fruit fruit2 = constructor2.newInstance("Apple"); } } class Fruit{ public Fruit(){ System.out.println("无参构造器 Run..........."); } public Fruit(String type){ System.out.println("有参构造器 Run..........." + type); } }

运行结果： 无参构造器 Run………… 有参构造器 Run…………Apple

9.数组在内存中如何分配

对于 Java 数组的初始化，有如下两种方式，这也是面试中常常考到的经典题目：
静态初始化：初始化时由程序员显式指定每一个数组元素的初始值，由系统决定数组长度，如：

//只是指定初始值，并无指定数组的长度，可是系统为自动决定该数组的长度为4 String[] computers = {"Dell", "Lenovo", "Apple", "Acer"}; //① //只是指定初始值，并无指定数组的长度，可是系统为自动决定该数组的长度为3 String[] names = new String[]{"多啦A梦", "大雄", "静香"}; //②

动态初始化：初始化时由程序员显示的指定数组的长度，由系统为数据每一个元素分配初始值，如：

//只是指定了数组的长度，并无显示的为数组指定初始值，可是系统会默认给数组数组元素分配初始值为null String[] cars = new String[4]; //③

由于 Java 数组变量是引用类型的变量，因此上述几行初始化语句执行后，三个数组在内存中的分配状况以下图所示：

由上图可知，静态初始化方式，程序员虽然没有指定数组长度，可是系统已经自动帮咱们给分配了，而动态初始化方式，程序员虽然没有显示的指定初始化值，可是由于 Java 数组是引用类型的变量，因此系统也为每一个元素分配了初始化值 null ，固然不一样类型的初始化值也是不同的，假设是基本类型int类型，那么为系统分配的初始化值，也是对应的默认值0。

10.Cloneable 接口实现原理

Cloneable接口是Java开发中经常使用的一个接口， 它的做用是使一个类的实例可以将自身拷贝到另外一个新的实例中，注意，这里所说的“拷贝”拷的是对象实例，而不是类的定义，进一步说，拷贝的是一个类的实例中各字段的值。

在开发过程当中，拷贝实例是常见的一种操做，若是一个类中的字段较多，而咱们又采用在客户端中逐字段复制的方法进行拷贝操做的话，将不可避免的形成客户端代码繁杂冗长，并且也没法对类中的私有成员进行复制，而若是让须要具有拷贝功能的类实现Cloneable接口，并重写clone()方法，就能够经过调用clone()方法的方式简洁地实现实例拷贝功能

深拷贝(深复制)和浅拷贝(浅复制)是两个比较通用的概念，尤为在C++语言中，若不弄懂，则会在delete的时候出问题，可是咱们在这幸亏用的是Java。虽然Java自动管理对象的回收，但对于深拷贝(深复制)和浅拷贝(浅复制)，咱们仍是要给予足够的重视，由于有时这两个概念每每会给咱们带来不小的困惑。

浅拷贝是指拷贝对象时仅仅拷贝对象自己（包括对象中的基本变量），而不拷贝对象包含的引用指向的对象。深拷贝不只拷贝对象自己，并且拷贝对象包含的引用指向的全部对象。举例来讲更加清楚：对象 A1 中包含对 B1 的引用， B1 中包含对 C1 的引用。浅拷贝 A1 获得 A2 ， A2 中依然包含对 B1 的引用， B1 中依然包含对 C1 的引用。深拷贝则是对浅拷贝的递归，深拷贝 A1 获得 A2 ， A2 中包含对 B2 （ B1 的 copy ）的引用， B2 中包含对 C2 （ C1 的 copy ）的引用。

若不对clone()方法进行改写，则调用此方法获得的对象即为浅拷贝

大厂面试总结

互联网大厂比较喜欢的人才特色：对技术有热情，强硬的技术基础实力；主动，善于团队协做，善于总结思考。技术基础以及的问题多看看书准备，不懂的直接说不懂不要紧的；在项目细节上多把关一下，根据项目有针对性的谈本身的技术亮点，能表达清楚，能够引导面试官来问你比较擅长的技术问题。

另外本人整理收藏了20年多家公司面试知识点整理 以及各类知识点整理 下面有部分截图 想要资料的话：【点击这里暗号博客园】