其他互联网大厂面试题
List , Set 都是继承自 Collection 接口
List 特点：元素有放入顺序，元素可重复 ，
Set 特点：元素无放入顺序，元素不可重复，重复元素会覆盖掉，（元素虽然无放入顺序，但是元素在set中的位置是有该元素的 HashCode 决定的，其位置其实是固定的，加入Set 的 Object 必须定义 equals ()方法 ，另外list 支持for循环，也就是通过下标来遍历，也可以用迭代器，但是set只能用迭代，因为他无序，无法用下标来取得想 要的值。） Set和List对比 Set：检索元素效率低下，删除和插入效率高，插入和删除不会引起元素位置改变。List：和数组类似，List可以动态增长，查找元素效率高，插入删除元素效率低，因为会引起其他元素位置改变。
向 HashSet 中 add ()元素时，判断元素是否存在的依据，不仅要比较hash值，同时还要结合 equles 方法比较。
HashSet 中的 add ()方法会使用 HashMap 的 add ()方法。以下是 HashSet 部分源码：
private static final Object PRESENT = new Object(); private transient HashMap map;
public HashSet() {
map = new HashMap<>();
}
public boolean add(E e) {
return map.put(e, PRESENT)==null;
}
HashMap 的 key 是唯一的，由上面的代码可以看出 HashSet 添加进去的值就是作为HashMap的key。所以不会
重复（HashMa比较key是否相等是先比较 hashcode 在比较 equals）。
不是线程安全的;
如果有两个线程A和B，都进行插入数据，刚好这两条不同的数据经过哈希计算后得到的哈希码是一样的，且该位置还有其他的数据。所以这两个线程都会进入我在 上面标记为1的代码中。假设一种情况，线程A通讨if断 ，该位置没有哈希冲突，进入了if语句，还没有进行数据插入，这时候 CPU 就把资源让给了线程B，线程A停在了if语句里面，线程B判断该位置没有哈希冲突（线程A的数据还没插入），也进入了if语句 ，线程B执行完后，轮到线程A执行，现在线程A直接在该位置插入而不用再判断。这时候，你会发现线程A把线程B插入的数据给覆盖了。发生了线程不安全情况。本来在 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次方的数。
在 JDK1.7 及之前的版本中，HashMap 又叫散列链表∶基于一个数组以及多个链表的实现，hash值冲突的时候，就将对应节点以链表的形式存储。
JDK1.8中，当同一个hash值（Table 上元素）的链表节点数不小于8时，将不再以单链表的形式存储了，会被调整成一颗红黑树。这就是 JDK7与 JDK8 中 HashMap 实现的最大区别。
其下基于JDK1.7.0_80与JDK1.8.0_66 做的分析JDK1.7中
K1.7中
使用一个 Entry 数组来存储数据，用key的 hashcode 取模来决定key会被放到数组里的位置，如果 hashcode 相同，或者 hashcode 取模后的结果相同（ hash co11ision ），那么这些key 会被定位到 Entry 数组的同一个格子里，这些key 会形成一个链表。
在 hashcode 特别差的情况下，比方说所有key的 hashcode 都相同，这个链表可能会很长，那么 put/get 操作都可能需要遍历这个链表，也就是说时间复杂度在最差情况下会退化到 o0（n）
JDK1.8中
使用一个 Node 数组来存储数据，但这个 Node 可能是链表结构，也可能是红黑树结构
● 如果插入的 key 的 hashcode 相同，那么这些key也会被定位到Node 数组的同一个格子里。● 如果同一个格子里的key不超过8个，使用链表结构存储。
● 如果超过了8个，那么会调用 treei fyBin 函数，将链表转换为红黑树。
那么即使 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 左右
● final可以修饰类、变量、方法，修饰类表示该类不能被继承、修饰方法表示该方法不能被重写、修饰变量表示该变量是一个常量不能被重新赋值。
● finally一般作用在try-catch代码块中，在处理异常的时候，通常我们将一定要执行的代码方法finally代码块中，表示不管是否出现异常，该代码块都会执行，一般用来存放一些关闭资源的代码。
● finalize是一个方法，属于Obiect类的一个方法，而Object类是所有类的父类，该方法—般由垃圾回收器来调用，当我们调用 System.gc（方法的时候，由垃圾回收器调用finalize（），回收垃圾，—个对象是否可回收的最后判断。
强引用只要引用存在，垃圾回收器永远不会回收
Object obj = new Object();.
User user=new User();
可直接通过obj取得对应的对象如 obj.eque1s（new objectO）;而这样 obj对象对后面 new object 的一个强引用，只有当 obj这个引用被释放之后，对象才会被释放掉，这也是我们经常所用到的编码形式。
软引用 非必须引用，内存溢出之前进行回收，可以通过以下代码实现
Object obj = new Object();
SoftReference<0bject> sf = new SoftReference这时候sf是对obj的一个软引用，通过sf.get（）方法可以取到这个对象，当然，当这个对象被标记为需要回收的对象时，则返回nul;软引用主要用户实现类似缓存的功能，在内存足够的情况下直接通过软引用取值，无需从繁忙的真实来源查询数据，提升速度;当内存不足时，自动删除这部分缓存数据，从真正的来源查询这些数据。
弱引用第二次垃圾回收时回收，可以通过如下代码实现
Object obj = new Object();
weakReference<0bject> wf = new weakReference弱引用是在第二次垃圾回收时回收，短时间内通过弱引用取对应的数据，，可以取到，当执行过第二次垃圾回收时，将返回null。弱引用主要用于监控对象是否已经被垃圾回收器标记为即将回收的垃圾，可以通过弱引用的isEnQueued 方法返回对象是否被垃圾回收器标记。
ThreadLocal 中有使用到弱引用，
public class ThreadLocal {static clasS ThreadLoca]Map {
static class Entry extends weakReference>{/** The value associated wi th this ThreadLoca1.*/object value;
Entry(ThreadLoca1 k, Object v) {
super(k);value = v;””//... 、了/7..... 3
虚引用 垃圾回收时回收，无法通过引用取到对象值，可以通过如下代码实现
0bject obj = new Object();
PhantomReference<0bject> pf = new PhantomReference<0bject>(obj);obj=null;
pf.get（）;//永远返回nu11
pf.isEnQueuedO）;//返回是否从内存中已经删除
虚引用是每次垃圾回收的时候都会被回收，通过虚引用的get方法永远获取到的数据为nul，因此也被成为幽灵引用。虚引用主要用于检测对象是否已经从内存中删除。
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());
}
}
Java 反射机制是在运行状态中，对于任意一个类，都能够获得这个类的所有属性和方法，对于任意个对象都能够调用它的任意一个属性和方法。这种在运行时动态的获取信息以及动态调用对象的方法的功能称为 Java 的反射机制。
Class类与java.lang.reflect类库一起对反射的概念进行了支持，该类库包含了Field，Method，Constructor 类 （每个类都实现了 Member 接口）。这些类型的对象时由VM在运行时创建的，用以表示未知类里对应的成员。
这样你就可以使用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 constructor1 = clazz.getConstructor();
Constructor 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