純乾貨分享！2020阿里java崗筆試面試題總結（附答案）

時間 2020-10-21

原文原文鏈接

前言

2020金九銀十立刻結束，現爲你們整理了此次金九銀十面試阿里的面試題總結，都是我從朋友那拿到的面試真題，話很少說，滿滿的乾貨分享給你們！java

int a=10是原子操做嗎？

是的。
注意點：面試

i++(或++i)是非原子操做，i++是一個多步操做，並且是能夠被中斷的。i++能夠被分割成3步，第一步讀取i的值，第二步計算i+1；第三部將最終值賦值給i。
* int a = b;不是原子操做。從語法的級別來看，這是也是一條語句，是原子的；可是從實際執行的二進制指令來看，因爲現代計算機CPU架構體系的限制，數據不能夠直接從內存搬運到另一塊內存，必須藉助寄存器中斷，這條語句通常對應兩條計算機指令，即將變量b的值搬運到某個寄存器（如eax）中，再從該寄存器搬運到變量a的內存地址：

mov eax, dword ptr [b]  
mov dword ptr [a], eax

既然是兩條指令，那麼多個線程在執行這兩條指令時，某個線程可能會在第一條指令執行完畢後被剝奪CPU時間片，切換到另一個線程而產生不肯定的狀況。算法

innodb支持全文索引嗎？

5.6版本以後InnoDB存儲引擎開始支持全文索引，5.7版本以後經過使用ngram插件開始支持中文。以前僅支持英文，由於是經過空格做爲分詞的分隔符，對於中文來講是不合適的。MySQL容許在char、varchar、text類型上創建全文索引。後端

innodb支持表鎖嗎？

支持，補充：普通的增刪改是表鎖，加入索引的增刪改是行鎖，執行查詢時不加任何鎖的。數組

HTTP短鏈接怎麼變成長鏈接。

在header中加入 --Connection:keep-alive。安全

調用yeild（）會阻塞嗎？

阻塞指的是暫停一個線程的執行以等待某個條件發生（如某資源就緒）。
yield() 方法：yield() 使得線程放棄當前分得的 CPU 時間，可是不使線程阻塞，即線程仍處於可執行狀態，隨時可能再次分得 CPU 時間。調用 yield() 的效果等價於調度程序認爲該線程已執行了足夠的時間從而轉到另外一個線程。yield()只是使當前線程從新回到可執行狀態，因此執行yield()的線程有可能在進入到可執行狀態後立刻又被執行。sleep()可以使優先級低的線程獲得執行的機會，固然也可讓同優先級和高優先級的線程有執行的機會；yield()只能使同優先級的線程有執行的機會。服務器

虛擬機棧是線程共享的嗎？

不是。
網絡

JVM初始運行的時候都會分配好 Method Area（方法區）和Heap（堆），而JVM 每遇到一個線程，就爲其分配一個 Program Counter Register（程序計數器） , VM Stack（虛擬機棧）和Native Method Stack （本地方法棧），當線程終止時，三者（虛擬機棧，本地方法棧和程序計數器）所佔用的內存空間也會被釋放掉。這也是爲何我把內存區域分爲線程共享和非線程共享的緣由，非線程共享的那三個區域的生命週期與所屬線程相同，而線程共享的區域與JAVA程序運行的生命週期相同，因此這也是系統垃圾回收的場所只發生在線程共享的區域（實際上對大部分虛擬機來講只發生在Heap上）的緣由。多線程

棧區:

每一個線程包含一個棧區，棧中只保存基礎數據類型的值（好比int i=1中1就是基礎類型的對象）和對象的引用以及基礎數據的引用
每一個棧中的數據(基礎數據類型和對象引用)都是私有的，其餘棧不能訪問。
棧分爲3個部分：基本類型變量區、執行環境上下文、操做指令區(存放操做指令)。

堆區:

存儲的所有是對象，每一個對象都包含一個與之對應的class的信息。(class的目的是獲得操做指令)
jvm只有一個堆區(heap)被全部線程共享，堆中不存放基本類型和對象引用，只存放對象自己。

方法區:

又叫靜態區，跟堆同樣，被全部的線程共享。方法區包含全部的class和static變量。
方法區中包含的都是在整個程序中永遠惟一的元素，如class，static變量。（二者區別爲堆區存放new出來的對象信息,方法區存放自己就具備的類信息）

常量存放在JVM的那個區域？

