Java面試知識(shí)點(diǎn)（全）https://nanxiang.blog.csdn.net/article/details/130640392

Java基礎(chǔ)

語(yǔ)法基礎(chǔ)

面向?qū)ο?/h3>

封裝

利用抽象數(shù)據(jù)類型將數(shù)據(jù)和基于數(shù)據(jù)的操作封裝在一起，使其構(gòu)成一個(gè)不可分割的獨(dú)立實(shí)體。數(shù)據(jù)被保護(hù)在抽象數(shù)據(jù)類型的內(nèi)部，盡可能地隱藏內(nèi)部的細(xì)節(jié)，只保留一些對(duì)外接口使之與外部發(fā)生聯(lián)系。用戶無(wú)需知道對(duì)象內(nèi)部的細(xì)節(jié)，但可以通過(guò)對(duì)象對(duì)外提供的接口來(lái)訪問(wèn)該對(duì)象。

優(yōu)點(diǎn):減少耦合: 可以獨(dú)立地開發(fā)、測(cè)試、優(yōu)化、使用、理解和修改
減輕維護(hù)的負(fù)擔(dān): 可以更容易被程序員理解，并且在調(diào)試的時(shí)候可以不影響其他模塊
有效地調(diào)節(jié)性能: 可以通過(guò)剖析確定哪些模塊影響了系統(tǒng)的性能
提高軟件的可重用性
降低了構(gòu)建大型系統(tǒng)的風(fēng)險(xiǎn): 即使整個(gè)系統(tǒng)不可用，但是這些獨(dú)立的模塊卻有可能是可用
的以下 Person 類封裝 name、gender、age 等屬性，外界只能通過(guò) get() 方法獲取一個(gè) Person 對(duì)象的 name 屬性和 gender 屬性，而無(wú)法獲取 age 屬性，但是 age 屬性可以供 work() 方法使用。
注意到 gender 屬性使用 int 數(shù)據(jù)類型進(jìn)行存儲(chǔ)，封裝使得用戶注意不到這種實(shí)現(xiàn)細(xì)節(jié)。并且在需要修改 gender 屬性使用的數(shù)據(jù)類型時(shí)，也可以在不影響客戶端代碼的情況下進(jìn)行。

public class Person {

    private String name;
    private int gender;
    private int age;

    public String getName() {
        return name;
    }

    public String getGender() {
        return gender == 0 ? "man" : "woman";
    }

    public void work() {
        if (18 <= age && age <= 50) {
            System.out.println(name + " is working very hard!");
        } else {
            System.out.println(name + " can't work any more!");
        }
    }
}

繼承

繼承實(shí)現(xiàn)了 IS-A 關(guān)系，例如 Cat 和 Animal 就是一種 IS-A 關(guān)系，因此 Cat 可以繼承自 Animal，從而獲得 Animal 非 private 的屬性和方法。
繼承應(yīng)該遵循里氏替換原則，子類對(duì)象必須能夠替換掉所有父類對(duì)象。
Cat 可以當(dāng)做 Animal 來(lái)使用，也就是說(shuō)可以使用 Animal 引用 Cat 對(duì)象。父類引用指向子類對(duì)象稱為 向上轉(zhuǎn)型 。

多態(tài)

多態(tài)分為編譯時(shí)多態(tài)和運(yùn)行時(shí)多態(tài):

編譯時(shí)多態(tài)主要指方法的重載
運(yùn)行時(shí)多態(tài)指程序中定義的對(duì)象引用所指向的具體類型在運(yùn)行期間才確定

運(yùn)行時(shí)多態(tài)有三個(gè)條件:

繼承
覆蓋(重寫)
向上轉(zhuǎn)型

a = a + b 與 a += b 的區(qū)別+=

隱式的將加操作的結(jié)果類型強(qiáng)制轉(zhuǎn)換為持有結(jié)果的類型。如果兩個(gè)整型相加，如 byte、short 或者 int，首先會(huì)將它們提升到 int 類型，然后在執(zhí)行加法操作。

    byte a = 127;
    byte b = 127;
    b = a + b; // error : cannot convert from int to byte
    b += a; // ok

(因?yàn)?a+b 操作會(huì)將 a、b 提升為 int 類型，所以將 int 類型賦值給 byte 就會(huì)編譯出錯(cuò))

3*0.1 == 0.3 將會(huì)返回什么? true 還是 false?

false，因?yàn)橛行└↑c(diǎn)數(shù)不能完全精確的表示出來(lái)。

equals()和hashCode()的理解

• 為什么在重寫 equals 方法的時(shí)候需要重寫 hashCode 方法?
  因?yàn)橛袕?qiáng)制的規(guī)范指定需要同時(shí)重寫 hashcode 與 equals 是方法，許多容器類，如 HashMap、HashSet 都依賴于 hashcode 與 equals 的規(guī)定。
• 有沒(méi)有可能兩個(gè)不相等的對(duì)象有相同的 hashcode?
  有可能，兩個(gè)不相等的對(duì)象可能會(huì)有相同的 hashcode 值，這就是為什么在 hashmap 中會(huì)有沖突。相等 hashcode 值的規(guī)定只是說(shuō)如果兩個(gè)對(duì)象相等，必須有相同的hashcode 值，但是沒(méi)有關(guān)于不相等對(duì)象的任何規(guī)定。
• 兩個(gè)相同的對(duì)象會(huì)有不同的 hash code 嗎?
  不能，根據(jù) hash code 的規(guī)定，這是不可能的。

