Java 面试知识初步整理

    // hash 在 String 类中有定义，value 是 char 类型数组

    public int hashCode() {
        int h = hash;
        if (h == 0 && value.length > 0) {
            char val[] = value;

            for (int i = 0; i < value.length; i++) {
                h = 31 * h + val[i];
            }
            hash = h;
        }
        return h;
    }

1.10 package 的作用？

1）多层命名空间，解决命名冲突；

2）按功能对代码文件进行分门别类，有利于管理，一目了然清晰。

1.11 面向对象的特征和优点？

1、优点：开发效率高，鲁棒性好，可维护性高。

2、特点：抽象、继承、封装、多态。

1.12 byte的取值范围为什么是[-128, 127]？

[-127, 127] 的二进制补码表示为[11111111, 01111111]，-128的补码表示为10000000。

1.13 String、StringBuilder、StringBuffer的区别？

1、String是不可变类，线程安全，内部由final修饰的char数组组成，频繁拼接字符串会在内存存储大量不再使用的字符串，造成内存泄漏。

2、StringBuilder，线程不安全，可变类。

3、StringBuffer，线程安全，可变类。

1.14 finally 关键字何时执行，是否一定会被执行？

在 “try{}”中，return 执行之前执行，不一定，发生错误或者强行退出时不执行。

1.15 Java NIO 的原理是什么？

NIO 由Buffer、selector、channel 组成，用于解决多线程实现IO时存在的线程开销问题。NIO 首先在服务端创建Selector对象，客户端访问服务端的时候，会创建一个channel，服务端轮询处理所有的channel。

2. 集合

2.1 Voctor、ArrayList、LinkedList 之间的区别，容量如何扩充？

1、Voctor底层由数组组成，线程安全，扩容是2倍增长，查询快，增删慢；

2、ArrayList底层由数组组成，非线程安全，扩容为1.5倍增长，查询快，增删慢；

3、LinkedList底层由链表组成，增删快，查询慢。

2.2 HashMap 和 HashTable 的区别？

1、HashMap 的数据结构为数组+链表组成，非线程安全，关键字和值可以为空，初始size为16，增长因子为0.75，二倍增长；

2、HashTable 和 hashMap相似，线程安全，关键字和值不可为空，初始size为11，扩容：newsize = oldsize*2+1。

2.3 为什么 HashMap 的键值可以为 null，HashTable 不能为 null？

HashTable 通过 get() 获得 value 为 null 时，因为多线程的并发访问和修改值，导致无法判断 null 是被设置为空还是从该关键字不存在。而 Hash Map 是非线程安全的，通过 get() 获得的 value 为 null 或者 0 来判断。

2.4 描述下 HashMap 的 put() 操作？

1、根据关键字 key 获得 Entry 对象的 hash 码，判断该位置的是否为 null；为 null 的话，直接插入该值；

2、不为 null，遍历 Entry 对象所在的链表，如果不为空，将该位置的值更新，如果为空，插入链表的尾部；

3、如果不为空，且链表长度大于8，改为红黑树插入。

    public V put(K key, V value) {
        if (table == EMPTY_TABLE) {
            inflateTable(threshold);
        }
        if (key == null)
            return putForNullKey(value);
        int hash = hash(key);
        int i = indexFor(hash, table.length);
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }

        modCount++;
        addEntry(hash, key, value, i);
        return null;
    }

2.5 HashMap 怎么实现线程安全？

1、synchronizedMap()函数实现；

2、使用 HashTable；

3、分段锁：CurrentHashMap。

2.6 ConcurrentHashMap 底层原理？

Java 1.7版本是通过分段锁机制来实现的，ConcurrentHashMap 初始有16个分段锁Segment，后期不能再进行扩容的。每个分段锁Segment都类似于一个HashMap，继承了重入锁ReentrantLock，有了锁的功能，由数组和链表组成，当链表的长度大于8时，转化为红黑树。