方法區: 又叫靜態區，跟堆同樣，被全部的線程共享。它用於存儲已經被虛擬機加載的類信息、常量、靜態變量、即時編譯器編譯後的代碼等數據。架構

window.postMessage() 方法能夠安全地實現跨源通訊。一般，對於兩個不一樣頁面的腳本，只有當執行它們的頁面位於具備相同的協議（一般爲https），端口號（443爲https的默認值），以及主機 (兩個頁面的模數 Document.domain設置爲相同的值) 時，這兩個腳本才能相互通訊。window.postMessage() 方法提供了一種受控機制來規避此限制，只要正確的使用，這種方法就很安全。

全部的對象都分配到堆中嗎？

答：不必定。

CopyOnWriteArrayList是線程安全的嗎？

答：是的。
CopyOnWriteArrayList使用了一種叫寫時複製的方法，當有新元素添加到CopyOnWriteArrayList時，先從原有的數組中拷貝一份出來，而後在新的數組作寫操做，寫完以後，再將原來的數組引用指向到新數組。建立新數組，並往新數組中加入一個新元素,這個時候，array這個引用仍然是指向原數組的。當元素在新數組添加成功後，將array這個引用指向新數組。
CopyOnWriteArrayList的整個add操做都是在鎖的保護下進行的。這樣作是爲了不在多線程併發add的時候，複製出多個副本出來,把數據搞亂了，致使最終的數組數據不是咱們指望的。

public boolean add(E e) {
        //一、先加鎖
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] elements = getArray();
            int len = elements.length;
            //二、拷貝數組
            Object[] newElements = Arrays.copyOf(elements, len + 1);
            //三、將元素加入到新數組中
            newElements[len] = e;
            //四、將array引用指向到新數組
            setArray(newElements);
            return true;
        } finally {
            //五、解鎖
            lock.unlock();
        }
    }

因爲全部的寫操做都是在新數組進行的，這個時候若是有線程併發的寫，則經過鎖來控制，若是有線程併發的讀，則分幾種狀況：

若是寫操做未完成，那麼直接讀取原數組的數據；
若是寫操做完成，可是引用還未指向新數組，那麼也是讀取原數組數據；
若是寫操做完成，而且引用已經指向了新的數組，那麼直接重新數組中讀取數據。

可見，CopyOnWriteArrayList的讀操做是能夠不用加鎖的。
CopyOnWriteArrayList 有幾個缺點：
因爲寫操做的時候，須要拷貝數組，會消耗內存，
若是原數組的內容比較多的狀況下，可能致使young gc或者full gc
不能用於實時讀的場景，像拷貝數組、新增元素都須要時間，
因此調用一個set操做後，讀取到數據可能仍是舊的,
雖然CopyOnWriteArrayList 能作到最終一致性,可是仍是無法知足實時性要求；
CopyOnWriteArrayList 合適讀多寫少的場景，不過這類慎用
由於誰也無法保證CopyOnWriteArrayList 到底要放置多少數據，
萬一數據稍微有點多，每次add/set都要從新複製數組，這個代價實在過高昂了。
在高性能的互聯網應用中，這種操做分分鐘引發故障。
CopyOnWriteArrayList透露的思想

讀寫分離，讀和寫分開
最終一致性
使用另外開闢空間的思路，來解決併發衝突

數組越界問題

通常來說咱們使用時，會用一個線程向容器中添加元素，一個線程來讀取元素，而讀取的操做每每更加頻繁。寫操做加鎖保證了線程安全，讀寫分離保證了讀操做的效率，簡直完美。
若是這時候有第三個線程進行刪除元素操做，讀線程去讀取容器中最後一個元素，讀以前的時候容器大小爲i，當去讀的時候刪除線程忽然刪除了一個元素，這個時候容器大小變爲了i-1，讀線程仍然去讀取第i個元素，這時候就會發生數組越界。
測試一下，首先向CopyOnWriteArrayList裏面塞10000個測試數據，啓動兩個線程，一個不斷的刪除元素，一個不斷的讀取容器中最後一個數據。

public void test(){
        for(int i = 0; i<10000; i++){
            list.add("string" + i);
        }

        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    if (list.size() > 0) {
                        String content = list.get(list.size() - 1);
                    }else {
                        break;
                    }
                }
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    if(list.size() <= 0){
                        break;
                    }
                    list.remove(0);
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();
    }