String、StringBuffer與StringBuilder的區(qū)別？

第一點(diǎn): 可變和適用范圍。String對(duì)象是不可變的，而StringBuffer和StringBuilder是可變字符序列。每次對(duì)String的操作相當(dāng)于生成一個(gè)新的String對(duì)象，而對(duì)StringBuffer和StringBuilder的操作是對(duì)對(duì)象本身的操作，而不會(huì)生成新的對(duì)象，所以對(duì)于頻繁改變內(nèi)容的字符串避免使用String，因?yàn)轭l繁的生成對(duì)象將會(huì)對(duì)系統(tǒng)性能產(chǎn)生影響。
第二點(diǎn): 線程安全。String由于有final修飾，是immutable的，安全性是簡(jiǎn)單而純粹的。StringBuilder和StringBuffer的區(qū)別在于StringBuilder不保證同步，也就是說(shuō)如果需要線程安全需要使用StringBuffer，不需要同步的StringBuilder效率更高。

接口與抽象類的區(qū)別？

一個(gè)子類只能繼承一個(gè)抽象類, 但能實(shí)現(xiàn)多個(gè)接口
抽象類可以有構(gòu)造方法, 接口沒(méi)有構(gòu)造方法
抽象類可以有普通成員變量, 接口沒(méi)有普通成員變量
抽象類和接口都可有靜態(tài)成員變量, 抽象類中靜態(tài)成員變量訪問(wèn)類型任意，接口只能public static final(默認(rèn))
抽象類可以沒(méi)有抽象方法, 抽象類可以有普通方法；接口在JDK8之前都是抽象方法，在JDK8可以有default方法，在JDK9中允許有私有普通方法
抽象類可以有靜態(tài)方法；接口在JDK8之前不能有靜態(tài)方法，在JDK8中可以有靜態(tài)方法，且只能被接口類直接調(diào)用（不能被實(shí)現(xiàn)類的對(duì)象調(diào)用）
抽象類中的方法可以是public、protected; 接口方法在JDK8之前只有public abstract，在JDK8可以有default方法，在JDK9中允許有private方法

注解的作用

注解是JDK1.5版本開始引入的一個(gè)特性，用于對(duì)代碼進(jìn)行說(shuō)明，可以對(duì)包、類、接口、字段、方法參數(shù)、局部變量等進(jìn)行注解。它主要的作用有以下四方面：
生成文檔，通過(guò)代碼里標(biāo)識(shí)的元數(shù)據(jù)生成javadoc文檔。
編譯檢查，通過(guò)代碼里標(biāo)識(shí)的元數(shù)據(jù)讓編譯器在編譯期間進(jìn)行檢查驗(yàn)證。
編譯時(shí)動(dòng)態(tài)處理，編譯時(shí)通過(guò)代碼里標(biāo)識(shí)的元數(shù)據(jù)動(dòng)態(tài)處理，例如動(dòng)態(tài)生成代碼。
運(yùn)行時(shí)動(dòng)態(tài)處理，運(yùn)行時(shí)通過(guò)代碼里標(biāo)識(shí)的元數(shù)據(jù)動(dòng)態(tài)處理，例如使用反射注入實(shí)例。

注解的常見分類

Java自帶的標(biāo)準(zhǔn)注解，包括@Override、@Deprecated和@SuppressWarnings，分別用于標(biāo)明重寫某個(gè)方法、標(biāo)明某個(gè)類或方法過(guò)時(shí)、標(biāo)明要忽略的警告，用這些注解標(biāo)明后編譯器就會(huì)進(jìn)行檢查
元注解，元注解是用于定義注解的注解，包括@Retention、@Target、@Inherited、@Documented
@Retention用于標(biāo)明注解被保留的階段
@Target用于標(biāo)明注解使用的范圍
@Inherited用于標(biāo)明注解可繼承
@Documented用于標(biāo)明是否生成javadoc文檔

集合

ArrayList和LinkedList

1.ArrayList是實(shí)現(xiàn)了基于數(shù)組的數(shù)據(jù)結(jié)構(gòu)，LinkedList基于鏈表的數(shù)據(jù)結(jié)構(gòu)。
2.對(duì)于隨機(jī)訪問(wèn)get和set，ArrayList覺(jué)得優(yōu)于LinkedList，因?yàn)長(zhǎng)inkedList要移動(dòng)指針。
3.對(duì)于新增和刪除操作add和remove，LinedList比較占優(yōu)勢(shì)，因?yàn)锳rrayList要移動(dòng)數(shù)據(jù)。
4.ArrayList默認(rèn)長(zhǎng)度10，擴(kuò)容為（原始*0.5）+1

List 元素是有序的、可重復(fù)
ArrayList、Vector默認(rèn)初始容量為10
Vector：線程安全，但速度慢
　　　　底層數(shù)據(jù)結(jié)構(gòu)是數(shù)組結(jié)構(gòu)
　　　 加載因子為1：即當(dāng) 元素個(gè)數(shù) 超過(guò) 容量長(zhǎng)度 時(shí)，進(jìn)行擴(kuò)容
　　　　擴(kuò)容增量：原容量的 1倍
　　　　如 Vector的容量為10，一次擴(kuò)容后是容量為20
ArrayList：線程不安全，查詢速度快
　　　　底層數(shù)據(jù)結(jié)構(gòu)是數(shù)組結(jié)構(gòu)
　　　　擴(kuò)容增量：原容量的 0.5倍+1
　　　　如 ArrayList的容量為10，一次擴(kuò)容后是容量為16