Java 1.8版本时通过数组 + 红黑树 + CAS （compare and swap） + sychronized 机制组成，数组可以扩容。

    /** Implementation for put and putIfAbsent */
    final V putVal(K key, V value, boolean onlyIfAbsent) {
        if (key == null || value == null) throw new NullPointerException();
        int hash = spread(key.hashCode());
        int binCount = 0;
        for (Node<K,V>[] tab = table;;) {
            Node<K,V> f; int n, i, fh;
            if (tab == null || (n = tab.length) == 0)
                tab = initTable();
            else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
                if (casTabAt(tab, i, null,
                             new Node<K,V>(hash, key, value, null)))
                    break;                   // no lock when adding to empty bin
            }
            else if ((fh = f.hash) == MOVED)
                tab = helpTransfer(tab, f);
            else {
                V oldVal = null;
                synchronized (f) {
                    if (tabAt(tab, i) == f) {
                        if (fh >= 0) {
                            binCount = 1;
                            for (Node<K,V> e = f;; ++binCount) {
                                K ek;
                                if (e.hash == hash &&
                                    ((ek = e.key) == key ||
                                     (ek != null && key.equals(ek)))) {
                                    oldVal = e.val;
                                    if (!onlyIfAbsent)
                                        e.val = value;
                                    break;
                                }
                                Node<K,V> pred = e;
                                if ((e = e.next) == null) {
                                    pred.next = new Node<K,V>(hash, key,
                                                              value, null);
                                    break;
                                }
                            }
                        }
                        else if (f instanceof TreeBin) {
                            Node<K,V> p;
                            binCount = 2;
                            if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
                                                           value)) != null) {
                                oldVal = p.val;
                                if (!onlyIfAbsent)
                                    p.val = value;
                            }
                        }
                    }
                }
                if (binCount != 0) {
                    if (binCount >= TREEIFY_THRESHOLD)
                        treeifyBin(tab, i);
                    if (oldVal != null)
                        return oldVal;
                    break;
                }
            }
        }
        addCount(1L, binCount);
        return null;
    }

2.7 HashMap遍历的三种方法

方法1：使用 For-Each 迭代 entries；

Map<Integer, Integer> map = new HashMap<Integer, Integer>();
for(Map.Entry<Integer, Integer> entry : map.entrySet()){
	System.out.println("key = " + entry.getKey() + ", value = " + entry.getValue())
}

方法2 使用For-Each迭代keys和values：

Map<Integer, Integer> map = new HashMap<Integer, Integer>();
 
//iterating over keys only
for (Integer key : map.keySet()) {
	System.out.println("Key = " + key);
}
 
//iterating over values only
for (Integer value : map.values()) {
	System.out.println("Value = " + value);
}

方法3 使用Iterator迭代：

Map<Integer, Integer> map = new HashMap<Integer, Integer>();
Iterator<Map.Entry<Integer, Integer>> entries = map.entrySet().iterator();
while (entries.hasNext()) {
	Map.Entry<Integer, Integer> entry = entries.next();
	System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue());
}

2.8 HashMap 是怎么扩容的？为什么要再做一次 Hash 计算？多线程情况下会存在什么问题？

1、HashMap 的初始大小默认为16，加载因子为0.75，当HashMap 的元素个数/HashMap 大小等于加载因子，则容量扩展为原来的2倍；HashMap 的容量必须是2的幂，因为性能，通过限制 HashMap 的容量是一个2的幂数，定位 Entry 在新 Hash Map 的位置时，h & (length-1) 和 h % length 结果是一致的，Java的%、/操作比&慢10倍左右。

扩容的时候，当复制旧的 HashMap 到新的 HashMap 时，遇到哈希冲突时，采用头插法将冲突的 Entry 插入到链表中。

2、不同的键的的hashcode仅仅只能通过低位来区分，高位的信息没有被充分利用。极端情况就是：所有的hashCode低位全相等，而高位不相等，通过一个再 Hash 来减少哈希冲突。

