面试复习-java基础

一、java基础

1、数据类型

一个字节等于8bit
基本数据类：boolean（1），byte（1），char（2），int（4），short（2），float（4），double（8），long（8）
封装类型：Boolean，Byte，Character，Integer，Short，Float，Double，Long

1.1 包装类型

Integer x = 2 // 装箱，调用了Integer.valueOf(2)
int y = 2 // 拆箱，调用了x.intValue()

1.2 缓存池

new Integer(123)与Integer.valueOf(123)的区别在于：前者每次都会创建一个新对象，而后者会使用缓存池中的对象，多次调用也会是同一个对象的引用，因此就有两个new Integer(x)出来的对象比较会是false，而两个Integer.valueOf()赋值的对象比较出来的结果会是true。
JDK1.8中缓存池常量范围-128~127
Integer的缓存上界默认是127，但是可以在jvm启动的时候，通过XX:AutoBoxCacheMax=参数来调整

2、字符串

String定义的字符串不可改变长度，jdk8中用char数组存储数据，该数组被final修饰，String不可变的好处：1、可以缓存hash值，常用语HashMap的key，不可变的特性使得hash值也不可变，因此只需要进行一次计算；2、StringPool存放创建过的String对象；3、安全性：作为网络连接参数；4、线程安全：不可变性具备线程安全，所以可以在多个线程中安全使用。

StringBuffer和StringBuilder可以改变字符串长度，StringBuffer是线程安全的，StringBuilder不是线程安全的。

new String(“abc”)的方式会创建两个字符串对象，前提是StringPool中没有该字符串对象，那么就会在堆中创建一个字符串对象，StringPool也会创建一个字符串对象，指向这个字符串字面量；该方式创建出来的对象用“==”比较的是两个对象地址，因此是false，而直接用String a = "abc"的方式会从常量池获取，因此创建出来的对象是同一个地址引用，String的intern()方法会把字符串放到StringPool中，之后返回这个字符串的引用。

String s1 = new String("aaa");
String s2 = new String("aaa");
System.out.println(s1 == s2);           // false
String s3 = s1.intern();
String s4 = s1.intern();
System.out.println(s3 == s4);           // true
String s5 = s2.intern();
System.out.println(s3 == s5);           // true

String s5 = "bbb";
String s6 = "bbb";
System.out.println(s5 == s6);  // true

jdk7之前,StringPool放在运行时常量池中，属于永久代，但是java7之后，被移到了堆中，因为永久代空间有限，大量使用字符串的场景会导致OOM。

3、集合

1）List以特定索引存储对象，可以有重复元素，Set不能存放重复元素，Map以键值对存放对象。

2）ArrayList和Vector都是用数组存数据，查询快，插入慢，Vector的方法有synchronized修饰，所以是线程安全，性能比ArrayList差，LinkedList用链表存数据，插入快，查询慢，可以用Collections.synchronizedList()方法转成线程安全的。每次插入的时候都会先进行扩容检验、所以要指定list的大小，不然默认会是10个大小。

3）List和Set继承Collection接口。常用的集合有List和Map。

4）快速失败和安全失败区别：针对迭代器而言，安全失败是基于对底层集合做拷贝，安全失败的迭代器不会抛出异常，而快速失败的迭代器会抛出ConcurrentModificationException异常，java.util包下的集合类都是快速失败的，java.util.concurrent包下的容器都是安全失败的。

3.1 List