ArrayList和Vector使用了數(shù)組的實(shí)現(xiàn)，可以認(rèn)為ArrayList或者Vector封裝了對(duì)內(nèi)部數(shù)組的操作，比如向數(shù)組中添加，刪除，插入新的元素或者數(shù)據(jù)的擴(kuò)展和重定向。

LinkedList使用了循環(huán)雙向鏈表數(shù)據(jù)結(jié)構(gòu)。與基于數(shù)組ArrayList相比，這是兩種截然不同的實(shí)現(xiàn)技術(shù)，這也決定了它們將適用于完全不同的工作場(chǎng)景。

LinkedList鏈表由一系列表項(xiàng)連接而成。一個(gè)表項(xiàng)總是包含3個(gè)部分：元素內(nèi)容，前驅(qū)表和后驅(qū)表，如圖所示：

在下圖展示了一個(gè)包含3個(gè)元素的LinkedList的各個(gè)表項(xiàng)間的連接關(guān)系。在JDK的實(shí)現(xiàn)中，無(wú)論LikedList是否為空，鏈表內(nèi)部都有一個(gè)header表項(xiàng)，它既表示鏈表的開始，也表示鏈表的結(jié)尾。表項(xiàng)header的后驅(qū)表項(xiàng)便是鏈表中第一個(gè)元素，表項(xiàng)header的前驅(qū)表項(xiàng)便是鏈表中最后一個(gè)元素。

下面以增加和刪除元素為例比較ArrayList和LinkedList的不同之處：
增加元素到列表尾端：
只要ArrayList的當(dāng)前容量足夠大，add()操作的效率非常高的。只有當(dāng)ArrayList對(duì)容量的需求超出當(dāng)前數(shù)組大小時(shí)，才需要進(jìn)行擴(kuò)容。擴(kuò)容的過(guò)程中，會(huì)進(jìn)行大量的數(shù)組復(fù)制操作。而數(shù)組復(fù)制時(shí)，最終將調(diào)用System.arraycopy()方法，因此add()操作的效率還是相當(dāng)高的。

LinkeList由于使用了鏈表的結(jié)構(gòu)，因此不需要維護(hù)容量的大小。從這點(diǎn)上說(shuō)，它比ArrayList有一定的性能優(yōu)勢(shì)，然而，每次的元素增加都需要新建一個(gè)Entry對(duì)象，并進(jìn)行更多的賦值操作。在頻繁的系統(tǒng)調(diào)用中，對(duì)性能會(huì)產(chǎn)生一定的影響

增加元素到列表任意位置
除了提供元素到List的尾端，List接口還提供了在任意位置插入元素的方法：void add(int index,E element);
由于實(shí)現(xiàn)的不同，ArrayList和LinkedList在這個(gè)方法上存在一定的性能差異，由于ArrayList是基于數(shù)組實(shí)現(xiàn)的，而數(shù)組是一塊連續(xù)的內(nèi)存空間，如果在數(shù)組的任意位置插入元素，必然導(dǎo)致在該位置后的所有元素需要重新排列，因此，其效率相對(duì)會(huì)比較低。
可以看到每次插入操作，都會(huì)進(jìn)行一次數(shù)組復(fù)制。而這個(gè)操作在增加元素到List尾端的時(shí)候是不存在的，大量的數(shù)組重組操作會(huì)導(dǎo)致系統(tǒng)性能低下。并且插入元素在List中的位置越是靠前，數(shù)組重組的開銷也越大。
而LinkedList此時(shí)顯示了優(yōu)勢(shì)：
可見，對(duì)LinkedList來(lái)說(shuō)，在List的尾端插入數(shù)據(jù)與在任意位置插入數(shù)據(jù)是一樣的，不會(huì)因?yàn)椴迦氲奈恢每壳岸鴮?dǎo)致插入的方法性能降低。
刪除任意位置元素
對(duì)ArrayList來(lái)說(shuō)，remove()方法和add()方法是雷同的。在任意位置移除元素后，都要進(jìn)行數(shù)組的重組并且刪除的位置越靠前，數(shù)組重組時(shí)的開銷越大
在LinkedList的實(shí)現(xiàn)中，首先要通過(guò)循環(huán)找到要?jiǎng)h除的元素。如果要?jiǎng)h除的位置處于List的前半段，則從前往后找；若其位置處于后半段，則從后往前找。因此無(wú)論要?jiǎng)h除較為靠前或者靠后的元素都是非常高效的；但要移除List中間的元素卻幾乎要遍歷完半個(gè)List，在List擁有大量元素的情況下，效率很低
查詢：

LinkedList采用的是鏈表，

private static class Node<E> {
        E item;
        Node<E> next;
        Node<E> prev;
        Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }

每個(gè)節(jié)點(diǎn)都會(huì)保存前一個(gè)和后一個(gè)節(jié)點(diǎn)?，F(xiàn)在來(lái)看一下它是如何進(jìn)行查找的

/**
     * Returns the element at the specified position in this list.
     * @param index index of the element to return
     * @return the element at the specified position in this list
     * @throws IndexOutOfBoundsException {@inheritDoc}
     */
    public E get(int index) {
        checkElementIndex(index);
        return node(index).item;
    }

最后調(diào)用了node(int index)方法