3、采用队头插入的方式，导致了HashMap在“多线程环境下”的死循环问题。

    void resize(int newCapacity) {
        Entry[] oldTable = table;
        int oldCapacity = oldTable.length;
        if (oldCapacity == MAXIMUM_CAPACITY) {//最大容量为 1 << 30
            threshold = Integer.MAX_VALUE;
            return;
        }

        Entry[] newTable = new Entry[newCapacity];//新建一个新表
        boolean oldAltHashing = useAltHashing;
        useAltHashing |= sun.misc.VM.isBooted() &&
                (newCapacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);
        boolean rehash = oldAltHashing ^ useAltHashing;//是否再hash
        transfer(newTable, rehash);//完成旧表到新表的转移
        table = newTable;
        threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
    }

    void transfer(Entry[] newTable, boolean rehash) {
        int newCapacity = newTable.length;
        for (Entry<K,V> e : table) {//遍历同桶数组中的每一个桶
            while(null != e) {//顺序遍历某个桶的外挂链表
                Entry<K,V> next = e.next;//引用next
                if (rehash) {
                    e.hash = null == e.key ? 0 : hash(e.key);
                }
                int i = indexFor(e.hash, newCapacity);//找到新表的桶位置;原桶数组中的某个桶上的同一链表中的Entry此刻可能被分散到不同的桶中去了，有效的缓解了哈希冲突。
                e.next = newTable[i];//头插法插入新表中
                newTable[i] = e;
                e = next;
            }
        }
    }

3. Java虚拟机（JVM）

3.1 JVM 加载 class 文件的原理机制？

类加载机制：将后缀为.class文件加载到内存，经过加载、链接、初始化生成二进制可执行文件。

加载：将字节码读取到JVM中，并映射为JVM认可的数据结构。

链接：1）验证：检验是否符合JVM虚拟机规范；

2）准备：初始化静态变量为零值；

3）解析：将间接引用替换为直接引用。

初始化：执行类中定义的Java程序代码，静态变量初始化。

3.2 对象的内存布局？Java 虚拟机组成部分，哪些是线程私有？

线程私有的程序计数器、虚拟机栈、本地方法栈，线程共享的堆和方法区。

1、程序计数器：指向当前运行的程序；

2、虚拟机栈：存放局部变量表、方法栈帧等；

3、本地方法栈：存放本地方法；

4、堆：用于存放对象的实例；

5、方法区：虚拟机加载的类信息、常量、静态变量等；（运行时常量池：存放编译器生成的字面量和符号引用）。

3.3 new，对象的创建过程？

1、常量池中查找是否存在；

2、类加载；

3、内存分配；

4、初始化非静态变量为零值；

5、设置对象头；

6、执行非静态变量的Java程序代码。

3.4 如何判断对象是否存活？

1、引用计数法：每个对象拥有一个引用计数器，当对象被引用的时候，计数器+1，引用释放，计数器-1，存在循环引用的风险；

2、可达性分析算法：以 GC Roots 为起始点，向下进行搜索，搜索走过的路径称为引用链，当该对象不存在到达 GC Roots 时，表示该对象可以被回收；

3.5 垃圾收集算法有哪几个？

1、标记清除算法；

2、复制算法；

3、标记整理算法；

4、分代回收算法（详细介绍见3.6）。

3.6 内存分配与回收策略？

新生代内存分为：Eden、Survivor_from、Survivor_to，老年代为：Old；

新对象在 Eden 分配内存，对象有年龄，每次Eden区内存不够，执行一次新生代GC，对象的年龄增加一岁；新生代GC发生时，JVM会将 Eden 和 Survivor_from 中存活的对象，复制到 Survivor_to 内存中，然后将 Eden 和 Survivor_from 内存清空。

年龄达到16的送入老年代和大对象会直接进入老年代。

3.7 什么是 Java 内存模型，以及Java内存模型的作用？

Java 内存模型定义各个变量的访问规则，由 violate、final、sychronized 关键字实现原子性、可见性、有序性，以及 happen before 原则组成，happen before 原则：程序顺序规则、管程规则、violate规则、线程start()规则、线程join()规则、传递性规则。