Java接口能夠多繼承嗎？

java類是單繼承的。classB extends classA
java接口能夠多繼承。Interface3 extends Interface0, Interface1, interface……
不容許類多重繼承的主要緣由是，若是A同時繼承B和C，而B和C同時有一個D方法，A如何決定該繼承那一個呢？
但接口不存在這樣的問題，接口全都是抽象方法繼承誰都無所謂，因此接口能夠繼承多個接口。

(byte)300==(byte)100+(short)200?

答：false。
java中byte的取值範圍是-128~127，發生上溢下溢時要模256；130>127上溢，故模256得130，仍溢出，再減256得-126，因此s=-126。300>127上溢，故模256得44，44在byte取值範圍內，故s=44.
300 的二進制是：100101100；byte強制轉換後從右往左取8位爲：00101100；由於第八位爲0因此爲正數，又知道正數的原反補碼都相同；因此00101100轉換爲十進制是：44（32+8+4）
(byte)100+(short)200，byte和short的結果會自動轉爲short不會溢出。因此(byte)100+(short)200=(short)300，而(byte)300的結果是44.即二者不相等。

操做系統具備進程管理,存儲管理,文件管理和設備管理的功能,下列有關描述中,哪一項是不正確的? (A)

A.進程管理主要是對程序進行管理
B.存儲管理主要管理內存資源
C.文件管理能夠有效的支持對文件的操做，解決文件共享、保密和保護問題
D. 設備管理是指計算機系統中除了CPU和內存之外的全部輸入輸出設備的管理

this和super正確的是（C）：

A、均可以用在main()方法中 B、都是指一個內存地址
C、不能用在main()方法中 D、意義相同
public static void main(String[] args),main方法是靜態方法，不可使用對象特有的this或super關鍵字。

引用計數法是JVM GC算法嗎？

答：是。

能在try{}catch(){}finally{}結構的finally{}中再次拋出異常嗎？

答：能。
Exception in thread 「main」 java.lang.Exception: 異常4
at com.test.FinallyTry.f(FinallyTry.java:16)
at com.test.FinallyTry.main(FinallyTry.java:5)

--------在finally中拋異常或者return 會掩蓋以前的異常

HTTP2新特性？

答：減小頭部的體積、添加請求優先級、服務器推送、多路複用。

索引能夠將隨機IO變成順序IO嗎？

答：對。
隨機IO：假設咱們所須要的數據是隨機分散在磁盤的不一樣頁的不一樣扇區中的，那麼找到相應的數據須要等到磁臂（尋址做用）旋轉到指定的頁，而後盤片尋找到對應的扇區，才能找到咱們所須要的一塊數據，依次進行此過程直到找完全部數據，這個就是隨機IO，讀取數據速度較慢。
順序IO：假設咱們已經找到了第一塊數據，而且其餘所需的數據就在這一塊數據後邊，那麼就不須要從新尋址，能夠依次拿到咱們所需的數據，這個就叫順序IO。

transient修飾的變量是臨時變量嗎？

答：對。

一旦變量被transient修飾，變量將再也不是對象持久化的一部分，該變量內容在序列化後沒法得到訪問。
transient關鍵字只能修飾變量，而不能修飾方法和類。注意，本地變量是不能被transient關鍵字修飾的。變量若是是用戶自定義類變量，則該類須要實現SERIALIZABLE接口。
被transient關鍵字修飾的變量再也不能被序列化，一個靜態變量無論是否被transient修飾，均不能被序列化。
注意點：在Java中，對象的序列化能夠經過實現兩種接口來實現，若實現的是SERIALIZABLE接口，則全部的序列化將會自動進行，若實現的是Externalizable接口，則沒有任何東西能夠自動序列化，須要在writeExternal方法中進行手工指定所要序列化的變量，這與是否被transient修飾無關。

高、中、低三級調度。

高級調度：即做業調度，按照必定策略將選擇磁盤上的程序裝入內存，並創建進程。（存在與多道批處理系統中）
中級調度：即交換調度，按照必定策略在內外存之間進行數據交換。
低級調度：即CPU調度（進程調度），按照必定策略選擇就緒進程，佔用cpu執行。
其中低度調度是必須的。

下面那個查看80端口是否被佔用？

方式一：ps -ef |grep 80
方式二：netstat -anp |grep :80
方式三：lsof -i:80
方式四：netstat -tunlp |grep :80
方式五：netstat -an |grep :80