/**
     * Returns the (non-null) Node at the specified element index.
     */
    Node<E> node(int index) {
        // assert isElementIndex(index);
        if (index < (size >> 1)) {
            Node<E> x = first;
            for (int i = 0; i < index; i++)
                x = x.next;
            return x;
        } else {
            Node<E> x = last;
            for (int i = size - 1; i > index; i--)
                x = x.prev;
            return x;
        }
    }

通過(guò)循環(huán)，把當(dāng)前節(jié)點(diǎn)指向上一個(gè)或者下一個(gè)，來(lái)找到索引位置的節(jié)點(diǎn)。
ArrayList采用的是數(shù)組，數(shù)組有明確的下表，所以查找很快。

/**
     * Returns the element at the specified position in this list.
     *
     * @param  index index of the element to return
     * @return the element at the specified position in this list
     * @throws IndexOutOfBoundsException {@inheritDoc}
     */
    public E get(int index) {
        rangeCheck(index);
        return elementData(index);
    }
@SuppressWarnings("unchecked")
    E elementData(int index) {
        return (E) elementData[index];
    }

HashMap 原理

HashMap是基于哈希表的Map接口的非同步實(shí)現(xiàn)。
此實(shí)現(xiàn)提供所有可選的映射操作，并允許使用null值和null鍵。
HashMap儲(chǔ)存的是鍵值對(duì)，HashMap很快。此類不保證映射的順序，特別是它不保證該順序恒久不變。
HashMap實(shí)際上是一個(gè)“鏈表散列”的數(shù)據(jù)結(jié)構(gòu)，即數(shù)組和鏈表的結(jié)合體。
數(shù)組：存儲(chǔ)區(qū)間連續(xù)，占用內(nèi)存嚴(yán)重，尋址容易，插入刪除困難；
鏈表：存儲(chǔ)區(qū)間離散，占用內(nèi)存比較寬松，尋址困難，插入刪除容易；
Hashmap綜合應(yīng)用了這兩種數(shù)據(jù)結(jié)構(gòu)，實(shí)現(xiàn)了尋址容易，插入刪除也容易。

hashMap的結(jié)構(gòu)示意圖如下：

HashMap的基本存儲(chǔ)原理以及存儲(chǔ)內(nèi)容的組成

基本原理：
先聲明一個(gè)下標(biāo)范圍比較大的數(shù)組來(lái)存儲(chǔ)元素。另外設(shè)計(jì)一個(gè)哈希函數(shù)（也叫做散列函數(shù)）來(lái)獲得每一個(gè)元素的Key（關(guān)鍵字）的函數(shù)值（即數(shù)組下標(biāo)，hash值）相對(duì)應(yīng)，數(shù)組存儲(chǔ)的元素是一個(gè)Entry類，這個(gè)類有三個(gè)數(shù)據(jù)域，key、value（鍵值對(duì)），next(指向下一個(gè)Entry)。

例如，
第一個(gè)鍵值對(duì)A進(jìn)來(lái)。通過(guò)計(jì)算其key的hash得到的index=0。記做:Entry[0] = A。
第二個(gè)鍵值對(duì)B，通過(guò)計(jì)算其index也等于0， HashMap會(huì)將B.next =A,Entry[0] =B,
第三個(gè)鍵值對(duì) C,index也等于0,那么C.next = B,Entry[0] = C；這樣我們發(fā)現(xiàn)index=0的地方事實(shí)上存取了A,B,C三個(gè)鍵值對(duì),它們通過(guò)next這個(gè)屬性鏈接在一起。我們可以將這個(gè)地方稱為桶。 對(duì)于不同的元素，可能計(jì)算出了相同的函數(shù)值，這樣就產(chǎn)生了“沖突”，這就需要解決沖突，“直接定址”與“解決沖突”是哈希表的兩大特點(diǎn)。

HashMap的工作原理以及存取方法過(guò)程

HashMap的工作原理 ：
HashMap是基于散列法（又稱哈希法hashing）的原理，使用put(key, value)存儲(chǔ)對(duì)象到HashMap中，使用get(key)從HashMap中獲取對(duì)象。當(dāng)我們給put()方法傳遞鍵和值時(shí)，我們先對(duì)鍵調(diào)用hashCode()方法，返回的hashCode用于找到bucket（桶）位置來(lái)儲(chǔ)存Entry對(duì)象?！盚ashMap是在bucket中儲(chǔ)存鍵對(duì)象和值對(duì)象，作為Map.Entry。并不是僅僅只在bucket中存儲(chǔ)值。

HashMap具體的存取過(guò)程如下：

put鍵值對(duì)的方法的過(guò)程是：
1、獲取key ；
2、通過(guò)hash函數(shù)得到hash值；
int hash=key.hashCode(); //獲取key的hashCode，這個(gè)值是一個(gè)固定的int值
3、得到桶號(hào)(一般都為hash值對(duì)桶數(shù)求模) ，也即數(shù)組下標(biāo)int index=hash%Entry[].length。//獲取數(shù)組下標(biāo)：key的hash值對(duì)Entry數(shù)組長(zhǎng)度進(jìn)行取余
4、 存放key和value在桶內(nèi)。
table[index]=Entry對(duì)象；

