近5年常考Java面試題及答案整理（三）

阿新 • • 發佈：2018-12-11

近5年常考Java面試題及答案整理（二）

下列面試題都是在網上收集的，本人抱著學習的態度找了下參考答案，有不足的地方還請指正，更多精彩內容可以關注我的微信公眾號：Java團長

68、Java中如何實現序列化，有什麼意義？

答：序列化就是一種用來處理物件流的機制，所謂物件流也就是將物件的內容進行流化。可以對流化後的物件進行讀寫操作，也可將流化後的物件傳輸於網路之間。序列化是為了解決物件流讀寫操作時可能引發的問題（如果不進行序列化可能會存在資料亂序的問題）。
要實現序列化，需要讓一個類實現Serializable介面，該介面是一個標識性介面，標註該類物件是可被序列化的，然後使用一個輸出流來構造一個物件輸出流並通過writeObject(Object)方法就可以將實現物件寫出（即儲存其狀態）；如果需要反序列化則可以用一個輸入流建立物件輸入流，然後通過readObject方法從流中讀取物件。序列化除了能夠實現物件的持久化之外，還能夠用於物件的深度克隆（可以參考第29題）。

69、Java中有幾種型別的流？

答：位元組流和字元流。位元組流繼承於InputStream、OutputStream，字元流繼承於Reader、Writer。在 java.io 包中還有許多其他的流，主要是為了提高效能和使用方便。關於Java的I/O需要注意的有兩點：一是兩種對稱性（輸入和輸出的對稱性，位元組和字元的對稱性）；二是兩種設計模式（介面卡模式和裝潢模式）。另外Java中的流不同於C#的是它只有一個維度一個方向。

面試題 - 程式設計實現檔案拷貝。（這個題目在筆試的時候經常出現，下面的程式碼給出了兩種實現方案）

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

public final class MyUtil {

    private MyUtil() {
        throw new AssertionError();
    }

    public static void fileCopy(String source, String target) throws IOException {
        try (InputStream in = new FileInputStream(source)) {
            try (OutputStream out = new FileOutputStream(target)) {
                byte[] buffer = new byte[4096];
                int bytesToRead;
                while((bytesToRead = in.read(buffer)) != -1) {
                    out.write(buffer, 0, bytesToRead);
                }
            }
        }
    }

    public static void fileCopyNIO(String source, String target) throws IOException {
        try (FileInputStream in = new FileInputStream(source)) {
            try (FileOutputStream out = new FileOutputStream(target)) {
                FileChannel inChannel = in.getChannel();
                FileChannel outChannel = out.getChannel();
                ByteBuffer buffer = ByteBuffer.allocate(4096);
                while(inChannel.read(buffer) != -1) {
                    buffer.flip();
                    outChannel.write(buffer);
                    buffer.clear();
                }
            }
        }
    }
}

注意：上面用到Java 7的TWR，使用TWR後可以不用在finally中釋放外部資源，從而讓程式碼更加優雅。

70、寫一個方法，輸入一個檔名和一個字串，統計這個字串在這個檔案中出現的次數。

答：程式碼如下：

import java.io.BufferedReader;
import java.io.FileReader;

public final class MyUtil {

    // 工具類中的方法都是靜態方式訪問的因此將構造器私有不允許建立物件(絕對好習慣)
    private MyUtil() {
        throw new AssertionError();
    }

    /**
     * 統計給定檔案中給定字串的出現次數
     * 
     * @param filename  檔名
     * @param word 字串
     * @return 字串在檔案中出現的次數
     */
    public static int countWordInFile(String filename, String word) {
        int counter = 0;
        try (FileReader fr = new FileReader(filename)) {
            try (BufferedReader br = new BufferedReader(fr)) {
                String line = null;
                while ((line = br.readLine()) != null) {
                    int index = -1;
                    while (line.length() >= word.length() && (index = line.indexOf(word)) >= 0) {
                        counter++;
                        line = line.substring(index + word.length());
                    }
                }
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return counter;
    }

}

71、如何用Java程式碼列出一個目錄下所有的檔案？

答：
如果只要求列出當前資料夾下的檔案，程式碼如下所示：

import java.io.File;

class Test12 {

    public static void main(String[] args) {
        File f = new File("/Users/nnngu/Downloads");
        for(File temp : f.listFiles()) {
            if(temp.isFile()) {
                System.out.println(temp.getName());
            }
        }
    }
}

如果需要對資料夾繼續展開，程式碼如下所示：

import java.io.File;

class Test12 {

    public static void main(String[] args) {
        showDirectory(new File("/Users/nnngu/Downloads"));
    }

    public static void showDirectory(File f) {
        _walkDirectory(f, 0);
    }

    private static void _walkDirectory(File f, int level) {
        if(f.isDirectory()) {
            for(File temp : f.listFiles()) {
                _walkDirectory(temp, level + 1);
            }
        }
        else {
            for(int i = 0; i < level - 1; i++) {
                System.out.print("\t");
            }
            System.out.println(f.getName());
        }
    }
}

在Java 7中可以使用NIO.2的API來做同樣的事情，程式碼如下所示：

class ShowFileTest {

    public static void main(String[] args) throws IOException {
        Path initPath = Paths.get("/Users/nnngu/Downloads");
        Files.walkFileTree(initPath, new SimpleFileVisitor<Path>() {

            @Override
            public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) 
                    throws IOException {
                System.out.println(file.getFileName().toString());
                return FileVisitResult.CONTINUE;
            }

        });
    }
}

72、用Java的套接字程式設計實現一個多執行緒的回顯（echo）伺服器。

答：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;

public class EchoServer {

    private static final int ECHO_SERVER_PORT = 6789;