C++弱引用指針是那個？

weak_ptr也是一個引用計數型智能指針，可是它不增長對象的引用計數，即弱引用。與之相對，shared_ptr是強引用，只要有一個指向對象的shared_ptr存在，該對象就不會析構，直到指向對象的最後一個shared_ptr析構或reset()時纔會被銷燬。
利用weak_ptr，咱們能夠解決常見的空懸指針問題以及循環引用問題。

下面不屬於類的構造方法具有的特色是( )。

A．沒有返回值
B．用戶能夠經過new自動調用。
C．構造方法名必須和類名相同
D．用戶能夠直接調用
D [解析] 構造方法是類中的一種特殊方法，是爲對象初始化操做編寫的方法，用它來定義對象的初始狀態。在Java語言中的每一個類都有構造方法，它也是由方法名、參數和方法體組成。構造方法名必須與類名相同，它沒有返回值，用戶不能直接調用它，只能經過new自動調用。

spx協議工做在哪一層？

SPX(Sequenced Packet Exchange protocol，順序包交換)協議是Novell開發的用在NetWare中的協議，用來確保信息成功傳送。SPX使用NetWare的IPX協議做爲它的傳遞機制並在網絡結點間提供客戶服務器和層對層的交互通訊。它工做在傳輸層。

TCP第四次揮手後爲何要等待2MSL後才斷開連接？等待時間爲何是2MSL？

答：1.爲了保證客戶端最後一次揮手的報文可以到達服務器，若第4次揮手的報文段丟失了，服務器就會超時重傳第3次揮手的報文段，因此客戶端此時不是直接進入CLOSED，而是保持TIME_WAIT（等待2MSL就是TIME_WAIT）。當客戶端再次收到服務器由於超時重傳而發送的第3次揮手的請求時，客戶端就會從新給服務器發送第4次揮手的報文（保證服務器可以收到客戶端的迴應報文）。最後，客戶端、服務器才真正斷開鏈接。說白了，等待2MSL就是爲了確保服務器可以受到客戶端最後的迴應。

* 2.若是客戶端直接CLOSED，而後又再次向服務器發起一個新鏈接，誰也不能保證新發起的鏈接和剛關閉的鏈接的端口號是不一樣的，有可能新、老鏈接的端口號就是同樣的。假設新、老鏈接端口號一致，若老鏈接的一些數據仍滯留在網絡中，這些滯留數據在新鏈接創建後纔到達服務器，鑑於先後端口號一致，TCP協議就默認這些數據屬於新鏈接，因而數據就這樣亂成一鍋粥了。因此TCP鏈接還要在TIME_WAIT狀態下等待2MSL，確保全部老鏈接的數據都在網絡中消失！

3.首先說明什麼是MSL，MSL是Maximum Segment Lifetime的縮寫，譯爲報文最大生存時間，也就是任何報文在網絡上存活的最大時間，一旦超過該時間，報文就會被丟棄。2MSL也就是指的2倍MSL的時間。
爲何是2倍呢？
主動斷開的一側爲A，被動斷開的一側爲B。
第一個消息：A發FIN
第二個消息：B回覆ACK
第三個消息：B發出FIN此時此刻：B單方面認爲本身與A達成了共識，即雙方都贊成關閉鏈接。此時，B能釋放這個TCP鏈接佔用的內存資源嗎？不能，B必定要確保A收到本身的ACK、FIN。因此B須要靜靜地等待A的第四個消息的到來：
第四個消息：A發出ACK，用於確認收到B的FIN

當B接收到此消息，即認爲雙方達成了同步：雙方都知道鏈接能夠釋放了，此時B能夠安全地釋放此TCP鏈接所佔用的內存資源、端口號。因此被動關閉的B無需任何wait time，直接釋放資源。但，A並不知道B是否接到本身的ACK，A是這麼想的：
      1）若是B沒有收到本身的ACK，會超時重傳FiN那麼A再次接到重傳的FIN，會再次發送ACK
      2）若是B收到本身的ACK，也不會再發任何消息，包括ACK
不管是1仍是2，A都須要等待，要取這兩種狀況等待時間的最大值，以應對最壞的狀況發生，這個最壞狀況是：
      去向ACK消息最大存活時間（MSL) + 來向FIN消息的最大存活時間(MSL)。這偏偏就是2MSL( Maximum Segment Life)。等待2MSL時間，A就能夠放心地釋放TCP佔用的資源、端口號，此時可使用該端口號鏈接任何服務器。同時也能保證網絡中老的連接所有消失。