get值方法的過(guò)程是:
1、獲取key
2、通過(guò)hash函數(shù)得到hash值
int hash=key.hashCode();
3、得到桶號(hào)(一般都為hash值對(duì)桶數(shù)求模)
int index =hash%Entry[].length;
4、比較桶的內(nèi)部元素是否與key相等，若都不相等，則沒(méi)有找到。
5、取出相等的記錄的value。
HashMap中直接地址用hash函數(shù)生成；解決沖突，用比較函數(shù)解決。如果每個(gè)桶內(nèi)部只有一個(gè)元素，那么查找的時(shí)候只有一次比較。當(dāng)許多桶內(nèi)沒(méi)有值時(shí)，許多查詢就會(huì)更快了(指查不到的時(shí)候)。

Hash沖突解決

HashMap 采用一種所謂的“Hash 算法”來(lái)決定每個(gè)元素的存儲(chǔ)位置。當(dāng)程序執(zhí)行 map.put(String,Obect)方法 時(shí)，系統(tǒng)將調(diào)用String的 hashCode() 方法得到其 hashCode 值——每個(gè) Java 對(duì)象都有 hashCode() 方法，都可通過(guò)該方法獲得它的 hashCode 值。得到這個(gè)對(duì)象的 hashCode 值之后，系統(tǒng)會(huì)根據(jù)該 hashCode 值來(lái)決定該元素的存儲(chǔ)位置。源碼如下:

  public V put(K key, V value) {  
       if (key == null)  
           return putForNullKey(value);  
       int hash = hash(key.hashCode());  
       int i = indexFor(hash, table.length);  
       for (Entry<K,V> e = table[i]; e != null; e = e.next) {  
           Object k;  
           //判斷當(dāng)前確定的索引位置是否存在相同hashcode和相同key的元素，如果存在相同的hashcode和相同的key的元素，那么新值覆蓋原來(lái)的舊值，并返回舊值。  
           //如果存在相同的hashcode，那么他們確定的索引位置就相同，這時(shí)判斷他們的key是否相同，如果不相同，這時(shí)就是產(chǎn)生了hash沖突。  
           //Hash沖突后，那么HashMap的單個(gè)bucket里存儲(chǔ)的不是一個(gè) Entry，而是一個(gè) Entry 鏈。  
           //系統(tǒng)只能必須按順序遍歷每個(gè) Entry，直到找到想搜索的 Entry 為止——如果恰好要搜索的 Entry 位于該 Entry 鏈的最末端（該 Entry 是最早放入該 bucket 中），  
           //那系統(tǒng)必須循環(huán)到最后才能找到該元素。  
           if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {  
               V oldValue = e.value;  
               e.value = value;  
               return oldValue;  
           }  
       }  
       modCount++;  
       addEntry(hash, key, value, i);  
       return null;  
   } 

hashMap、hashTable、treeMap的區(qū)別

hashTable是線程安全的、hashMap不是線程安全的

HashMap通過(guò)hashcode對(duì)其內(nèi)容進(jìn)行快速查找，而 TreeMap中所有的元素都保持著某種固定的順序，如果你需要得到一個(gè)有序的結(jié)果你就應(yīng)該使用TreeMap（HashMap中元素的排列順序是不固定的）。
　　HashMap：適用于在Map中插入、刪除和定位元素。
　　Treemap：適用于按自然順序或自定義順序遍歷鍵(key)。
　　HashMap通常比TreeMap快一點(diǎn)(樹和哈希表的數(shù)據(jù)結(jié)構(gòu)使然)，建議多使用HashMap，在需要排序的Map時(shí)候才用TreeMap。

hashMap,hashTable, ConcurrentHashMap

HashTable
底層數(shù)組+鏈表實(shí)現(xiàn)，無(wú)論key還是value都不能為null，線程安全，實(shí)現(xiàn)線程安全的方式是在修改數(shù)據(jù)時(shí)鎖住整個(gè)HashTable，效率低，ConcurrentHashMap做了相關(guān)優(yōu)化
初始size為11，擴(kuò)容：newsize = olesize*2+1
計(jì)算index的方法：index = (hash & 0x7FFFFFFF) % tab.length

HashMap
底層數(shù)組+鏈表實(shí)現(xiàn)，可以存儲(chǔ)null鍵和null值，線程不安全
初始size為16，擴(kuò)容：newsize = oldsize*2，size一定為2的n次冪
擴(kuò)容針對(duì)整個(gè)Map，每次擴(kuò)容時(shí)，原來(lái)數(shù)組中的元素依次重新計(jì)算存放位置，并重新插入
插入元素后才判斷該不該擴(kuò)容，有可能無(wú)效擴(kuò)容（插入后如果擴(kuò)容，如果沒(méi)有再次插入，就會(huì)產(chǎn)生無(wú)效擴(kuò)容）
當(dāng)Map中元素總數(shù)超過(guò)Entry數(shù)組的75%，觸發(fā)擴(kuò)容操作，為了減少鏈表長(zhǎng)度，元素分配更均勻
計(jì)算index方法：index = hash & (tab.length – 1)

HashMap的初始值還要考慮加載因子:
哈希沖突：
若干Key的哈希值按數(shù)組大小取模后，如果落在同一個(gè)數(shù)組下標(biāo)上，將組成一條Entry鏈，對(duì)Key的查找需要遍歷Entry鏈上的每個(gè)元素執(zhí)行equals()比較。

加載因子：
為了降低哈希沖突的概率，默認(rèn)當(dāng)HashMap中的鍵值對(duì)達(dá)到數(shù)組大小的75%時(shí)，即會(huì)觸發(fā)擴(kuò)容。因此，如果預(yù)估容量是100，即需要設(shè)定100/0.75＝134的數(shù)組大小。