    public static void main(String[] args) {        
        try(ServerSocket server = new ServerSocket(ECHO_SERVER_PORT)) {
            System.out.println("伺服器已經啟動...");
            while(true) {
                Socket client = server.accept();
                new Thread(new ClientHandler(client)).start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static class ClientHandler implements Runnable {
        private Socket client;

        public ClientHandler(Socket client) {
            this.client = client;
        }

        @Override
        public void run() {
            try(BufferedReader br = new BufferedReader(new InputStreamReader(client.getInputStream()));
                    PrintWriter pw = new PrintWriter(client.getOutputStream())) {
                String msg = br.readLine();
                System.out.println("收到" + client.getInetAddress() + "傳送的: " + msg);
                pw.println(msg);
                pw.flush();
            } catch(Exception ex) {
                ex.printStackTrace();
            } finally {
                try {
                    client.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

}

注意：上面的程式碼使用了Java 7的TWR語法，由於很多外部資源類都間接的實現了AutoCloseable介面（單方法回撥介面），因此可以利用TWR語法在try結束的時候通過回撥的方式自動呼叫外部資源類的close()方法，避免書寫冗長的finally程式碼塊。此外，上面的程式碼用一個靜態內部類實現執行緒的功能，使用多執行緒可以避免一個使用者I/O操作所產生的中斷影響其他使用者對伺服器的訪問，簡單的說就是一個使用者的輸入操作不會造成其他使用者的阻塞。當然，上面的程式碼使用執行緒池可以獲得更好的效能，因為頻繁的建立和銷燬執行緒所造成的開銷也是不可忽視的。

下面是一段回顯客戶端測試程式碼：

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.Scanner;

public class EchoClient {

    public static void main(String[] args) throws Exception {
        Socket client = new Socket("localhost", 6789);
        Scanner sc = new Scanner(System.in);
        System.out.print("請輸入內容: ");
        String msg = sc.nextLine();
        sc.close();
        PrintWriter pw = new PrintWriter(client.getOutputStream());
        pw.println(msg);
        pw.flush();
        BufferedReader br = new BufferedReader(new InputStreamReader(client.getInputStream()));
        System.out.println(br.readLine());
        client.close();
    }
}

如果希望用NIO的多路複用套接字實現伺服器，程式碼如下所示。NIO的操作雖然帶來了更好的效能，但是有些操作是比較底層的，對於初學者來說還是有些難於理解。

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;

public class EchoServerNIO {

    private static final int ECHO_SERVER_PORT = 6789;
    private static final int ECHO_SERVER_TIMEOUT = 5000;
    private static final int BUFFER_SIZE = 1024;

    private static ServerSocketChannel serverChannel = null;
    private static Selector selector = null;    // 多路複用選擇器
    private static ByteBuffer buffer = null;    // 緩衝區

    public static void main(String[] args) {
        init();
        listen();
    }

    private static void init() {
        try {
            serverChannel = ServerSocketChannel.open();
            buffer = ByteBuffer.allocate(BUFFER_SIZE);
            serverChannel.socket().bind(new InetSocketAddress(ECHO_SERVER_PORT));
            serverChannel.configureBlocking(false);
            selector = Selector.open();
            serverChannel.register(selector, SelectionKey.OP_ACCEPT);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    private static void listen() {
        while (true) {
            try {
                if (selector.select(ECHO_SERVER_TIMEOUT) != 0) {
                    Iterator<SelectionKey> it = selector.selectedKeys().iterator();
                    while (it.hasNext()) {
                        SelectionKey key = it.next();
                        it.remove();
                        handleKey(key);
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    private static void handleKey(SelectionKey key) throws IOException {
        SocketChannel channel = null;

        try {
            if (key.isAcceptable()) {
                ServerSocketChannel serverChannel = (ServerSocketChannel) key.channel();
                channel = serverChannel.accept();
                channel.configureBlocking(false);
                channel.register(selector, SelectionKey.OP_READ);
            } else if (key.isReadable()) {
                channel = (SocketChannel) key.channel();
                buffer.clear();
                if (channel.read(buffer) > 0) {
                    buffer.flip();
                    CharBuffer charBuffer = CharsetHelper.decode(buffer);
                    String msg = charBuffer.toString();
                    System.out.println("收到" + channel.getRemoteAddress() + "的訊息：" + msg);
                    channel.write(CharsetHelper.encode(CharBuffer.wrap(msg)));
                } else {
                    channel.close();
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
            if (channel != null) {
                channel.close();
            }
        }
    }

}

import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.CharacterCodingException;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import java.nio.charset.CharsetEncoder;

public final class CharsetHelper {
    private static final String UTF_8 = "UTF-8";
    private static CharsetEncoder encoder = Charset.forName(UTF_8).newEncoder();
    private static CharsetDecoder decoder = Charset.forName(UTF_8).newDecoder();

    private CharsetHelper() {
    }

    public static ByteBuffer encode(CharBuffer in) throws CharacterCodingException{
        return encoder.encode(in);
    }

    public static CharBuffer decode(ByteBuffer in) throws CharacterCodingException{
        return decoder.decode(in);
    }
}

73、XML文件定義有幾種形式？它們之間有何本質區別？解析XML文件有哪幾種方式？

答：XML文件定義分為DTD和Schema兩種形式，二者都是對XML語法的約束，其本質區別在於Schema本身也是一個XML檔案，可以被XML解析器解析，而且可以為XML承載的資料定義型別，約束能力較之DTD更強大。對XML的解析主要有DOM（文件物件模型，Document Object Model）、SAX（Simple API for XML）和StAX（Java 6中引入的新的解析XML的方式，Streaming API for XML），其中DOM處理大型檔案時其效能下降的非常厲害，這個問題是由DOM樹結構佔用的記憶體較多造成的，而且DOM解析方式必須在解析檔案之前把整個文件裝入記憶體，適合對XML的隨機訪問（典型的用空間換取時間的策略）；SAX是事件驅動型的XML解析方式，它順序讀取XML檔案，不需要一次全部裝載整個檔案。當遇到像檔案開頭，文件結束，或者標籤開頭與標籤結束時，它會觸發一個事件，使用者通過事件回撥程式碼來處理XML檔案，適合對XML的順序訪問；顧名思義，StAX把重點放在流上，實際上StAX與其他解析方式的本質區別就在於應用程式能夠把XML作為一個事件流來處理。將XML作為一組事件來處理的想法並不新穎（SAX就是這樣做的），但不同之處在於StAX允許應用程式程式碼把這些事件逐個拉出來，而不用提供在解析器方便時從解析器中接收事件的處理程式。

74、你在專案中哪些地方用到了XML？

答：XML的主要作用有兩個方面：資料交換和資訊配置。在做資料交換時，XML將資料用標籤組裝成起來，然後壓縮打包加密後通過網路傳送給接收者，接收解密與解壓縮後再從XML檔案中還原相關資訊進行處理，XML曾經是異構系統間交換資料的事實標準，但此項功能幾乎已經被JSON（JavaScript Object Notation）取而代之。當然，目前很多軟體仍然使用XML來儲存配置資訊，我們在很多專案中通常也會將作為配置資訊的硬程式碼寫在XML檔案中，Java的很多框架也是這麼做的，而且這些框架都選擇了dom4j作為處理XML的工具，因為Sun公司的官方API實在不怎麼好用。

補充：現在有很多時髦的軟體（如Sublime）已經開始將配置檔案書寫成JSON格式，我們已經強烈的感受到XML的另一項功能也將逐漸被業界拋棄。

75、闡述JDBC操作資料庫的步驟。

答：下面的程式碼以連線本機的Oracle資料庫為例，演示JDBC操作資料庫的步驟。

載入驅動。

Class.forName("oracle.jdbc.driver.OracleDriver");

建立連線。

Connection con = DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:orcl", "scott", "tiger");

建立語句。

PreparedStatement ps = con.prepareStatement("select * from emp where sal between ? and ?");
ps.setInt(1, 1000);
ps.setInt(2, 3000);

執行語句。

ResultSet rs = ps.executeQuery();

處理結果。

while(rs.next()) {
    System.out.println(rs.getInt("empno") + " - " + rs.getString("ename"));
}

關閉資源。

    finally {
        if(con != null) {
            try {
                con.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

提示：關閉外部資源的順序應該和開啟的順序相反，也就是說先關閉ResultSet、再關閉Statement、在關閉Connection。上面的程式碼只關閉了Connection（連線），雖然通常情況下在關閉連線時，連線上建立的語句和開啟的遊標也會關閉，但不能保證總是如此，因此應該按照剛才說的順序分別關閉。此外，第一步載入驅動在JDBC 4.0中是可以省略的（自動從類路徑中載入驅動），但是我們建議保留。

76、Statement和PreparedStatement有什麼區別？哪個效能更好？

答：與Statement相比，①PreparedStatement介面代表預編譯的語句，它主要的優勢在於可以減少SQL的編譯錯誤並增加SQL的安全性（減少SQL注射攻擊的可能性）；②PreparedStatement中的SQL語句是可以帶引數的，避免了用字串連線拼接SQL語句的麻煩和不安全；③當批量處理SQL或頻繁執行相同的查詢時，PreparedStatement有明顯的效能上的優勢，由於資料庫可以將編譯優化後的SQL語句快取起來，下次執行相同結構的語句時就會很快（不用再次編譯和生成執行計劃）。

補充：為了提供對儲存過程的呼叫，JDBC API中還提供了CallableStatement介面。儲存過程（Stored Procedure）是資料庫中一組為了完成特定功能的SQL語句的集合，經編譯後儲存在資料庫中，使用者通過指定儲存過程的名字並給出引數（如果該儲存過程帶有引數）來執行它。雖然呼叫儲存過程會在網路開銷、安全性、效能上獲得很多好處，但是存在如果底層資料庫發生遷移時就會有很多麻煩，因為每種資料庫的儲存過程在書寫上存在不少的差別。

77、使用JDBC操作資料庫時，如何提升讀取資料的效能？如何提升更新資料的效能？

答：要提升讀取資料的效能，可以指定通過結果集（ResultSet）物件的setFetchSize()方法指定每次抓取的記錄數（典型的空間換時間策略）；要提升更新資料的效能可以使用PreparedStatement語句構建批處理，將若干SQL語句置於一個批處理中執行。

78、在進行資料庫程式設計時，連線池有什麼作用？

答：由於建立連線和釋放連線都有很大的開銷（尤其是資料庫伺服器不在本地時，每次建立連線都需要進行TCP的三次握手，釋放連線需要進行TCP四次握手，造成的開銷是不可忽視的），為了提升系統訪問資料庫的效能，可以事先建立若干連線置於連線池中，需要時直接從連線池獲取，使用結束時歸還連線池而不必關閉連線，從而避免頻繁建立和釋放連線所造成的開銷，這是典型的用空間換取時間的策略（浪費了空間儲存連線，但節省了建立和釋放連線的時間）。池化技術在Java開發中是很常見的，在使用執行緒時建立執行緒池的道理與此相同。基於Java的開源資料庫連線池主要有：C3P0、Proxool、DBCP、BoneCP、Druid等。

補充：在計算機系統中時間和空間是不可調和的矛盾，理解這一點對設計滿足效能要求的演算法是至關重要的。大型網站效能優化的一個關鍵就是使用快取，而快取跟上面講的連線池道理非常類似，也是使用空間換時間的策略。可以將熱點資料置於快取中，當用戶查詢這些資料時可以直接從快取中得到，這無論如何也快過去資料庫中查詢。當然，快取的置換策略等也會對系統性能產生重要影響，對於這個問題的討論已經超出了這裡要闡述的範圍。

79、什麼是DAO模式？

答：DAO（Data Access Object）顧名思義是一個為資料庫或其他持久化機制提供了抽象介面的物件，在不暴露底層持久化方案實現細節的前提下提供了各種資料訪問操作。在實際的開發中，應該將所有對資料來源的訪問操作進行抽象化後封裝在一個公共API中。用程式設計語言來說，就是建立一個介面，介面中定義了此應用程式中將會用到的所有事務方法。在這個應用程式中，當需要和資料來源進行互動的時候則使用這個介面，並且編寫一個單獨的類來實現這個介面，在邏輯上該類對應一個特定的資料儲存。DAO模式實際上包含了兩個模式，一是Data Accessor（資料訪問器），二是Data Object（資料物件），前者要解決如何訪問資料的問題，而後者要解決的是如何用物件封裝資料。

80、事務的ACID是指什麼？

答：

原子性(Atomic)：事務中各項操作，要麼全做要麼全不做，任何一項操作的失敗都會導致整個事務的失敗；
一致性(Consistent)：事務結束後系統狀態是一致的；
隔離性(Isolated)：併發執行的事務彼此無法看到對方的中間狀態；
永續性(Durable)：事務完成後所做的改動都會被持久化，即使發生災難性的失敗。通過日誌和同步備份可以在故障發生後重建資料。

補充：關於事務，在面試中被問到的概率是很高的，可以問的問題也是很多的。首先需要知道的是，只有存在併發資料訪問時才需要事務。當多個事務訪問同一資料時，可能會存在5類問題，包括3類資料讀取問題（髒讀、不可重複讀和幻讀）和2類資料更新問題（第1類丟失更新和第2類丟失更新）。

髒讀（Dirty Read）：A事務讀取B事務尚未提交的資料並在此基礎上操作，而B事務執行回滾，那麼A讀取到的資料就是髒資料。

不可重複讀（Unrepeatable Read）：事務A重新讀取前面讀取過的資料，發現該資料已經被另一個已提交的事務B修改過了。

幻讀（Phantom Read）：事務A重新執行一個查詢，返回一系列符合查詢條件的行，發現其中插入了被事務B提交的行。

第1類丟失更新：事務A撤銷時，把已經提交的事務B的更新資料覆蓋了。

時間	取款事務A	轉賬事務B
T1	開始事務
T2		開始事務
T3	查詢賬戶餘額為1000元
T4		查詢賬戶餘額為1000元
T5		匯入100元修改餘額為1100元
T6		提交事務
T7	取出100元將餘額修改為900元
T8	撤銷事務
T9	餘額恢復為1000元（丟失更新）

第2類丟失更新：事務A覆蓋事務B已經提交的資料，造成事務B所做的操作丟失。

時間	轉賬事務A	取款事務B
T1		開始事務
T2	開始事務
T3		查詢賬戶餘額為1000元
T4	查詢賬戶餘額為1000元
T5		取出100元將餘額修改為900元
T6		提交事務
T7	匯入100元將餘額修改為1100元
T8	提交事務
T9	查詢賬戶餘額為1100元（丟失更新）

資料併發訪問所產生的問題，在有些場景下可能是允許的，但是有些場景下可能就是致命的，資料庫通常會通過鎖機制來解決資料併發訪問問題，按鎖定物件不同可以分為表級鎖和行級鎖；按併發事務鎖定關係可以分為共享鎖和獨佔鎖，具體的內容大家可以自行查閱資料進行了解。
直接使用鎖是非常麻煩的，為此資料庫為使用者提供了自動鎖機制，只要使用者指定會話的事務隔離級別，資料庫就會通過分析SQL語句然後為事務訪問的資源加上合適的鎖，此外，資料庫還會維護這些鎖通過各種手段提高系統的效能，這些對使用者來說都是透明的（就是說你不用理解，事實上我確實也不知道）。ANSI/ISO SQL 92標準定義了4個等級的事務隔離級別，如下表所示：

隔離級別	髒讀	不可重複讀	幻讀	第一類丟失更新	第二類丟失更新
READ UNCOMMITED	允許	允許	允許	不允許	允許
READ COMMITTED	不允許	允許	允許	不允許	允許
REPEATABLE READ	不允許	不允許	允許	不允許	不允許
SERIALIZABLE	不允許	不允許	不允許	不允許	不允許

需要說明的是，事務隔離級別和資料訪問的併發性是對立的，事務隔離級別越高併發性就越差。所以要根據具體的應用來確定合適的事務隔離級別，這個地方沒有萬能的原則。

81、JDBC中如何進行事務處理？

答：Connection提供了事務處理的方法，通過呼叫setAutoCommit(false)可以設定手動提交事務；當事務完成後用commit()顯式提交事務；如果在事務處理過程中發生異常則通過rollback()進行事務回滾。除此之外，從JDBC 3.0中還引入了Savepoint（儲存點）的概念，允許通過程式碼設定儲存點並讓事務回滾到指定的儲存點。

82、JDBC能否處理Blob和Clob？

答： Blob是指二進位制大物件（Binary Large Object），而Clob是指大字元物件（Character Large Objec），因此其中Blob是為儲存大的二進位制資料而設計的，而Clob是為儲存大的文字資料而設計的。JDBC的PreparedStatement和ResultSet都提供了相應的方法來支援Blob和Clob操作。下面的程式碼展示瞭如何使用JDBC操作LOB：
下面以MySQL資料庫為例，建立一個張有三個欄位的使用者表，包括編號（id）、姓名（name）和照片（photo），建表語句如下：

create table tb_user
(
id int primary key auto_increment,
name varchar(20) unique not null,
photo longblob
);

下面的Java程式碼向資料庫中插入一條記錄：

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;

class JdbcLobTest {

    public static void main(String[] args) {
        Connection con = null;
        try {
            // 1. 載入驅動（Java6以上版本可以省略）
            Class.forName("com.mysql.jdbc.Driver");
            // 2. 建立連線
            con = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "123456");
            // 3. 建立語句物件
            PreparedStatement ps = con.prepareStatement("insert into tb_user values (default, ?, ?)");
            ps.setString(1, "郭靖");              // 將SQL語句中第一個佔位符換成字串
            try (InputStream in = new FileInputStream("test.jpg")) {    // Java 7的TWR
                ps.setBinaryStream(2, in);      // 將SQL語句中第二個佔位符換成二進位制流
                // 4. 發出SQL語句獲得受影響行數
                System.out.println(ps.executeUpdate() == 1 ? "插入成功" : "插入失敗");
            } catch(IOException e) {
                System.out.println("讀取照片失敗!");
            }
        } catch (ClassNotFoundException | SQLException e) {     // Java 7的多異常捕獲
            e.printStackTrace();
        } finally { // 釋放外部資源的程式碼都應當放在finally中保證其能夠得到執行
            try {
                if(con != null && !con.isClosed()) {
                    con.close();    // 5. 釋放資料庫連線 
                    con = null;     // 指示垃圾回收器可以回收該物件
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

83、簡述正則表示式及其用途。

答：在編寫處理字串的程式時，經常會有查詢符合某些複雜規則的字串的需要。正則表示式就是用於描述這些規則的工具。換句話說，正則表示式就是記錄文字規則的程式碼。

說明：計算機誕生初期處理的資訊幾乎都是數值，但是時過境遷，今天我們使用計算機處理的資訊更多的時候不是數值而是字串，正則表示式就是在進行字串匹配和處理的時候最為強大的工具，絕大多數語言都提供了對正則表示式的支援。

84、Java中是如何支援正則表示式操作的？

答：Java中的String類提供了支援正則表示式操作的方法，包括：matches()、replaceAll()、replaceFirst()、split()。此外，Java中可以用Pattern類表示正則表示式物件，它提供了豐富的API進行各種正則表示式操作，請參考下面面試題的程式碼。

面試題： - 如果要從字串中擷取第一個英文左括號之前的字串，例如：北京市(朝陽區)(西城區)(海淀區)，擷取結果為：北京市，那麼正則表示式怎麼寫？

import java.util.regex.Matcher;
import java.util.regex.Pattern;

class RegExpTest {

    public static void main(String[] args) {
        String str = "北京市(朝陽區)(西城區)(海淀區)";
        Pattern p = Pattern.compile(".*?(?=\\()");
        Matcher m = p.matcher(str);
        if(m.find()) {
            System.out.println(m.group());
        }
    }
}

說明：上面的正則表示式中使用了懶惰匹配和前瞻，如果不清楚這些內容，推薦讀一下網上很有名的《正則表示式30分鐘入門教程》。

85、獲得一個類的類物件有哪些方式？

答：

方法1：型別.class，例如：String.class
方法2：物件.getClass()，例如："hello".getClass()
方法3：Class.forName()，例如：Class.forName("java.lang.String")

86、如何通過反射建立物件？

答：

方法1：通過類物件呼叫newInstance()方法，例如：String.class.newInstance()
方法2：通過類物件的getConstructor()或getDeclaredConstructor()方法獲得構造器（Constructor）物件並呼叫其newInstance()方法建立物件，例如：String.class.getConstructor(String.class).newInstance("Hello");

87、如何通過反射獲取和設定物件私有欄位的值？

答：可以通過類物件的getDeclaredField()方法獲得欄位（Field）物件，然後再通過欄位物件的setAccessible(true)將其設定為可以訪問，接下來就可以通過get/set方法來獲取/設定欄位的值了。下面的程式碼實現了一個反射的工具類，其中的兩個靜態方法分別用於獲取和設定私有欄位的值，欄位可以是基本型別也可以是物件型別且支援多級物件操作，例如ReflectionUtil.get(dog, "owner.car.engine.id");可以獲得dog物件的主人的汽車的引擎的ID號。

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.List;

/**
 * 反射工具類
 * @author nnngu
 *
 */
public class ReflectionUtil {

    private ReflectionUtil() {
        throw new AssertionError();
    }

    /**
     * 通過反射取物件指定欄位(屬性)的值
     * @param target 目標物件
     * @param fieldName 欄位的名字
     * @throws 如果取不到物件指定欄位的值則丟擲異常
     * @return 欄位的值
     */
    public static Object getValue(Object target, String fieldName) {
        Class<?> clazz = target.getClass();
        String[] fs = fieldName.split("\\.");

        try {
            for(int i = 0; i < fs.length - 1; i++) {
                Field f = clazz.getDeclaredField(fs[i]);
                f.setAccessible(true);
                target = f.get(target);
                clazz = target.getClass();
            }

            Field f = clazz.getDeclaredField(fs[fs.length - 1]);
            f.setAccessible(true);
            return f.get(target);
        }
        catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 通過反射給物件的指定欄位賦值
     * @param target 目標物件
     * @param fieldName 欄位的名稱
     * @param value 值
     */
    public static void setValue(Object target, String fieldName, Object value) {
        Class<?> clazz = target.getClass();
        String[] fs = fieldName.split("\\.");
        try {
            for(int i = 0; i < fs.length - 1; i++) {
                Field f = clazz.getDeclaredField(fs[i]);
                f.setAccessible(true);
                Object val = f.get(target);
                if(val == null) {
                    Constructor<?> c = f.getType().getDeclaredConstructor();
                    c.setAccessible(true);
                    val = c.newInstance();
                    f.set(target, val);
                }
                target = val;
                clazz = target.getClass();
            }

            Field f = clazz.getDeclaredField(fs[fs.length - 1]);
            f.setAccessible(true);
            f.set(target, value);
        }
        catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

}

88、如何通過反射呼叫物件的方法？

答：請看下面的程式碼：

import java.lang.reflect.Method;

class MethodInvokeTest {

    public static void main(String[] args) throws Exception {
        String str = "hello";
        Method m = str.getClass().getMethod("toUpperCase");
        System.out.println(m.invoke(str));  // HELLO
    }
}

89、簡述一下面向物件的"六原則一法則"。

答：

單一職責原則：一個類只做它該做的事情。（單一職責原則想表達的就是"高內聚"，寫程式碼最終極的原則只有六個字"高內聚、低耦合"，就如同葵花寶典或辟邪劍譜的中心思想就八個字"欲練此功必先自宮"，所謂的高內聚就是一個程式碼模組只完成一項功能，在面向物件中，如果只讓一個類完成它該做的事，而不涉及與它無關的領域就是踐行了高內聚的原則，這個類就只有單一職責。我們都知道一句話叫"因為專注，所以專業"，一個物件如果承擔太多的職責，那麼註定它什麼都做不好。這個世界上任何好的東西都有兩個特徵，一個是功能單一，好的相機絕對不是電視購物裡面賣的那種一個機器有一百多種功能的，它基本上只能照相；另一個是模組化，好的自行車是組裝車，從減震叉、剎車到變速器，所有的部件都是可以拆卸和重新組裝的，好的乒乓球拍也不是成品拍，一定是底板和膠皮可以拆分和自行組裝的，一個好的軟體系統，它裡面的每個功能模組也應該是可以輕易的拿到其他系統中使用的，這樣才能實現軟體複用的目標。）
開閉原則：軟體實體應當對擴充套件開放，對修改關閉。（在理想的狀態下，當我們需要為一個軟體系統增加新功能時，只需要從原來的系統派生出一些新類就可以，不需要修改原來的任何一行程式碼。要做到開閉有兩個要點：①抽象是關鍵，一個系統中如果沒有抽象類或介面系統就沒有擴充套件點；②封裝可變性，將系統中的各種可變因素封裝到一個繼承結構中，如果多個可變因素混雜在一起，系統將變得複雜而混亂，如果不清楚如何封裝可變性，可以參考《設計模式精解》一書中對橋樑模式的講解的章節。）
依賴倒轉原則：面向介面程式設計。（該原則說得直白和具體一些就是宣告方法的引數型別、方法的返回型別、變數的引用型別時，儘可能使用抽象型別而不用具體型別，因為抽象型別可以被它的任何一個子型別所替代，請參考下面的里氏替換原則。）
里氏替換原則：任何時候都可以用子型別替換掉父型別。（關於里氏替換原則的描述，Barbara Liskov女士的描述比這個要複雜得多，但簡單的說就是能用父型別的地方就一定能使用子型別。里氏替換原則可以檢查繼承關係是否合理，如果一個繼承關係違背了里氏替換原則，那麼這個繼承關係一定是錯誤的，需要對程式碼進行重構。例如讓貓繼承狗，或者狗繼承貓，又或者讓正方形繼承長方形都是錯誤的繼承關係，因為你很容易找到違反里氏替換原則的場景。需要注意的是：子類一定是增加父類的能力而不是減少父類的能力，因為子類比父類的能力更多，把能力多的物件當成能力少的物件來用當然沒有任何問題。）
介面隔離原則：介面要小而專，絕不能大而全。（臃腫的介面是對介面的汙染，既然介面表示能力，那麼一個介面只應該描述一種能力，介面也應該是高度內聚的。例如，琴棋書畫就應該分別設計為四個介面，而不應設計成一個介面中的四個方法，因為如果設計成一個介面中的四個方法，那麼這個介面很難用，畢竟琴棋書畫四樣都精通的人還是少數，而如果設計成四個介面，會幾項就實現幾個介面，這樣的話每個介面被複用的可能性是很高的。Java中的介面代表能力、代表約定、代表角色，能否正確的使用介面一定是程式設計水平高低的重要標識。）
合成聚合複用原則：優先使用聚合或合成關係複用程式碼。（通過繼承來複用程式碼是面向物件程式設計中被濫用得最多的東西，因為所有的教科書都無一例外的對繼承進行了鼓吹從而誤導了初學者，類與類之間簡單的說有三種關係，Is-A關係、Has-A關係、Use-A關係，分別代表繼承、關聯和依賴。其中，關聯關係根據其關聯的強度又可以進一步劃分為關聯、聚合和合成，但說白了都是Has-A關係，合成聚合複用原則想表達的是優先考慮Has-A關係而不是Is-A關係複用程式碼，原因嘛可以自己從百度上找到一萬個理由，需要說明的是，即使在Java的API中也有不少濫用繼承的例子，例如Properties類繼承了Hashtable類，Stack類繼承了Vector類，這些繼承明顯就是錯誤的，更好的做法是在Properties類中放置一個Hashtable型別的成員並且將其鍵和值都設定為字串來儲存資料，而Stack類的設計也應該是在Stack類中放一個Vector物件來儲存資料。記住：任何時候都不要繼承工具類，工具是可以擁有並可以使用的，而不是拿來繼承的。）
迪米特法則：迪米特法則又叫最少知識原則，一個物件應當對其他物件有儘可能少的瞭解。（迪米特法則簡單的說就是如何做到"低耦合"，門面模式和調停者模式就是對迪米特法則的踐行。對於門面模式可以舉一個簡單的例子，你去一家公司洽談業務，你不需要了解這個公司內部是如何運作的，你甚至可以對這個公司一無所知，去的時候只需要找到公司入口處的前臺美女，告訴她們你要做什麼，她們會找到合適的人跟你接洽，前臺的美女就是公司這個系統的門面。再複雜的系統都可以為使用者提供一個簡單的門面，Java Web開發中作為前端控制器的Servlet或Filter不就是一個門面嗎，瀏覽器對伺服器的運作方式一無所知，但是通過前端控制器就能夠根據你的請求得到相應的服務。調停者模式也可以舉一個簡單的例子來說明，例如一臺計算機，CPU、記憶體、硬碟、顯示卡、音效卡各種裝置需要相互配合才能很好的工作，但是如果這些東西都直接連線到一起，計算機的佈線將異常複雜，在這種情況下，主機板作為一個調停者的身份出現，它將各個裝置連線在一起而不需要每個裝置之間直接交換資料，這樣就減小了系統的耦合度和複雜度，如下圖所示。迪米特法則用通俗的話來將就是不要和陌生人打交道，如果真的需要，找一個自己的朋友，讓他替你和陌生人打交道。）

90、簡述一下你瞭解的設計模式。

答：所謂設計模式，就是一套被反覆使用的程式碼設計經驗的總結（情境中一個問題經過證實的一個解決方案）。使用設計模式是為了可重用程式碼、讓程式碼更容易被他人理解、保證程式碼可靠性。設計模式使人們可以更加簡單方便的複用成功的設計和體系結構。將已證實的技術表述成設計模式也會使新系統開發者更加容易理解其設計思路。
在GoF的《Design Patterns: Elements of Reusable Object-Oriented Software》中給出了三類（建立型[對類的例項化過程的抽象化]、結構型[描述如何將類或物件結合在一起形成更大的結構]、行為型[對在不同的物件之間劃分責任和演算法的抽象化]）共23種設計模式，包括：Abstract Factory（抽象工廠模式），Builder（建造者模式），Factory Method（工廠方法模式），Prototype（原始模型模式），Singleton（單例模式）；Facade（門面模式），Adapter（介面卡模式），Bridge（橋樑模式），Composite（合成模式），Decorator（裝飾模式），Flyweight（享元模式），Proxy（代理模式）；Command（命令模式），Interpreter（直譯器模式），Visitor（訪問者模式），Iterator（迭代子模式），Mediator（調停者模式），Memento（備忘錄模式），Observer（觀察者模式），State（狀態模式），Strategy（策略模式），Template Method（模板方法模式）， Chain Of Responsibility（責任鏈模式）。
面試被問到關於設計模式的知識時，可以揀最常用的作答，例如：

工廠模式：工廠類可以根據條件生成不同的子類例項，這些子類有一個公共的抽象父類並且實現了相同的方法，但是這些方法針對不同的資料進行了不同的操作（多型方法）。當得到子類的例項後，開發人員可以呼叫基類中的方法而不必考慮到底返回的是哪一個子類的例項。
代理模式：給一個物件提供一個代理物件，並由代理物件控制原物件的引用。實際開發中，按照使用目的的不同，代理可以分為：遠端代理、虛擬代理、保護代理、Cache代理、防火牆代理、同步化代理、智慧引用代理。
介面卡模式：把一個類的介面變換成客戶端所期待的另一種介面，從而使原本因介面不匹配而無法在一起使用的類能夠一起工作。
模板方法模式：提供一個抽象類，將部分邏輯以具體方法或構造器的形式實現，然後宣告一些抽象方法來迫使子類實現剩餘的邏輯。不同的子類可以以不同的方式實現這些抽象方法（多型實現），從而實現不同的業務邏輯。
除此之外，還可以講講上面提到的門面模式、橋樑模式、單例模式、裝潢模式（Collections工具類和I/O系統中都使用裝潢模式）等，反正基本原則就是揀自己最熟悉的、用得最多的作答，以免言多必失。

91、用Java寫一個單例類。

答：

餓漢式單例

public class Singleton {
    private Singleton(){}
    private static Singleton instance = new Singleton();
    public static Singleton getInstance(){
        return instance;
    }
}

懶漢式單例

public class Singleton {
    private static Singleton instance = null;
    private Singleton() {}
    public static synchronized Singleton getInstance(){
        if (instance == null) instance ＝ new Singleton();
        return instance;
    }
}

注意：實現一個單例有兩點注意事項，①將構造器私有，不允許外界通過構造器建立物件；②通過公開的靜態方法向外界返回類的唯一例項。這裡有一個問題可以思考：Spring的IoC容器可以為普通的類建立單例，它是怎麼做到的呢？

92、什麼是UML？

答：UML是統一建模語言（Unified Modeling Language）的縮寫，它發表於1997年，綜合了當時已經存在的面向物件的建模語言、方法和過程，是一個支援模型化和軟體系統開發的圖形化語言，為軟體開發的所有階段提供模型化和視覺化支援。使用UML可以幫助溝通與交流，輔助應用設計和文件的生成，還能夠闡釋系統的結構和行為。

93、UML中有哪些常用的圖？

答：UML定義了多種圖形化的符號來描述軟體系統部分或全部的靜態結構和動態結構，包括：用例圖（use case diagram）、類圖（class diagram）、時序圖（sequence diagram）、協作圖（collaboration diagram）、狀態圖（statechart diagram）、活動圖（activity diagram）、構件圖（component diagram）、部署圖（deployment diagram）等。在這些圖形化符號中，有三種圖最為重要，分別是：用例圖（用來捕獲需求，描述系統的功能，通過該圖可以迅速的瞭解系統的功能模組及其關係）、類圖（描述類以及類與類之間的關係，通過該圖可以快速瞭解系統）、時序圖（描述執行特定任務時物件之間的互動關係以及執行順序，通過該圖可以瞭解物件能接收的訊息也就是說物件能夠向外界提供的服務）。
用例圖：

類圖：

時序圖：

94、用Java寫一個氣泡排序。

答：氣泡排序幾乎是個程式設計師都寫得出來，但是面試的時候如何寫一個逼格高的氣泡排序卻不是每個人都能做到，下面提供一個參考程式碼：

import java.util.Comparator;

/**
 * 排序器介面(策略模式: 將演算法封裝到具有共同介面的獨立的類中使得它們可以相互替換)
 * @author nnngu
 *
 */
public interface Sorter {

   /**
    * 排序
    * @param list 待排序的陣列
    */
   public <T extends Comparable<T>> void sort(T[] list);

   /**
    * 排序
    * @param list 待排序的陣列
    * @param comp 比較兩個物件的比較器
    */
   public <T> void sort(T[] list, Comparator<T> comp);
}

import java.util.Comparator;

/**
 * 氣泡排序
 * 
 * @author nnngu
 *
 */
public class BubbleSorter implements Sorter {

    @Override
    public <T extends Comparable<T>> void sort(T[] list) {
        boolean swapped = true;
        for (int i = 1, len = list.length; i < len && swapped; ++i) {
            swapped = false;
            for (int j = 0; j < len - i; ++j) {
                if (list[j].compareTo(list[j + 1]) > 0) {
                    T temp = list[j];
                    list[j] = list[j + 1];
                    list[j + 1] = temp;
                    swapped = true;
                }
            }
        }
    }

    @Override
    public <T> void sort(T[] list, Comparator<T> comp) {
        boolean swapped = true;
        for (int i = 1, len = list.length; i < len && swapped; ++i) {
            swapped = false;
            for (int j = 0; j < len - i; ++j) {
                if (comp.compare(list[j], list[j + 1]) > 0) {
                    T temp = list[j];
                    list[j] = list[j + 1];
                    list[j + 1] = temp;
                    swapped = true;
                }
            }
        }
    }
}

95、用Java寫一個折半查詢。

答：折半查詢，也稱二分查詢、二分搜尋，是一種在有序陣列中查詢某一特定元素的搜尋演算法。搜素過程從陣列的中間元素開始，如果中間元素正好是要查詢的元素，則搜素過程結束；如果某一特定元素大於或者小於中間元素，則在陣列大於或小於中間元素的那一半中查詢，而且跟開始一樣從中間元素開始比較。如果在某一步驟陣列已經為空，則表示找不到指定的元素。這種搜尋演算法每一次比較都使搜尋範圍縮小一半，其時間複雜度是O(logN)。

import java.util.Comparator;

public class MyUtil {

   public static <T extends Comparable<T>> int binarySearch(T[] x, T key) {
      return binarySearch(x, 0, x.length- 1, key);
   }

   // 使用迴圈實現的二分查詢
   public static <T> int binarySearch(T[] x, T key, Comparator<T> comp) {
      int low = 0;
      int high = x.length - 1;
      while (low <= high) {
          int mid = (low + high) >>> 1;
          int cmp = comp.compare(x[mid], key);
          if (cmp < 0) {
            low= mid + 1;
          }
          else if (cmp > 0) {
            high= mid - 1;
          }
          else {
            return mid;
          }
      }
      return -1;
   }

   // 使用遞迴實現的二分查詢
   private static<T extends Comparable<T>> int binarySearch(T[] x, int low, int high, T key) {
      if(low <= high) {
        int mid = low + ((high - low) >> 1);
        if(key.compareTo(x[mid])== 0) {
           return mid;
        }
        else if(key.compareTo(x[mid])< 0) {
           return binarySearch(x,low, mid - 1, key);
        }
        else {
           return binarySearch(x,mid + 1, high, key);
        }
      }
      return -1;
   }
}

說明：上面的程式碼中給出了折半查詢的兩個版本，一個用遞迴實現，一個用迴圈實現。需要注意的是計算中間位置時不應該使用(high+ low) / 2的方式，因為加法運算可能導致整數越界，這裡應該使用以下三種方式之一：low + (high - low) / 2或low + (high – low) >> 1或(low + high) >>> 1（>>>是邏輯右移，是不帶符號位的右移）

我有一個微信公眾號，經常會分享一些Java技術相關的乾貨；如果你喜歡我的分享，可以用微信搜尋“Java團長”或者“javatuanzhang”關注。

近5年常考Java面試題及答案整理（三）

近5年常考Java面試題及答案整理（一）

近5年常考Java面試題及答案整理（二）

近5年常考Java面試題及答案整理（三）

近5年常考Java面試題及答案整理（一）

近5年常考Java面試題及答案整理（二）

分享10道常考Java面試題及答案

2018年最新Java面試題及答案整理(持續完善中…)

115個Java面試題和答案——終極（上）

Java中級面試題及答案解析（8）

大資料面試題以及答案整理（一）

大資料開發工程師面試題以及答案整理（一）

Spring 面試題及答案解析（7）

spring面試題及答案解析（7）

96道常考Java面試題，分享給大家，含答案

最近 5 年 133 個 Java 面試題，你都會了嗎?

2018年最新JAVA面試題總結之資料庫（3）

2018年最新JAVA面試題總結之基礎（1）

2018年最新JAVA面試題總結之框架（4）

100+經典Java面試題及答案解析

華為的JAVA面試題及答案（部分）

面試必備，java常見基礎面試題及答案整理！

115道經典Java面試題及答案解析，掌握這些還怕面試官不下”跪“

近5年常考Java面試題及答案整理（三）

相關推薦