進程有那些狀態，並簡單描述一下？

進程其基本狀態有5種，即建立狀態、就緒狀態、運行狀態、阻塞狀態、終止狀態。
建立狀態:進程在建立時須要申請一個空白PCB，向其中填寫控制和管理進程的信息，完成資源分配。
就緒狀態:進程已經準備好，已分配到所需資源，只要分配到CPU就可以當即運行。
執行狀態:進程處於就緒狀態被調度後，進程進入執行狀態。
阻塞狀態:正在執行的進程因爲某些事件而暫時沒法運行，進程受到阻塞。
終止狀態:進程結束，或出現錯誤，或被系統終止，進入終止狀態，沒法再執行。
進程是指計算機中的程序關於某數據集合上的一次運行活動，是系統進行資源分配和調度的基本單位。
進程狀態是指一個進程的生命週期能夠劃分爲一組狀態，這些狀態刻畫了整個進程，進程狀態即體現一個進程的生命狀態。

建立NIO客戶端代碼。

package com.cn.niochat;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.channels.SocketChannel;
import java.nio.charset.Charset;
import java.util.Scanner;

/**
 * 用Java實現nio的客戶端
 */
public class NioClient {

    public void start() throws IOException {
        /**
         * 連接服務器端
         */
        SocketChannel socketChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1",8000));

        //向服務器端發送數據
        //從命令行獲取數據，獲取鍵盤的輸入
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNextLine()){
            //獲取這一行數據
           String request =  scanner.nextLine();
           //若是有數據，則發送，且數據不爲空
           if(request != null && request.length() > 0){
               socketChannel.write(Charset.forName("UTF-8").encode(request));
           }
        }
    }

    public static void main(String[] args) throws IOException {
        NioClient nioClient = new NioClient();
        nioClient.start();
    }
}

獲取一個類的class實例的方法有那些？

（1）.調用運行時類自己的.class屬性
Class clazz = String.class;
（2）,經過運行時類的對象獲取
public final Class<?> getClass()是非靜態方法.
Person p = new Person();
Class clazz = p.getClass();
（3）經過Class的靜態方法獲取:體現反射的動態性
String className = 「java.util.commons」;
Class clazz = Class.forName(className);
（4）經過類的加載器
String className = 「java.util.commons」;
ClassLoader classLoader = this.getClass().getClassLoader();
Class claz = classLoader.loadClass(className);

a、b、c、d、e、f字符出現的次數分別爲1六、五、十二、1七、十、25。編碼的最少字節是多少？

（25+16+17）×2+12×3+（5+10）×4=212。

MySQL中得到結果集的記錄並在此記錄上作特殊的操做的最佳對象是？

遊標。

System.out.println(1+1+「1」)輸出21。System.out.println(「1」+1+1);輸出111。

Java的+表達式計算是從左往右的。如果兩個整形，會求值，若其中之一是String,會拼接，且結果爲String。1+1+「1」，先計算1+1，由於兩個都是整形，求值=2，而後2+「1」，拼接，因此是
21，而「1」+1+1，先計算「1」+1，由於有String，結果爲’11",再「11」+1就是「111」。

成員變量，靜態方法看左邊；非靜態方法：編譯看左邊，運行看右邊。

意思是：當父類變量引用子類對象時（Fu f = new Zi();
），在這個引用變量f指向的對象中，他的成員變量和靜態方法與父類是一致的，他的非靜態方法，在編譯時是與父類一致的，運行時卻與子類一致（發生了複寫）。

class Fu {
    intnum = 5;
    static void method4() {
        System.out.println("fu method_4");
    }
    void method3() {
        System.out.println("fu method_3");
    }
}

class Zi extends Fu {
    intnum = 8;
    static void method4() {//注意點：靜態方法不能重寫
        System.out.println("zi method_4");
    }
    void method3() {
        System.out.println("zi method_3");
    }
}

class DuoTaiDemo4 {

     public static void main(String[] args) {
         Fu f = new Zi();
         System.out.println(f.num);//與父類一致
         f.method4();//與父類一致
         f.method3();//編譯時與父類一致，運行時與子類一致
         Zi z = new Zi();
         System.out.println(z.num);
         z.method4();
         z.method3();
     }
}