空間換時(shí)間：
如果希望加快Key查找的時(shí)間，還可以進(jìn)一步降低加載因子，加大初始大小，以降低哈希沖突的概率。

HashMap和Hashtable都是用hash算法來(lái)決定其元素的存儲(chǔ)，因此HashMap和Hashtable的hash表包含如下屬性：
??容量（capacity）：hash表中桶的數(shù)量
??初始化容量（initial capacity）：創(chuàng)建hash表時(shí)桶的數(shù)量，HashMap允許在構(gòu)造器中指定初始化容量
??尺寸（size）：當(dāng)前hash表中記錄的數(shù)量
??負(fù)載因子（load factor）：負(fù)載因子等于“size/capacity”。負(fù)載因子為0，表示空的hash表，0.5表示半滿的散列表，依此類推。輕負(fù)載的散列表具有沖突少、適宜插入與查詢的特點(diǎn)（但是使用Iterator迭代元素時(shí)比較慢）

除此之外，hash表里還有一個(gè)“負(fù)載極限”，“負(fù)載極限”是一個(gè)0～1的數(shù)值，“負(fù)載極限”決定了hash表的最大填滿程度。當(dāng)hash表中的負(fù)載因子達(dá)到指定的“負(fù)載極限”時(shí)，hash表會(huì)自動(dòng)成倍地增加容量（桶的數(shù)量），并將原有的對(duì)象重新分配，放入新的桶內(nèi)，這稱為rehashing。

HashMap和Hashtable的構(gòu)造器允許指定一個(gè)負(fù)載極限，HashMap和Hashtable默認(rèn)的“負(fù)載極限”為0.75，這表明當(dāng)該hash表的3/4已經(jīng)被填滿時(shí)，hash表會(huì)發(fā)生rehashing。

“負(fù)載極限”的默認(rèn)值（0.75）是時(shí)間和空間成本上的一種折中：
較高的“負(fù)載極限”可以降低hash表所占用的內(nèi)存空間，但會(huì)增加查詢數(shù)據(jù)的時(shí)間開銷，而查詢是最頻繁的操作（HashMap的get()與put()方法都要用到查詢）
較低的“負(fù)載極限”會(huì)提高查詢數(shù)據(jù)的性能，但會(huì)增加hash表所占用的內(nèi)存開銷
程序猿可以根據(jù)實(shí)際情況來(lái)調(diào)整“負(fù)載極限”值。

ConcurrentHashMap

底層采用分段的數(shù)組+鏈表實(shí)現(xiàn)，線程安全

通過(guò)把整個(gè)Map分為N個(gè)Segment，可以提供相同的線程安全，但是效率提升N倍，默認(rèn)提升16倍。(讀操作不加鎖，由于HashEntry的value變量是 volatile的，也能保證讀取到最新的值。)

Hashtable的synchronized是針對(duì)整張Hash表的，即每次鎖住整張表讓線程獨(dú)占，ConcurrentHashMap允許多個(gè)修改操作并發(fā)進(jìn)行，其關(guān)鍵在于使用了鎖分離技術(shù)

有些方法需要跨段，比如size()和containsValue()，它們可能需要鎖定整個(gè)表而而不僅僅是某個(gè)段，這需要按順序鎖定所有段，操作完畢后，又按順序釋放所有段的鎖

擴(kuò)容：段內(nèi)擴(kuò)容（段內(nèi)元素超過(guò)該段對(duì)應(yīng)Entry數(shù)組長(zhǎng)度的75%觸發(fā)擴(kuò)容，不會(huì)對(duì)整個(gè)Map進(jìn)行擴(kuò)容），插入前檢測(cè)需不需要擴(kuò)容，有效避免無(wú)效擴(kuò)容

Hashtable和HashMap都實(shí)現(xiàn)了Map接口，但是Hashtable的實(shí)現(xiàn)是基于Dictionary抽象類的。Java5提供了ConcurrentHashMap，它是HashTable的替代，比HashTable的擴(kuò)展性更好。

HashMap基于哈希思想，實(shí)現(xiàn)對(duì)數(shù)據(jù)的讀寫。當(dāng)我們將鍵值對(duì)傳遞給put()方法時(shí)，它調(diào)用鍵對(duì)象的hashCode()方法來(lái)計(jì)算hashcode，然后找到bucket位置來(lái)存儲(chǔ)值對(duì)象。當(dāng)獲取對(duì)象時(shí)，通過(guò)鍵對(duì)象的equals()方法找到正確的鍵值對(duì)，然后返回值對(duì)象。
HashMap使用鏈表來(lái)解決碰撞問(wèn)題，當(dāng)發(fā)生碰撞時(shí)，對(duì)象將會(huì)儲(chǔ)存在鏈表的下一個(gè)節(jié)點(diǎn)中。
HashMap在每個(gè)鏈表節(jié)點(diǎn)中儲(chǔ)存鍵值對(duì)對(duì)象。當(dāng)兩個(gè)不同的鍵對(duì)象的hashcode相同時(shí)，它們會(huì)儲(chǔ)存在同一個(gè)bucket位置的鏈表中，可通過(guò)鍵對(duì)象的equals()方法來(lái)找到鍵值對(duì)。如果鏈表大小超過(guò)閾值（TREEIFY_THRESHOLD,8），鏈表就會(huì)被改造為樹形結(jié)構(gòu)。