1）Array和ArrayList
Array可以包含基本类型和对象类型，ArrayList只能是对象类型，Array的大小固定，ArrayList大小不固定，当处理固定大小的基本数据类型时，可以使用Array，操作会比ArrayList快，因为ArrayList需要自动装箱。ArrayList初始化的时候需要指定大小，不然扩容会变为原来的1.5倍，频繁扩容会影响性能，由于list中的数组元素并不会全部使用，因此会使用transient来修饰声明保存数据的数组不会被序列化，同时ArrayList使用writeObject()和readObject(0方法来控制数组中有元素填充的内容。
初始化一个线程安全的ArrayList方法：1、可以使用List list = new ArrayList<>(); List synList = Collections.synchronizedList(list);，2、也可以使用concurrent并发包下的CopyOnWriteArrayList，List list = new CopyOnWriteArrayList<>();。
CopyOnWriteArrayList是读写分离的，写操作在一个复制的数组上进行，读操作在原数组进行。写操作会加锁，写操作完成之后，会让原数组指向新的复制数组。适合读多写少的场景。缺陷：内存占用高；数据不一致，读写操作不能做到实时同步。

2）Vector：线程安全。扩容默认翻倍。
3）LinkedList：双向链表，可作队列。

3.2 Set

TreeSet：基于红黑树实现，有序操作。
HashSet：基于哈希表实现，支持快速查找，不支持有序操作。
LinkedHashSet：具有HashSet的查找效率，内部使用双向链表维护插入顺序。

3.3 Queue

1）LinkedList：双向队列。
2）PriorityQueue：基于堆结构实现，可以实现优先级队列。

3.3 map的分类和常见情况

四个实现类：HashMap，HashTable，LinkedHashMap，TreeMap。map以键值对存在，不允许键重复，但是值可以重复。

1）HashMap：允许键重复，不支持线程同步，但是可以用Collections.synchronizedMap方法使HashMap同步，或者使用ConcurrentHashMap（推荐使用）。有两个重要参数：容量和负载因子。默认容量是16，负载因子是0.75，当size>16*0.75时，就会发生扩容。put和get方法都会把key计算成hashcode值，该值通过与map存储空间的数组长度做取模运算，结果就是数组中的index下标，hashMap规定数组的长度为2的n次方，那么使用2的n次方-1做位运算结果与取模一样，但是效率高出许多。如果计算出的index已经有数据，那么就使用头插法在该位置生成链表，如果是get，那么就遍历链表，比较key和链表节点一致就返回。
遍历方式：

Iterator<Map.Entry<String, Integer>> entryIterator = map.entrySet().iterator();
        while (entryIterator.hasNext()) {
            Map.Entry<String, Integer> next = entryIterator.next();
            System.out.println("key=" + next.getKey() + " value=" + next.getValue());
        }

map.forEach((key,value)->{
    System.out.println("key=" + key + " value=" + value);
});

注意： 在高并发下，发生扩容，容易出现环形链表，如果访问一个不存在map中的key，该key的index恰好落在环形链表的数组上，那么就会出现死循环。
jdk8中当冲突hashCode的链表长度超过了阈值(默认为8)并且table的长度不小于64（否则扩容一次），链表就会转换为红黑树。
2）HashTable：和HashMap一样继承Dictionary类，支持线程同步，不允许空键，写入比HashMap慢。

3）LinkedHashMap：是HashMap的子类，保存了记录的插入顺序，因此可以获取对象的插入顺序，LinkedHashMap的遍历速度与容量无关，与实际数据有关，而HashMap的遍历速度和容量有关，因此，当HashMap容量很大，实际数据比较小，速度可能不如LinkedHashMap。

4）TreeMap：可以根据自定义的排序规则对键进行排序，因此，如果按照自然顺序或自定义顺序遍历键的时候，用TreeMap会比较好，所以有排序需求的话，用这个map会更好。

4、其他

4.1 计算小数问题

类似4.0-3-6的结果不是0.4，会出现很长的小数，这是由于二进制存储十进制的误差导致的，可以使用BigDecimal来处理这些需要精度的数字操作，new BigDecimal(String.class)，里面的入参必须是String类型才能正常计算，还可以通过 BigDecimal.setScale(小数位)来进行小数的截取

4.2 “==”与“equal”

“==”比较的是内存地址，如果是基本数据类型，就是比较值。“equal”需要重写hashCode()方法，因为不重写hashCode()，那么调用equal也会去比较两个对象的hashCode是否相等，而默认的hashCode()方法其实就是计算对象的内存地址，所以如果不重写hashCode，那么两个对象的内存地址肯定不一样，这就会导致equal比较出来的结果是false。
HashSet和HashMap的key是使用了hashCode()计算对象应该存储的位置，因此如果放入hash表的对象没有重写hashCode()方法，那么就会被当做两个不同的对象。
重写hashCode()的方法，
1、首先初始化一个整型变量，赋值为一个不为0的常数值，比如int result = 17
2、将result*31+成员变量，因为任何数乘以31都可以被jvm优化成(x<<5)-x的形式，移位和减法的操作比普通的乘法效率更高

@Override
public int hashCode() {
    int result = 17;
    result = 31 * result + i; // i是基本类型
    result = 31 * result + s.hashCode(); // s是封装类型或者其他类对象
    return result;
}

4.3 final，finally与finalize

1）final：final可以修饰变量，方法和类。修饰的变量，基本类型的值不可改变，对象类型指向的地址不可改变；方法不可以重写；类不可以继承。

2）finally是异常处理中，总是执行的部分。

3）finalize：是垃圾处理中回调的方法，调用回收对象的此方法，当该方法被系统调用，表示这个对象即将死亡，但是主动调用并不会触发死亡。

4.4 Synchronized，lock和volatile

1）synchronized：是java的关键字，用来修饰一个方法或者一个代码块的时候，能够保证线程安全。加锁顺序：无锁-偏向锁-轻量级锁（自旋锁，CAS）-重量级锁。 修饰静态方法和同步代码块的用法锁是类锁，修饰的成员方法，需要获取的是对象锁。

2）lock：是一个接口，lock发生异常时，如果没有unLock()方法，会造成死锁，因此需要在finally中释放锁，但是synchronized在发生异常会自动释放锁；lock可以让等待的线程响应中断，synchronized等待的线程会一直等待下去；Lock可以知道有没有成功获取锁，而synchronized不可以。

3）volatile：可以保证有序性和可见性。代码经过编译器之后，会重新排序，加入volatile，可以保证代码执行的有序；在翻译成汇编代码时，如果使用了volatile，那么代码会加入一个lock的前缀指令，防止读取旧值之后，其他线程对该值修改，保证读取的旧值和新值一致。

4.5 值传递与引用传递

java只有值传递，对象作为参数也不会改变指向的内存地址。
如果方法参数是以对象传入，那么改变该对象的成员变量等字段值，也会相应的改变原对象的字段值，但是如果把该对象赋值为其他对象，那么此时该方法的对象参数和调用时候的对象参数指针已经不是指向同一个了，比如下面这个mc对象在方法里面被赋予了新值，那么就和main方法中的mc不是同一个了，即使在test方法改变mc对象里面的成员字段值，也不会影响到main方法中的mc对象的成员字段值。

public static void main(String[] args) {
	MyClass mc = new MyClass("mc1");
	canChange(mc);
	cannotChange(mc);
}
public static void cannotChange(MyClass mc) {
	mc = new MyClass("newMc"); // 此处mc对象指针指向了新的MyClass对象。
}
public static void canChange(MyClass mc) {
	mc.setName("mc2"); // 这里就会改变外部mc对象的name字段值。
}

4.6 泛型

泛型可以确保正确类型的对象放入集合，防止运行时出现ClassCastException。不能把List传递给一个接收List