1、如何實現字串的反轉及替換？
答：方法很多，可以自己寫實現也可以使用String或StringBuffer/StringBuilder中的方法。
有一道很常見的面試題是用遞迴實現字串反轉，程式碼如下所示：

public static String reverse(String originStr) {
    if(originStr == null || originStr.length() <= 1) 
        return originStr;
    return reverse(originStr.substring(1)) + originStr.charAt(0
 
);
}

2、怎樣將GB2312編碼的字串轉換為ISO-8859-1編碼的字串？
答：程式碼如下所示：

String s1 = "你好";
String s2 = new String(s1.getBytes("GB2312"), "ISO-8859-1");

3、列印昨天的當前時刻。
答：

import java.util.Calendar;

class YesterdayCurrent {
    public static void main(String[] args){
        Calendar cal = Calendar.getInstance();
 

        cal.add(Calendar.DATE, -1);
        System.out.println(cal.getTime());
    }
}

在Java 8中，可以用下面的程式碼實現相同的功能。

import java.time.LocalDateTime;

class YesterdayCurrent {

    public static void main(String[] args) {
        LocalDateTime today = LocalDateTime.now();
        LocalDateTime yesterday = today.minusDays(1
 
);

        System.out.println(yesterday);
    }
}

補充：Java的時間日期API一直以來都是被詬病的東西，為了解決這一問題，Java 8中引入了新的時間日期API，其中包括LocalDate、LocalTime、LocalDateTime、Clock、Instant等類，這些的類的設計都使用了不變模式，因此是執行緒安全的設計。如果不理解這些內容，可以參考另一篇文章《關於Java併發程式設計的總結和思考》。

4、try{}裡有一個return語句，那麼緊跟在這個try後的finally{}裡的程式碼會不會被執行，什麼時候被執行，在return前還是後?
答：會執行，在方法返回呼叫者前執行。

注意：在finally中改變返回值的做法是不好的，因為如果存在finally程式碼塊，try中的return語句不會立馬返回呼叫者，而是記錄下返回值待finally程式碼塊執行完畢之後再向呼叫者返回其值，然後如果在finally中修改了返回值，就會返回修改後的值。顯然，在finally中返回或者修改返回值會對程式造成很大的困擾，應該避免這種做法。

5、List、Set、Map是否繼承自Collection介面？
答：List、Set 是，Map 不是。Map是鍵值對對映容器，與List和Set有明顯的區別，而Set儲存的零散的元素且不允許有重複元素（數學中的集合也是如此），List是線性結構的容器，適用於按數值索引訪問元素的情形。

6、Collection和Collections的區別？
答：Collection是一個介面，它是Set、List等容器的父介面；Collections是個一個工具類，提供了一系列的靜態方法來輔助容器操作，這些方法包括對容器的搜尋、排序、執行緒安全化等等。

7、List、Map、Set三個介面存取元素時，各有什麼特點？
答：List以特定索引來存取元素，可以有重複元素。Set不能存放重複元素（用物件的equals()方法來區分元素是否重複）。Map儲存鍵值對（key-value pair）對映，對映關係可以是一對一或多對一。Set和Map容器都有基於雜湊儲存和排序樹的兩種實現版本，基於雜湊儲存的版本理論存取時間複雜度為O(1)，而基於排序樹版本的實現在插入或刪除元素時會按照元素或元素的鍵（key）構成排序樹從而達到排序和去重的效果。

8、Thread類的sleep()方法和物件的wait()方法都可以讓執行緒暫停執行，它們有什麼區別?
答：sleep()方法（休眠）是執行緒類（Thread）的靜態方法，呼叫此方法會讓當前執行緒暫停執行指定的時間，將執行機會（CPU）讓給其他執行緒，但是物件的鎖依然保持，因此休眠時間結束後會自動恢復（執行緒回到就緒狀態，請參考第66題中的執行緒狀態轉換圖）。wait()是Object類的方法，呼叫物件的wait()方法導致當前執行緒放棄物件的鎖（執行緒暫停執行），進入物件的等待池（wait pool），只有呼叫物件的notify()方法（或notifyAll()方法）時才能喚醒等待池中的執行緒進入等鎖池（lock pool），如果執行緒重新獲得物件的鎖就可以進入就緒狀態。

補充：可能不少人對什麼是程序，什麼是執行緒還比較模糊，對於為什麼需要多執行緒程式設計也不是特別理解。簡單的說：程序是具有一定獨立功能的程式關於某個資料集合上的一次執行活動，是作業系統進行資源分配和排程的一個獨立單位；執行緒是程序的一個實體，是CPU排程和分派的基本單位，是比程序更小的能獨立執行的基本單位。執行緒的劃分尺度小於程序，這使得多執行緒程式的併發性高；程序在執行時通常擁有獨立的記憶體單元，而執行緒之間可以共享記憶體。使用多執行緒的程式設計通常能夠帶來更好的效能和使用者體驗，但是多執行緒的程式對於其他程式是不友好的，因為它可能佔用了更多的CPU資源。當然，也不是執行緒越多，程式的效能就越好，因為執行緒之間的排程和切換也會浪費CPU時間。時下很時髦的Node.js就採用了單執行緒非同步I/O的工作模式。

9、編寫多執行緒程式有幾種實現方式？
答：Java 5以前實現多執行緒有兩種實現方法：一種是繼承Thread類；另一種是實現Runnable介面。兩種方式都要通過重寫run()方法來定義執行緒的行為，推薦使用後者，因為Java中的繼承是單繼承，一個類有一個父類，如果繼承了Thread類就無法再繼承其他類了，顯然使用Runnable介面更為靈活。

補充：Java 5以後建立執行緒還有第三種方式：實現Callable介面，該介面中的call方法可以線上程執行結束時產生一個返回值，程式碼如下所示：

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

class MyTask implements Callable<Integer> {
    private int upperBounds;

    public MyTask(int upperBounds) {
        this.upperBounds = upperBounds;
    }

    @Override
    public Integer call() throws Exception {
        int sum = 0; 
        for(int i = 1; i <= upperBounds; i++) {
            sum += i;
        }
        return sum;
    }

}

class Test {

    public static void main(String[] args) throws Exception {
        List<Future<Integer>> list = new ArrayList<>();
        ExecutorService service = Executors.newFixedThreadPool(10);
        for(int i = 0; i < 10; i++) {
            list.add(service.submit(new MyTask((int) (Math.random() * 100))));
        }

        int sum = 0;
        for(Future<Integer> future : list) {
            // while(!future.isDone()) ;
            sum += future.get();
        }

        System.out.println(sum);
    }
}

10、synchronized關鍵字的用法？
答：synchronized關鍵字可以將物件或者方法標記為同步，以實現對物件和方法的互斥訪問，可以用synchronized(物件) { … }定義同步程式碼塊，或者在宣告方法時將synchronized作為方法的修飾符。

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

12、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中釋放外部資源 ，從而讓程式碼更加優雅。