在HashMap中，null可以作為鍵，這樣的鍵只有一個(gè)，但可以有一個(gè)或多個(gè)鍵所對(duì)應(yīng)的值為null。當(dāng)get()方法返回null值時(shí)，即可以表示HashMap中沒(méi)有該key，也可以表示該key所對(duì)應(yīng)的value為null。因此，在HashMap中不能由get()方法來(lái)判斷HashMap中是否存在某個(gè)key，應(yīng)該用containsKey()方法來(lái)判斷。而在Hashtable中，無(wú)論是key還是value都不能為null。
Hashtable是線程安全的，它的方法是同步的，可以直接用在多線程環(huán)境中。而HashMap則不是線程安全的，在多線程環(huán)境中，需要手動(dòng)實(shí)現(xiàn)同步機(jī)制。

Hashtable與HashMap另一個(gè)區(qū)別是HashMap的迭代器（Iterator）是fail-fast迭代器，而Hashtable的enumerator迭代器不是fail-fast的。所以當(dāng)有其它線程改變了HashMap的結(jié)構(gòu)（增加或者移除元素），將會(huì)拋出ConcurrentModificationException，但迭代器本身的remove()方法移除元素則不會(huì)拋出ConcurrentModificationException異常。但這并不是一個(gè)一定發(fā)生的行為，要看JVM。

Object類中有幾個(gè)方法

protected Object clone()創(chuàng)建并返回此對(duì)象的一個(gè)副本。
boolean equals(Object obj)指示其他某個(gè)對(duì)象是否與此對(duì)象“相等”。
protected void finalize()當(dāng)垃圾回收器確定不存在對(duì)該對(duì)象的更多引用時(shí)，由對(duì)象的垃圾回收器調(diào)用此方法。
Class<?> getClass()返回此 Object 的運(yùn)行時(shí)類。
int hashCode()返回該對(duì)象的哈希碼值。
void notify()喚醒在此對(duì)象監(jiān)視器上等待的單個(gè)線程。
void notifyAll()喚醒在此對(duì)象監(jiān)視器上等待的所有線程。
String toString()返回該對(duì)象的字符串表示。
void wait()在其他線程調(diào)用此對(duì)象的 notify() 方法或 notifyAll() 方法前，導(dǎo)致當(dāng)前線程等待。
void wait(long timeout)在其他線程調(diào)用此對(duì)象的 notify() 方法或 notifyAll() 方法，或者超過(guò)指定的時(shí)間量前，導(dǎo)致當(dāng)前線程等待。
void wait(long timeout, int nanos)在其他線程調(diào)用此對(duì)象的 notify() 方法或 notifyAll() 方法，或者其他某個(gè)線程中斷當(dāng)前線程，或者已超過(guò)某個(gè)實(shí)際時(shí)間量前，導(dǎo)致當(dāng)前線程等待。

亂碼問(wèn)題

按字節(jié)：
buffer.append(new String(bytes,0,n,“UTF-8”));
按字符
設(shè)置轉(zhuǎn)碼charset=utf-8 InputStreamReader reader = new InputStreamReader( inputStream, charset);
內(nèi)存
byte[] bytes = s.getBytes();
String s1 = new String(bytes,“GBK”);
String s2 = new String(bytes)
網(wǎng)絡(luò)：
decode方法和encode

java8特性

一、Lambda表達(dá)式
Lambda表達(dá)式可以說(shuō)是Java 8最大的賣點(diǎn)，她將函數(shù)式編程引入了Java。Lambda允許把函數(shù)作為一個(gè)方法的參數(shù)，或者把代碼看成數(shù)據(jù)。
一個(gè)Lambda表達(dá)式可以由用逗號(hào)分隔的參數(shù)列表、–>符號(hào)與函數(shù)體三部分表示。例如：
Arrays.asList( “p”, “k”, “u”,“f”, “o”, “r”,“k”).forEach( e -> System.out.println( e ) );
1 Arrays.asList( “p”, “k”, “u”,“f”, “o”, “r”,“k”).forEach( e -> System.out.println( e ) );
為了使現(xiàn)有函數(shù)更好的支持Lambda表達(dá)式，Java 8引入了函數(shù)式接口的概念。函數(shù)式接口就是只有一個(gè)方法的普通接口。java.lang.Runnable與java.util.concurrent.Callable是函數(shù)式接口最典型的例子。為此，Java 8增加了一種特殊的注解

@FunctionalInterface：
 @FunctionalInterface
 public interface Functional {
    void method();
 }

二、接口的默認(rèn)方法與靜態(tài)方法
我們可以在接口中定義默認(rèn)方法，使用default關(guān)鍵字，并提供默認(rèn)的實(shí)現(xiàn)。所有實(shí)現(xiàn)這個(gè)接口的類都會(huì)接受默認(rèn)方法的實(shí)現(xiàn)，除非子類提供的自己的實(shí)現(xiàn)。例如：

 public interface DefaultFunctionInterface {
     default String defaultFunction() {
        return "default function";
     }
}

我們還可以在接口中定義靜態(tài)方法，使用static關(guān)鍵字，也可以提供實(shí)現(xiàn)。例如：

 public interface StaticFunctionInterface {
     static String staticFunction() {
         return "static function";
     }
 }

接口的默認(rèn)方法和靜態(tài)方法的引入，其實(shí)可以認(rèn)為引入了C＋＋中抽象類的理念，以后我們?cè)僖膊挥迷诿總€(gè)實(shí)現(xiàn)類中都寫重復(fù)的代碼了。

三、方法引用
通常與Lambda表達(dá)式聯(lián)合使用，可以直接引用已有Java類或?qū)ο蟮姆椒āＲ话阌兴姆N不同的方法引用：
構(gòu)造器引用。語(yǔ)法是Class::new，或者更一般的Class< T >::new，要求構(gòu)造器方法是沒(méi)有參數(shù)；
靜態(tài)方法引用。語(yǔ)法是Class::static_method，要求接受一個(gè)Class類型的參數(shù)；
特定類的任意對(duì)象方法引用。它的語(yǔ)法是Class::method。要求方法是沒(méi)有參數(shù)的；
特定對(duì)象的方法引用，它的語(yǔ)法是instance::method。要求方法接受一個(gè)參數(shù)，與3不同的地方在于，3是在列表元素上分別調(diào)用方法，而4是在某個(gè)對(duì)象上調(diào)用方法，將列表元素作為參數(shù)傳入；

四、重復(fù)注解
在Java 5中使用注解有一個(gè)限制，即相同的注解在同一位置只能聲明一次。Java 8引入重復(fù)注解，這樣相同的注解在同一地方也可以聲明多次。重復(fù)注解機(jī)制本身需要用@Repeatable注解。Java 8在編譯器層做了優(yōu)化，相同注解會(huì)以集合的方式保存，因此底層的原理并沒(méi)有變化。

五、擴(kuò)展注解的支持
Java 8擴(kuò)展了注解的上下文，幾乎可以為任何東西添加注解，包括局部變量、泛型類、父類與接口的實(shí)現(xiàn)，連方法的異常也能添加注解。

六、Optional
Java 8引入Optional類來(lái)防止空指針異常，Optional類最先是由Google的Guava項(xiàng)目引入的。Optional類實(shí)際上是個(gè)容器：它可以保存類型T的值，或者保存null。使用Optional類我們就不用顯式進(jìn)行空指針檢查了。

七、Stream
Stream API是把真正的函數(shù)式編程風(fēng)格引入到Java中。其實(shí)簡(jiǎn)單來(lái)說(shuō)可以把Stream理解為MapReduce，當(dāng)然Google的MapReduce的靈感也是來(lái)自函數(shù)式編程。她其實(shí)是一連串支持連續(xù)、并行聚集操作的元素。從語(yǔ)法上看，也很像linux的管道、或者鏈?zhǔn)骄幊?，代碼寫起來(lái)簡(jiǎn)潔明了，非常酷帥！

八、Date/Time API (JSR 310)
Java 8新的Date-Time API (JSR 310)受Joda-Time的影響，提供了新的java.time包，可以用來(lái)替代 java.util.Date和java.util.Calendar。一般會(huì)用到Clock、LocaleDate、LocalTime、LocaleDateTime、ZonedDateTime、Duration這些類，對(duì)于時(shí)間日期的改進(jìn)還是非常不錯(cuò)的。

九、JavaScript引擎Nashorn
Nashorn允許在JVM上開發(fā)運(yùn)行JavaScript應(yīng)用，允許Java與JavaScript相互調(diào)用。

十、Base64
在Java 8中，Base64編碼成為了Java類庫(kù)的標(biāo)準(zhǔn)。Base64類同時(shí)還提供了對(duì)URL、MIME友好的編碼器與解碼器。
除了這十大新特性之外，還有另外的一些新特性：
更好的類型推測(cè)機(jī)制：Java 8在類型推測(cè)方面有了很大的提高，這就使代碼更整潔，不需要太多的強(qiáng)制類型轉(zhuǎn)換了。
編譯器優(yōu)化：Java 8將方法的參數(shù)名加入了字節(jié)碼中，這樣在運(yùn)行時(shí)通過(guò)反射就能獲取到參數(shù)名，只需要在編譯時(shí)使用-parameters參數(shù)。

并行（parallel）數(shù)組：支持對(duì)數(shù)組進(jìn)行并行處理，主要是parallelSort()方法，它可以在多核機(jī)器上極大提高數(shù)組排序的速度。
并發(fā)（Concurrency）：在新增Stream機(jī)制與Lambda的基礎(chǔ)之上，加入了一些新方法來(lái)支持聚集操作。
Nashorn引擎jjs：基于Nashorn引擎的命令行工具。它接受一些JavaScript源代碼為參數(shù)，并且執(zhí)行這些源代碼。
類依賴分析器jdeps：可以顯示Java類的包級(jí)別或類級(jí)別的依賴。
JVM的PermGen空間被移除：取代它的是Metaspace（JEP 122）。文章來(lái)源地址http://www.zghlxwxcb.cn/news/detail-449199.html

外傳

?? 原創(chuàng)不易，如若本文能夠幫助到您的同學(xué)
?? 支持我：關(guān)注我+點(diǎn)贊??+收藏??
?? 留言：探討問(wèn)題，看到立馬回復(fù)
?? 格言：己所不欲勿施于人 揚(yáng)帆起航、游歷人生、永不言棄！??

到了這里，關(guān)于Java面試知識(shí)點(diǎn)(全)- Java面試基礎(chǔ)部分一的文章就介紹完了。如果您還想了解更多內(nèi)容，請(qǐng)?jiān)谟疑辖撬阉鱐OY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！