Java高級面試題

• 網絡編程
• • 簡答題
• NIO(Netty)
• JVM
• • 選擇題
  • 簡答題
  • • java的四種引用，強弱軟虛，用到的場景
    • OOM
    • 運行時數據區域
    • 垃圾收集
• 多線程（并發）編程
• • 選擇題
  • 填空題
  • 簡答題
  • • 定義類ThdTest，其父類為Thread類；并在主方法中創建一個ThdTest的對象，同時啟動該線程對象。
    • 線程狀態轉換
    • Thread與Runable如何實現多線程**
    • 線程同步的方法有什么
    • 線程鎖的等級
    • 生產者消費者模式的幾種實現
    • wait()和sleep()的區別
    • IO框架主要用到什么設計模式
    • volatile變量修飾符
    • 多線程環境中安全使用集合API
    • 死鎖
    • 什么是多線程
    • 說一下多線程的好處
    • 線程和進程有什么區別
    • 什么是線程同步. ? 異步
    • 線程之間如何同步
    • 什么是線程不安全？如何解決？
    • 如何創建一個線程？有幾種方法？
    • sleep()和 wait()有什么區別？
  • 參考
• 設計模式
• 源碼分析
• 數據庫設計
• • 簡答題
  • • MySQL
    • 基礎知識
    • 什么是事務
    • MySQL -SQL
• 算法
• • 簡答題
  • 編程題
  • • 有序數組的 Two Sum
• 數據結構
• • 選擇題
  • 填空題
  • 簡答題
  • • • 數據結構——樹——知識點總結
      • 找出兩個鏈表的交點
    • 樹的高度
    • 數組中兩個數的和為給定值
  • 編程題
• 容器
• • 選擇題
  • 填空題
  • 簡答題
  • 編程題
• 協議
• • 簡答題
  • • TCP的三次握手和四次揮手，瀏覽器訪問一個網址的過程
    • TCP與UDP區別
    • HTTP、HTTPS區別

網絡編程

簡答題

• 網絡中的每臺計算機都必須有一個唯一的 IP 地址作為標識。
• 通常IP地址寫作一組有 “.”號分隔的 十 進制數。
• IPv4規定的IP地址都是 32 位地址。
• IPv6的地址是 48 位無符號整數。
• 假若要編寫一個網絡通信程序，則需在程序最開頭引用 java.net 類包。
• 通常IP地址均有4個部分組成，每個部分的范圍都是0～ 255 。
• 在java.net包中，IP地址由一個稱為 InetAddress 的特殊的類來描述。
• 通常端口號的取值范圍為0～ 65535 之間。
• 通常0～ 1023 間的端口號作為保留端口號。
• UDP 協議不保證數據傳輸的可靠性。
• 在網絡通信程序中，使用 端口號 來標識正在運行的進程。
• 兩種常用的網絡通信協議是 TCP 和 UDP 。
• TCP 是面向連接的通信協議。
• UDP 是無連接的通信協議。
• Transmission Control Protocol指的是 傳輸控制協議 。
• UDP的英文全稱為 Use Datagram Packet 。
• TCP 協議提供的是可靠無差錯的數據傳輸。
• 在TCP/IP中， socket 是由IP地址與端口號組成。
• 在建立套接字連接過程中，通常把負責監聽的一方稱為 服務器 。
• 客戶端使用 Socket 類建立套接字連接。
• 編寫網絡服務器程序說，使用 ServerSocket 類來創建服務器端的連接。
• Socket提供了兩臺不同計算機上執行的應用程序之間進行連接的功能。
• 服務器端使用 accept 方法監聽客戶端發起的連接請求。
• Socket獲取輸入/輸出流的兩個主要方法是：getInputStream()和getOutputStream() 。
• 網絡數據通信，通常采用 流式通信 模式。
• 在服務器端程序中應用 多線程 技術同時處理多個客戶端的連接請求。
• 基于UDP網絡程序設計中，使用 DatagramSocket 類來創建套接字連接。
• DatagramSocket類的實例對象使用 send() 方法發送數據。
• DatagramSocket類的實例對象使用 receive() 方法接收數據。
• DatagramPacket 類用于將要發送的數據打包或將已經接收到的數據進行拆包。
• 關閉套接字需使用 close() 方法。

NIO(Netty)

JVM

選擇題

• 下列哪些語句關于內存回收的說明是正確的? ( D )
  A. ? 程序員必須創建一個線程來釋放內存；
  B. ? 內存回收程序負責釋放無用內存
  C. ? 內存回收程序允許程序員直接釋放內存
  D. ? 內存回收程序可以在指定的時間釋放內存對象

簡答題

java的四種引用，強弱軟虛，用到的場景

JDK1.2之前只有強引用,其他幾種引用都是在JDK1.2之后引入的.

強引用（Strong Reference） 最常用的引用類型，如Object obj = new Object(); 。只要強引用存在則GC時則必定不被回收。

軟引用（Soft Reference） 用于描述還有用但非必須的對象，當堆將發生OOM（Out Of Memory）時則會回收軟引用所指向的內存空間，若回收后依然空間不足才會拋出OOM。一般用于實現內存敏感的高速緩存。 當真正對象被標記finalizable以及的finalize()方法調用之后并且內存已經清理, 那么如果SoftReference object還存在就被加入到它的 ReferenceQueue.只有前面幾步完成后,Soft Reference和Weak Reference的get方法才會返回null

弱引用（Weak Reference） 發生GC時必定回收弱引用指向的內存空間。 和軟引用加入隊列的時機相同

虛引用（Phantom Reference) 又稱為幽靈引用或幻影引用，虛引用既不會影響對象的生命周期，也無法通過虛引用來獲取對象實例，僅用于在發生GC時接收一個系統通知。 當一個對象的finalize方法已經被調用了之后，這個對象的幽靈引用會被加入到隊列中。通過檢查該隊列里面的內容就知道一個對象是不是已經準備要被回收了. 虛引用和軟引用和弱引用都不同,它會在內存沒有清理的時候被加入引用隊列.虛引用的建立必須要傳入引用隊列,其他可以沒有

OOM

? OutOfMemoryError異常

除了程序計數器外，虛擬機內存的其他幾個運行時區域都有發生OutOfMemoryError(OOM)異常的可能，

? Java Heap 溢出

一般的異常信息：java.lang.OutOfMemoryError:Java heap spacess

java堆用于存儲對象實例，我們只要不斷的創建對象，并且保證GC Roots到對象之間有可達路徑來避免垃圾回收機制清除這些對象，就會在對象數量達到最大堆容量限制后產生內存溢出異常。

出現這種異常，一般手段是先通過內存映像分析工具(如Eclipse Memory Analyzer)對dump出來的堆轉存快照進行分析，重點是確認內存中的對象是否是必要的，先分清是因為內存泄漏(Memory Leak)還是內存溢出(Memory Overflow)。

如果是內存泄漏，可進一步通過工具查看泄漏對象到GC Roots的引用鏈。于是就能找到泄漏對象時通過怎樣的路徑與GC Roots相關聯并導致垃圾收集器無法自動回收。

如果不存在泄漏，那就應該檢查虛擬機的參數(-Xmx與-Xms)的設置是否適當。

虛擬機棧和本地方法棧溢出

如果線程請求的棧深度大于虛擬機所允許的最大深度，將拋出StackOverflowError異常。

如果虛擬機在擴展棧時無法申請到足夠的內存空間，則拋出OutOfMemoryError異常

這里需要注意當棧的大小越大可分配的線程數就越少。

? 運行時常量池溢出

異常信息：java.lang.OutOfMemoryError:PermGen space

如果要向運行時常量池中添加內容，最簡單的做法就是使用String.intern()這個Native方法。該方法的作用是：如果池中已經包含一個等于此String的字符串，則返回代表池中這個字符串的String對象；否則，將此String對象包含的字符串添加到常量池中，并且返回此String對象的引用。由于常量池分配在方法區內，我們可以通過-XX:PermSize和-XX:MaxPermSize限制方法區的大小，從而間接限制其中常量池的容量。

? 方法區溢出

方法區用于存放Class的相關信息，如類名. ? 訪問修飾符. ? 常量池. ? 字段描述. ? 方法描述等。

異常信息：java.lang.OutOfMemoryError:PermGen space

方法區溢出也是一種常見的內存溢出異常，一個類如果要被垃圾收集器回收，判定條件是很苛刻的。在經常動態生成大量Class的應用中，要特別注意這點。

運行時數據區域

（1）程序計數器

記錄正在執行的虛擬機字節碼指令的地址（如果正在執行的是本地方法則為空）。

（2）Java 虛擬機棧

每個 Java 方法在執行的同時會創建一個棧幀用于存儲局部變量表. ? 操作數棧. ? 常量池引用等信息。從方法調用直至執行完成的過程，對應著一個棧幀在 Java 虛擬機棧中入棧和出棧的過程。

可以通過 -Xss 這個虛擬機參數來指定每個線程的 Java 虛擬機棧內存大小，在 JDK 1.4 中默認為 256K，而在 JDK 1.5+ 默認為 1M：

java -Xss2M HackTheJava

該區域可能拋出以下異常：

? 當線程請求的棧深度超過最大值，會拋出 StackOverflowError 異常；

? 棧進行動態擴展時如果無法申請到足夠內存，會拋出 OutOfMemoryError 異常。

（3）本地方法棧

本地方法棧與 Java 虛擬機棧類似，它們之間的區別只不過是本地方法棧為本地方法服務。

本地方法一般是用其它語言（C. ? C++ 或匯編語言等）編寫的，并且被編譯為基于本機硬件和操作系統的程序，對待這些方法需要特別處理。

（4）堆

所有對象都在這里分配內存，是垃圾收集的主要區域（“GC 堆”）。

現代的垃圾收集器基本都是采用分代收集算法，其主要的思想是針對不同類型的對象采取不同的垃圾回收算法。可以將堆分成兩塊：

新生代（Young Generation）

老年代（Old Generation）

堆不需要連續內存，并且可以動態增加其內存，增加失敗會拋出 OutOfMemoryError 異常。

可以通過 -Xms 和 -Xmx 這兩個虛擬機參數來指定一個程序的堆內存大小，第一個參數設置初始值，第二個參數設置最大值。

java -Xms1M -Xmx2M HackTheJava

（5）方法區

用于存放已被加載的類信息. ? 常量. ? 靜態變量. ? 即時編譯器編譯后的代碼等數據。

和堆一樣不需要連續的內存，并且可以動態擴展，動態擴展失敗一樣會拋出 OutOfMemoryError 異常。

對這塊區域進行垃圾回收的主要目標是對常量池的回收和對類的卸載，但是一般比較難實現。

HotSpot 虛擬機把它當成永久代來進行垃圾回收。但很難確定永久代的大小，因為它受到很多因素影響，并且每次 Full GC 之后永久代的大小都會改變，所以經常會拋出 OutOfMemoryError 異常。為了更容易管理方法區，從 JDK 1.8 開始，移除永久代，并把方法區移至元空間，它位于本地內存中，而不是虛擬機內存中。

方法區是一個 JVM 規范，永久代與元空間都是其一種實現方式。在 JDK 1.8 之后，原來永久代的數據被分到了堆和元空間中。元空間存儲類的元信息，靜態變量和常量池等放入堆中。

（6）運行時常量池

（7）直接內存

在 JDK 1.4 中新引入了 NIO 類，它可以使用 Native 函數庫直接分配堆外內存，然后通過 Java 堆里的 DirectByteBuffer 對象作為這塊內存的引用進行操作。這樣能在一些場景中顯著提高性能，因為避免了在堆內存和堆外內存來回拷貝數據。

垃圾收集

垃圾收集主要是針對堆和方法區進行。程序計數器. ? 虛擬機棧和本地方法棧這三個區域屬于線程私有的，只存在于線程的生命周期內，線程結束之后就會消失，因此不需要對這三個區域進行垃圾回收。

（1）判斷一個對象是否可被回收

① 引用計數算法

為對象添加一個引用計數器，當對象增加一個引用時計數器加 1，引用失效時計數器減 1。引用計數為 0 的對象可被回收。

在兩個對象出現循環引用的情況下，此時引用計數器永遠不為 0，導致無法對它們進行回收。正是因為循環引用的存在，因此 Java 虛擬機不使用引用計數算法。

② 可達性分析算法

以 GC Roots 為起始點進行搜索，可達的對象都是存活的，不可達的對象可被回收。

Java 虛擬機使用該算法來判斷對象是否可被回收，GC Roots 一般包含以下內容：

虛擬機棧中局部變量表中引用的對象

本地方法棧中 JNI 中引用的對象

方法區中類靜態屬性引用的對象

方法區中的常量引用的對象

③ 方法區的回收

因為方法區主要存放永久代對象，而永久代對象的回收率比新生代低很多，所以在方法區上進行回收性價比不高。

主要是對常量池的回收和對類的卸載。

為了避免內存溢出，在大量使用反射和動態代理的場景都需要虛擬機具備類卸載功能。

類的卸載條件很多，需要滿足以下三個條件，并且滿足了條件也不一定會被卸載：

該類所有的實例都已經被回收，此時堆中不存在該類的任何實例。

加載該類的 ClassLoader 已經被回收。

該類對應的 Class 對象沒有在任何地方被引用，也就無法在任何地方通過反射訪問該類方法。

④ finalize()

類似 C++ 的析構函數，用于關閉外部資源。但是 try-finally 等方式可以做得更好，并且該方法運行代價很高，不確定性大，無法保證各個對象的調用順序，因此最好不要使用。

當一個對象可被回收時，如果需要執行該對象的 finalize() 方法，那么就有可能在該方法中讓對象重新被引用，從而實現自救。自救只能進行一次，如果回收的對象之前調用了 finalize() 方法自救，后面回收時不會再調用該方法。

多線程（并發）編程

選擇題

• 下列關于Java線程的說法那些是正確的（ D ）
  A. ? 每一個Java線程可以看成由代碼. ? 一個真實的CPU以及數據三部份組成。
  B. ? 創建線程的兩種方法中，從Thread類中繼承的創建方式可以防止出現多父類問題。
  C. ? Thread類屬于java.util程序包。
  D. ? 以上說法無一正確。

• 下面哪個不是Thread類的方法?（ C ）
  A. ? yield()
  B. ? sleep(long msec)
  C. ? go()
  D. ? stop()

• 運行下列程序, 會產生什么結果 ( A 應該是runnable )

public class X extends Thread implements Runable{ public void run(){ System.out.println("this is run()"); } public static void main(String args[]) { Thread t=new Thread(new X()); t.start(); } }

??A. ? 第一行會產生編譯錯誤
??B. ? 第六行會產生編譯錯誤
??C. ? 第六行會產生運行錯誤
??D. ? 程序會運行和啟動

• 運行下列程序, 會產生什么結果 ( D )

public class X extends Thread implements Runable{ public void run(){ System.out.println("this is run()"); } public static void main(String args[]) { Thread t=new　Thread(new X()); t.start(); } }

??A. ? in the Inner outer
??B. ? outer
??C. ? in the Inner
??D. ? 編譯不通過

填空題

• 實現并發機制的一種有效手段是 多線程 。
• 一個程序具備同時執行不同任務的能力，這種能力稱為 并發 。
• 每個線程都經歷創建. ? 就緒. ? 運行. ? 阻塞和 死亡 等5個狀態。
• 處于就緒狀態的線程何時可真正的執行，取決于線程的 優先級以及隊列當前狀況。
• 在Java系統中，線程調度依據優先級基礎上的 搶奪式調度 原則。
• Java提供的 監視器機制，可以避免對象在內存中的數據資源的沖突。
• 在單線程的進程中，一個進程一次只能執行 1 個任務。
• Java線程同步機制提供關鍵字 Synchronized ，用于修飾可能引起資源沖突的方法。
• 優先級低**的線程獲得CPU的機會也比較 **小。
• 低優先級線程在較長時間內無法獲得運行機會的現象就是所謂的餓死。
• 創建多線程的途徑有兩種：創建Thread類的子類與實現Runnable 接口。
• 線程是比進程更 小 的執行單位。
• 一個進程在其執行的過程中，可以產生 多 個線程。
• 程序的一次動態執行過程，則稱為 進程 。
• 程序是一段靜態的代碼，它是應用軟件執行的藍本。
• 一個正在執行的線程由于系統或人為原因被迫讓出CPU的使用權，這種現象稱為 阻塞 。
• 一個進入阻塞狀態的線程，只有當引起阻塞的原因被消除時，線程才可以轉入 就緒 狀態。
• 假若一個正在執行的線程被人為中斷，那么該線程會暫時中止自己的執行，進入 就緒 狀態。
• 線程的優先級范圍用數字表示：0～10，那么一個線程的默認優先級是 5 。
• 線程釋放分配給線程對象的內存，就是所謂的 死亡 狀態。
• 進入線程的生命周期的第一個狀態是 新建 狀態。
• 假若要實現Runnable接口，就必須具體實現接口中的 run（）方法。
• 線程調用 start 方法來啟動線程。
• 當一個線程執行完run()方法時，線程進入 死亡 狀態。
• 線程調用 sleep（） 方法來使自己放棄處理器資源，休眠一段時間。
• sleep(int)方法中，休眠時間的單位為 毫秒 。
• 判斷當前正在占有CPU的線程的方法是 currentthread（） 。
• Runnable接口中只有一個 run 方法。
• 線程同步機制中，調用 wait（） 方法使線程進入等待狀態。
• 通知線程狀態的變化并喚醒另一個等待線程，需應用 notify（） 方法。
• 所有等待的線程將無休止地等待下去，就是所謂的 死鎖 。
• 當兩個或多個線程要同時訪問共享數據時，一次只允許一個線程訪問共享 資源，支持這種互斥機制稱為 同步 。
• Java多線程編程中，用 Synchronized 來標識的區域或方法為鎖定的資源。
• 在Java中，運行環境使用 監視器 來解決線程同步的問題。
• 線程同步執行過程中，wait()方法與 notify（） 方法是匹配使用，否則易造成死鎖。
• 在特定應用程序中所有的線程處在等待狀態，并且相互等待其他線程喚醒，這種現象稱為 死鎖 。

簡答題

定義類ThdTest，其父類為Thread類；并在主方法中創建一個ThdTest的對象，同時啟動該線程對象。

public class TestDemo {public static void main(String[] args) {new ThdTest().start();System.out.println(Thread.currentThread().getName());}}//聲明類ThdTest，其父類為Thread類class ThdTest extends Thread {@Overridepublic void run() {for (int i = 0; i < 10; i++) {Thread.currentThread().setName("第【" + i + "】線程");try {Thread.sleep(100);System.out.println(Thread.currentThread().getName() + "\t" + Thread.currentThread().getId());} catch (InterruptedException ex) {throw new RuntimeException("因為未知原因【" + i + "】線程中斷");}}}}

線程狀態轉換

? 新建（New）

創建后尚未啟動。

? 可運行（Runnable）

可能正在運行，也可能正在等待 CPU 時間片。

包含了操作系統線程狀態中的 Running 和 Ready。

? 阻塞（Blocked）

等待獲取一個排它鎖，如果其線程釋放了鎖就會結束此狀態。

? 無限期等待（Waiting）

等待其它線程顯式地喚醒，否則不會被分配 CPU 時間片。

進入方法 退出方法
沒有設置 Timeout 參數的 Object.wait() 方法 Object.notify() / Object.notifyAll()
沒有設置 Timeout 參數的 Thread.join() 方法 被調用的線程執行完畢
LockSupport.park() 方法 LockSupport.unpark(Thread)

? 限期等待（Timed Waiting）

無需等待其它線程顯式地喚醒，在一定時間之后會被系統自動喚醒。

調用 Thread.sleep() 方法使線程進入限期等待狀態時，常常用“使一個線程睡眠”進行描述。

調用 Object.wait() 方法使線程進入限期等待或者無限期等待時，常常用“掛起一個線程”進行描述。

睡眠和掛起是用來描述行為，而阻塞和等待用來描述狀態。

阻塞和等待的區別在于，阻塞是被動的，它是在等待獲取一個排它鎖。而等待是主動的，通過調用 Thread.sleep() 和 Object.wait() 等方法進入。

進入方法 退出方法
Thread.sleep() 方法 時間結束
設置了 Timeout 參數的 Object.wait() 方法 時間結束 / Object.notify() / Object.notifyAll()
設置了 Timeout 參數的 Thread.join() 方法 時間結束 / 被調用的線程執行完畢
LockSupport.parkNanos() 方法 LockSupport.unpark(Thread)
LockSupport.parkUntil() 方法 LockSupport.unpark(Thread)

? 死亡（Terminated）

可以是線程結束任務之后自己結束，或者產生了異常而結束。

Thread與Runable如何實現多線程**

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

實現Runnable接口相比繼承Thread類有如下優勢：

? 可以避免由于Java的單繼承特性而帶來的局限

? 增強程序的健壯性，代碼能夠被多個程序共享，代碼與數據是獨立的

? 適合多個相同程序代碼的線程區處理同一資源的情況

線程同步的方法有什么

鎖，synchronized塊，信號量等。

線程鎖的等級

方法鎖. ? 對象鎖. ? 類鎖

生產者消費者模式的幾種實現

阻塞隊列實現，sync關鍵字實現，lock實現,reentrantLock等。

wait()和sleep()的區別

sleep()方法是線程類（Thread）的靜態方法，導致此線程暫停執行指定時間，將執行機會給其他線程，但是監控狀態依然保持，到時后會自動恢復（線程回到就緒（ready）狀態），因為調用sleep 不會釋放對象鎖。

wait()是Object 類的方法，對此對象調用wait()方法導致本線程放棄對象鎖(線程暫停執行)，進入等待此對象的等待鎖定池，只有針對此對象發出notify 方法（或notifyAll）后本線程才進入對象鎖定池準備獲得對象鎖進入就緒狀態。

IO框架主要用到什么設計模式

JDK的I/O包中就主要使用到了兩種設計模式：Adatper模式和Decorator模式。

volatile變量修飾符

在JDK1.2之前，Java的類型模型實現總是從主存(即共享內存)讀取變量，是不需要進行特別的注意的。而隨著JVM的成熟和優化，現在在多線程環境下volatile關鍵字的使用變的非常重要。

在當前的Java內存模型下，線程可以把變量保存在本地內存(比如機器的寄存器)中，而不是直接在主存中進行讀寫。這就可能造成一個線程在主存中修改了一個變量的值，而另一個線程還在繼續使用它在寄存器中的變量值的拷貝，造成數據的不一致。

要解決這個問題，就需要把變量聲明為volatile，這就指示JVM，這個變量是不穩定的，每次使用它都到主存中進行讀取。一般來說，多任務環境下，各任務間共享的變量都應該加volatile修飾符。

volatile修飾的成員變量在每次被線程訪問時，都強迫從共享內存中重讀該成員變量的值。而且，當成員變量發生變化時，強迫線程將變化值回寫到共享內存。這樣在任何時刻，兩個不同的線程總是看到某個成員變量的同一個值。

Java語言規范中指出：為了獲得最佳速度，允許線程保存成員變量的私有拷貝，而且只當線程進入或者離開同步代碼塊時才將私有拷貝與共享內存中的原始值進行比較。

這樣當多個線程同時與某個對象交互時，就必須注意到要讓線程及時的得到共享成員變量的變化。而volatile關鍵字就是提示JVM：對于這個成員變量，不能保存它的私有拷貝，而應直接與共享成員變量交互。

volatile是一種稍弱的同步機制，在訪問volatile變量時不會執行加鎖操作，也就不會執行線程阻塞，因此volatile變量是一種比synchronized關鍵字更輕量級的同步機制。

使用建議：在兩個或者更多的線程需要訪問的成員變量上使用volatile。當要訪問的變量已在synchronized代碼塊中，或者為常量時，或者為常量時，沒必要使用volatile。

由于使用volatile屏蔽掉了JVM中必要的代碼優化，所以在效率上比較低，因此一定在必要時才使用此關鍵字。

多線程環境中安全使用集合API

在集合API中，最初設計的Vector和Hashtable是多線程安全的。例如：對于Vector來說，用來添加和刪除元素的方法是同步的。如果只有一個線程與Vector的實例交互，那么，要求獲取和釋放對象鎖便是一種浪費，另外在不必要的時候如果濫用同步化，也有可能會帶來死鎖。因此，對于更改集合內容的方法，沒有一個是同步化的。集合本質上是非多線程安全的，當多個線程與集合交互時，為了使它多線程安全，必須采取額外的措施。

在Collections類 中有多個靜態方法，它們可以獲取通過同步方法封裝非同步集合而得到的集合：

public static Collection synchronizedCollention(Collection c)public static List synchronizedList(list l)public static Map synchronizedMap(Map m)public static Set synchronizedSet(Set s)public static SortedMap synchronizedSortedMap(SortedMap sm)public static SortedSet synchronizedSortedSet(SortedSet ss)

這些方法基本上返回具有同步集合方法版本的新類。比如，為了創建多線程安全且由ArrayList支持的List，可以使用如下代碼：

List list = Collection.synchronizedList(new ArrayList());

注意，ArrayList實例馬上封裝起來，不存在對未同步化ArrayList的直接引用（即直接封裝匿名實例）。這是一種最安全的途徑。如果另一個線程要直接引用ArrayList實例，它可以執行非同步修改。

這里需要注意的是：在Java語言中，大部分的線程安全類都是相對線程安全的，它能保證對這個對象單獨的操作時線程安全的，我們在調用的時候不需要額外的保障措施，但是對于一些特定的連續調用，就可能需要在調用端使用額外的同步手段來保證調用的正確性。例如Vector. ? HashTable. ? Collections的synchronizedXxxx（）方法包裝的集合等。

死鎖

當線程需要同時持有多個鎖時，有可能產生死鎖。考慮如下情形：

線程A當前持有互斥所鎖lock1，線程B當前持有互斥鎖lock2。接下來，當線程A仍然持有lock1時，它試圖獲取lock2，因為線程B正持有lock2，因此線程A會阻塞等待線程B對lock2的釋放。如果此時線程B在持有lock2的時候，也在試圖獲取lock1，因為線程A正持有lock1，因此線程B會阻塞等待A對lock1的釋放。二者都在等待對方所持有鎖的釋放，而二者卻又都沒釋放自己所持有的鎖，這時二者便會一直阻塞下去。這種情形稱為死鎖。

什么是多線程

在一個應用程序中,同時，有多個不同的執行路徑。

說一下多線程的好處

提供程序效率。

線程和進程有什么區別

線程是進程的一條執行路徑，而進程是線程的集合。

什么是線程同步. ? 異步

線程同步表示，當前線程執行完后下一個線程接著執行。

線程異步表示, 在一個應用程序中,同時，有多個不同的執行路徑。例如 javaweb ajax android handler

線程之間如何同步

線程之間同步使用 synchronized. ? wait 與 notify

什么是線程不安全？如何解決？

就是在多個線程共享同一個數據會受到其他線程的干擾。如何解決:使用線程同步技術， 用上鎖(synchronized)。 讓一個線程執行完了，在讓另一個線程執行。

如何創建一個線程？有幾種方法？

繼承thread類， 重寫run方法. ? 實現Runnalbe接口，重新run方法 ， 啟動一個線程用start();

sleep()和 wait()有什么區別？

a. ? sleep是讓當前線程指定休眠時間，然后繼續工作 不釋放鎖

b. ? 讓當前線程wait則是等待，直到有線程通知notify（）喚醒他才會重新工作。釋放鎖

參考

多線程(一)：創建線程和線程的常用方法

設計模式

源碼分析

數據庫設計

簡答題

MySQL

• Mysql 的存儲引擎,myisam和innodb的區別？
  1.MyISAM 是非事務的存儲引擎，適合用于頻繁查詢的應用。表鎖，不會出現死鎖，適合小數據，小并發。
  2.innodb是支持事務的存儲引擎，合于插入和更新操作比較多的應用，設計合理的話是行鎖（最大區別就在鎖的級別上），適合大數據，大并發。

• 數據表類型有哪些？
  MyISAM. ? InnoDB. ? HEAP. ? BOB,ARCHIVE,CSV等。
  MyISAM：成熟. ? 穩定. ? 易于管理，快速讀取。一些功能不支持（事務等），表級鎖。
  InnoDB：支持事務. ? 外鍵等特性. ? 數據行鎖定。空間占用大，不支持全文索引等。

• MySQL數據庫作發布系統的存儲，一天五萬條以上的增量，預計運維三年,怎么優化？
  a. 設計良好的數據庫結構，允許部分數據冗余，盡量避免join查詢，提高效率。
  b. 選擇合適的表字段數據類型和存儲引擎，適當的添加索引。
  c. mysql庫主從讀寫分離。
  d. 找規律分表，減少單表中的數據量提高查詢速度。
  e. 添加緩存機制，比如memcached，apc等。
  f. 不經常改動的頁面，生成靜態頁面。
  g. 書寫高效率的SQL。比如 SELECT * FROM TABEL 改為 SELECT field_1, field_2, field_3 FROM TABLE.

• 對于大流量的網站,您采用什么樣的方法來解決各頁面訪問量統計問題？
  a. 確認服務器是否能支撐當前訪問量。
  b. 優化數據庫訪問。
  c. 禁止外部訪問鏈接（盜鏈）, 比如圖片盜鏈。
  d. 控制文件下載。
  e. 使用不同主機分流。
  f. 使用瀏覽統計軟件，了解訪問量，有針對性的進行優化。

• 如何進行SQL優化？
  （1）選擇正確的存儲引擎
  以 MySQL為例，包括有兩個存儲引擎 MyISAM 和 InnoDB，每個引擎都有利有弊。
  MyISAM 適合于一些需要大量查詢的應用，但其對于有大量寫操作并不是很好。甚至你只是需要update一個字段，整個表都會被鎖起來，而別的進程，就算是讀進程都無法操作直到讀操作完成。另外，MyISAM 對于 SELECT COUNT(*) 這類的計算是超快無比的。
  InnoDB 的趨勢會是一個非常復雜的存儲引擎，對于一些小的應用，它會比 MyISAM 還慢。但是它支持“行鎖” ，于是在寫操作比較多的時候，會更優秀。并且，他還支持更多的高級應用，比如：事務。
  （2）優化字段的數據類型
  記住一個原則，越小的列會越快。如果一個表只會有幾列罷了（比如說字典表，配置表），那么，我們就沒有理由使用 INT 來做主鍵，使用 MEDIUMINT, SMALLINT 或是更小的 TINYINT 會更經濟一些。如果你不需要記錄時間，使用 DATE 要比 DATETIME 好得多。當然，你也需要留夠足夠的擴展空間。

  （3）為搜索字段添加索引
  索引并不一定就是給主鍵或是唯一的字段。如果在你的表中，有某個字段你總要會經常用來做搜索，那么最 好 是為其建立索引，除非你要搜索的字段是大的文本字段，那應該建立全文索引。

  (4)避免使用Select
  避免使用Select 從數據庫里讀出越多的數據，那么查詢就會變得越慢。并且，如果你的數據庫服務器和WEB服務器是兩臺獨立的服務器的話，這還會增加網絡傳輸的負載。即使你要查詢數據表的所有字段，也盡 量不要用通配符，善用內置提供的字段排除定義也許能給帶來更多的便利。

  (5)使用 ENUM 而不是 VARCHAR
  ENUM 類型是非常快和緊湊的。在實際上，其保存的是 TINYINT，但其外表上顯示為字符串。這樣一來，用 這個字段來做一些選項列表變得相當的完美。例如，性別. ? 民族. ? 部門和狀態之類的這些字段的取值是有限 而且固定的，那么，你應該使用 ENUM 而不是 VARCHAR。

  (6)盡可能的使用 NOT NULL
  除非你有一個很特別的原因去使用 NULL 值，你應該總是讓你的字段保持 NOT NULL。 NULL其實需要額外的 空間，并且，在你進行比較的時候，你的程序會更復雜。 當然，這里并不是說你就不能使用NULL了，現實情 況是很復雜的，依然會有些情況下，你需要使用NULL值。

  (7)固定長度的表會更快
  如果表中的所有字段都是“固定長度”的，整個表會被認為是 “static” 或 “fixed-length”。 例如，表中沒有如下 類型的字段： VARCHAR，TEXT，BLOB。只要你包括了其中一個這些字段，那么這個表就不是“固定長度靜態 表”了，這樣，MySQL 引擎會用另一種方法來處理。

固定長度的表會提高性能，因為MySQL搜尋得會更快一些，因為這些固定的長度是很容易計算下一個數據的偏移量的，所以讀取的自然也會很快。而如果字段不是定長的，那么，每一次要找下一條的話，需要程序找到主鍵。

并且，固定長度的表也更容易被緩存和重建。不過，唯一的副作用是，固定長度的字段會浪費一些空間，因為定長的字段無論你用不用，他都是要分配那么多的空間。

如何設計一個高并發的系統
① 數據庫的優化，包括合理的事務隔離級別. ? SQL語句優化. ? 索引的優化
② 使用緩存，盡量減少數據庫 IO
③ 分布式數據庫. ? 分布式緩存
④ 服務器的負載均衡

鎖的優化策略
① 讀寫分離
② 分段加鎖
③ 減少鎖持有的時間
④ 多個線程盡量以相同的順序去獲取資源

等等，這些都不是絕對原則，都要根據情況，比如不能將鎖的粒度過于細化，不然可能會出現線程的加鎖和釋放次數過多，反而效率不如一次加一把大鎖。這部分跟面試官談了很久

• 索引的底層實現原理和優化
  B+樹，經過優化的B+樹
  主要是在所有的葉子結點中增加了指向下一個葉子節點的指針，因此InnoDB建議為大部分表使用默認自增的主鍵作為主索引。

• 什么情況下設置了索引但無法使用
  ① 以“%”開頭的LIKE語句，模糊匹配
  ② OR語句前后沒有同時使用索引
  ③ 數據類型出現隱式轉化（如varchar不加單引號的話可能會自動轉換為int型）

• SQL語句的優化
  order by要怎么處理
  alter盡量將多次合并為一次
  insert和delete也需要合并
  等等

• 實踐中如何優化MySQL
  我當時是按以下四條依次回答的，他們四條從效果上第一條影響最大，后面越來越小。
  ① SQL語句及索引的優化
  ② 數據庫表結構的優化
  ③ 系統配置的優化
  ④ 硬件的優化

• sql注入的主要特點
  變種極多，攻擊簡單，危害極大
  sql注入的主要危害
  未經授權操作數據庫的數據
  惡意纂改網頁
  私自添加系統賬號或者是數據庫使用者賬號
  網頁掛木馬

• 優化數據庫的方法
  選取最適用的字段屬性，盡可能減少定義字段寬度，盡量把字段設置NOTNULL，例如’省份’. ? ’性別’最好適用ENUM
  使用連接(JOIN)來代替子查詢
  適用聯合(UNION)來代替手動創建的臨時表
  事務處理
  鎖定表. ? 優化事務處理
  適用外鍵，優化鎖定表
  建立索引
  優化查詢語句

• 簡單描述mysql中，索引，主鍵，唯一索引，聯合索引的區別，對數據庫的性能有什么影響（從讀寫兩方面）
  索引是一種特殊的文件(InnoDB數據表上的索引是表空間的一個組成部分)，它們包含著對數據表里所有記錄的引用指針。
  
  普通索引(由關鍵字KEY或INDEX定義的索引)的唯一任務是加快對數據的訪問速度。
  普通索引允許被索引的數據列包含重復的值。如果能確定某個數據列將只包含彼此各不相同的值，在為這個 數據列創建索引的時候就應該用關鍵字UNIQUE把它定義為一個唯一索引。也就是說，唯一索引可以保證數據 記錄的唯一性。
  
  主鍵，是一種特殊的唯一索引，在一張表中只能定義一個主鍵索引，主鍵用于唯一標識一條記錄，使用關鍵 字 PRIMARY KEY 來創建。
  
  索引可以覆蓋多個數據列，如像INDEX(columnA, columnB)索引，這就是聯合索引。
  
  索引可以極大的提高數據的查詢速度，但是會降低插入. ? 刪除. ? 更新表的速度，因為在執行這些寫操作時， 還要操作索引文件。

• 數據庫中的事務是什么?
  事務（transaction）是作為一個單元的一組有序的數據庫操作。如果組中的所有操作都成功，則認為事務成功，即使只有一個操作失敗，事務也不成功。如果所有操作完成，事務則提交，其修改將作用于所有其他數據庫進程。如果一個操作失敗，則事務將回滾，該事務所有操作的影響都將取消。ACID 四大特性,原子性. ? 隔離性. ? 一致性. ? 持久性。

• 了解XSS攻擊嗎？如何防止？
  XSS是跨站腳本攻擊，首先是利用跨站腳本漏洞以一個特權模式去執行攻擊者構造的腳本，然后利用不安全的Activex控件執行惡意的行為。
  使用htmlspecialchars()函數對提交的內容進行過濾，使字符串里面的特殊符號實體化。

• SQL注入漏洞產生的原因？如何防止？
  SQL注入產生的原因：程序開發過程中不注意規范書寫sql語句和對特殊字符進行過濾，導致客戶端可以通過全局變量POST和GET提交一些sql語句正常執行。

• 防止SQL注入的方式：
  開啟配置文件中的magic_quotes_gpc 和 magic_quotes_runtime設置
  執行sql語句時使用addslashes進行sql語句轉換
  Sql語句書寫盡量不要省略雙引號和單引號。
  過濾掉sql語句中的一些關鍵詞：update. ? insert. ? delete. ? select. ? * 。
  提高數據庫表和字段的命名技巧，對一些重要的字段根據程序的特點命名，取不易被猜到的。
  Php配置文件中設置register_globals為off,關閉全局變量注冊
  控制錯誤信息，不要在瀏覽器上輸出錯誤信息，將錯誤信息寫到日志文件中。

• 為表中得字段選擇合適得數據類型（物理設計）
  字段類型優先級: 整形>date,time>enum,char>varchar>blob,text
  優先考慮數字類型，其次是日期或者二進制類型，最后是字符串類型，同級別得數據類型，應該優先選擇占用空間小的數據類型

• 存儲時期
  Datatime:以 YYYY-MM-DD HH:MM:SS 格式存儲時期時間，精確到秒，占用8個字節得存儲空間，datatime類型與時區無關
  Timestamp:以時間戳格式存儲，占用4個字節，范圍小1970-1-1到2038-1-19，顯示依賴于所指定得時區，默認在第一個列行的數據修改時可以自動得修改timestamp列得值
  Date:（生日）占用得字節數比使用字符串.datatime.int儲存要少，使用date只需要3個字節，存儲日期月份，還可以利用日期時間函數進行日期間得計算
  Time:存儲時間部分得數據
  注意:不要使用字符串類型來存儲日期時間數據（通常比字符串占用得儲存空間小，在進行查找過濾可以利用日期得函數）
  使用int存儲日期時間不如使用timestamp類型

• 對于關系型數據庫而言，索引是相當重要的概念，請回答有關索引的幾個問題：
  a). ? 索引的目的是什么？
  快速訪問數據表中的特定信息，提高檢索速度
  創建唯一性索引，保證數據庫表中每一行數據的唯一性。
  加速表和表之間的連接
  使用分組和排序子句進行數據檢索時，可以顯著減少查詢中分組和排序的時間
  
  b). ? 索引對數據庫系統的負面影響是什么？
  負面影響：
  創建索引和維護索引需要耗費時間，這個時間隨著數據量的增加而增加；索引需要占用物理空間，不光是表需要占用數據空間，每個索引也需要占用物理空間；當對表進行增. ? 刪. ? 改. ? 的時候索引也要動態維護，這樣就降低了數據的維護速度。
  
  c). ? 為數據表建立索引的原則有哪些？
  在最頻繁使用的. ? 用以縮小查詢范圍的字段上建立索引。
  在頻繁使用的. ? 需要排序的字段上建立索引
  
  d). ? 什么情況下不宜建立索引？
  對于查詢中很少涉及的列或者重復值比較多的列，不宜建立索引。
  對于一些特殊的數據類型，不宜建立索引，比如文本字段（text）等

• 簡述在MySQL數據庫中MyISAM和InnoDB的區別
  區別于其他數據庫的最重要的特點就是其插件式的表存儲引擎。切記：存儲引擎是基于表的，而不是數據庫。

• InnoDB與MyISAM的區別：
  InnoDB存儲引擎: 主要面向OLTP(Online Transaction Processing，在線事務處理)方面的應用，是第一個完整支持ACID事務的存儲引擎(BDB第一個支持事務的存儲引擎，已經停止開發)。
  特點：
  行鎖設計. ? 支持外鍵,支持事務，支持并發，鎖粒度是支持mvcc得行級鎖；
  MyISAM存儲引擎: 是MySQL官方提供的存儲引擎，主要面向OLAP(Online Analytical Processing,在線分析處理)方面的應用。
  特點：
  不支持事務，鎖粒度是支持并發插入得表級鎖，支持表所和全文索引。操作速度快，不能讀寫操作太頻繁；

• 解釋MySQL外連接. ? 內連接與自連接的區別
  先說什么是交叉連接: 交叉連接又叫笛卡爾積，它是指不使用任何條件，直接將一個表的所有記錄和另一個表中的所有記錄一一匹配。
  內連接 則是只有條件的交叉連接，根據某個條件篩選出符合條件的記錄，不符合條件的記錄不會出現在結果集中，即內連接只連接匹配的行。
  外連接 其結果集中不僅包含符合連接條件的行，而且還會包括左表. ? 右表或兩個表中
  的所有數據行，這三種情況依次稱之為左外連接，右外連接，和全外連接。
  左外連接，也稱左連接，左表為主表，左表中的所有記錄都會出現在結果集中，對于那些在右表中并沒有匹配的記錄，仍然要顯示，右邊對應的那些字段值以NULL來填充。右外連接，也稱右連接，右表為主表，右表中的所有記錄都會出現在結果集中。左連接和右連接可以互換，MySQL目前還不支持全外連接。

• 寫出三種以上MySQL數據庫存儲引擎的名稱（提示：不區分大小寫）
  MyISAM. ? InnoDB. ? BDB（BerkeleyDB）. ? Merge. ? Memory（Heap）. ? Example. ? Federated. ?
  Archive. ? CSV. ? Blackhole. ? MaxDB 等等十幾個引擎

• Myql中的事務回滾機制概述
  事務是用戶定義的一個數據庫操作序列，這些操作要么全做要么全不做，是一個不可分割的工作單位，事務回滾是指將該事務已經完成的對數據庫的更新操作撤銷。
  
  要同時修改數據庫中兩個不同表時，如果它們不是一個事務的話，當第一個表修改完，可能第二個表修改過程中出現了異常而沒能修改，此時就只有第二個表依舊是未修改之前的狀態，而第一個表已經被修改完畢。而當你把它們設定為一個事務的時候，當第一個表修改完，第二表修改出現異常而沒能修改，第一個表和第二個表都要回到未修改的狀態，這就是所謂的事務回滾

• SQL語言包括哪幾部分？每部分都有哪些操作關鍵字？
  答：SQL語言包括數據定義(DDL). ? 數據操縱(DML),數據控制(DCL)和數據查詢（DQL）四個部分。
  數據定義：Create Table,Alter Table,Drop Table, Craete/Drop Index等
  數據操縱：Select ,insert,update,delete,
  數據控制：grant,revoke
  數據查詢：select

• 完整性約束包括哪些？
  數據完整性(Data Integrity)是指數據的精確(Accuracy)和可靠性(Reliability)。
  分為以下四類：

• 實體完整性：規定表的每一行在表中是惟一的實體。
• 域完整性：是指表中的列必須滿足某種特定的數據類型約束，其中約束又包括取值范圍. ? 精度等規定。
• 參照完整性：是指兩個表的主關鍵字和外關鍵字的數據應一致，保證了表之間的數據的一致性，防止了數據丟失或無意義的數據在數據庫中擴散。
• 用戶定義的完整性：不同的關系數據庫系統根據其應用環境的不同，往往還需要一些特殊的約束條件。用戶定義的完整性即是針對某個特定關系數據庫的約束條件，它反映某一具體應用必須滿足的語義要求。
  與表有關的約束：包括列約束(NOT NULL（非空約束）)和表約束(PRIMARY KEY. ? foreign key. ? check. ? UNIQUE) 。

• 什么是事務？及其特性？
  答：事務：是一系列的數據庫操作，是數據庫應用的基本邏輯單位。
  
  事務特性：
  （1）原子性：即不可分割性，事務要么全部被執行，要么就全部不被執行。
  （2）一致性或可串性。事務的執行使得數據庫從一種正確狀態轉換成另一種正確狀態
  （3）隔離性。在事務正確提交之前，不允許把該事務對數據的任何改變提供給任何其他事務，
  （4） 持久性。事務正確提交后，其結果將永久保存在數據庫中，即使在事務提交后有了其他故障，事務的處理結 果也會得到保存。

  或者這樣理解：

  事務就是被綁定在一起作為一個邏輯工作單元的SQL語句分組，如果任何一個語句操作失敗那么整個操作就被失 敗，以后操作就會回滾到操作前狀態，或者是上有個節點。為了確保要么執行，要么不執行，就可以使用事務。要將有組語句作為事務考慮，就需要通過ACID測試，即原子性，一致性，隔離性和持久性。

• 什么是鎖？
  答：數據庫是一個多用戶使用的共享資源。當多個用戶并發地存取數據時，在數據庫中就會產生多個事務同時存取同一數據的情況。若對并發操作不加控制就可能會讀取和存儲不正確的數據，破壞數據庫的一致性。

  加鎖是實現數據庫并發控制的一個非常重要的技術。當事務在對某個數據對象進行操作前，先向系統發出請求，對其加鎖。加鎖后事務就對該數據對象有了一定的控制，在該事務釋放鎖之前，其他的事務不能對此數據對象進行更新操作。

  基本鎖類型：鎖包括行級鎖和表級鎖

• 什么叫視圖？游標是什么？

  答：視圖是一種虛擬的表，具有和物理表相同的功能。可以對視圖進行增，改，查，操作，視圖通常是有一個表或者多個表的行或列的子集。對視圖的修改不影響基本表。它使得我們獲取數據更容易，相比多表查詢。

  游標：是對查詢出來的結果集作為一個單元來有效的處理。游標可以定在該單元中的特定行，從結果集的當前行檢索一行或多行。可以對結果集當前行做修改。一般不使用游標，但是需要逐條處理數據的時候，游標顯得十分重要。

• 什么是存儲過程？用什么來調用？

  答：存儲過程是一個預編譯的SQL語句，優點是允許模塊化的設計，就是說只需創建一次，以后在該程序中就可以調用多次。如果某次操作需要執行多次SQL，使用存儲過程比單純SQL語句執行要快。可以用一個命令對象來調用存儲過程。

• 索引的作用？和它的優點缺點是什么？

  答：索引就一種特殊的查詢表，數據庫的搜索引擎可以利用它加速對數據的檢索。它很類似與現實生活中書的目錄，不需要查詢整本書內容就可以找到想要的數據。索引可以是唯一的，創建索引允許指定單個列或者是多個列。缺點是它減慢了數據錄入的速度，同時也增加了數據庫的尺寸大小

• 如何通俗地理解三個范式？

  答：第一范式：1NF是對屬性的原子性約束，要求屬性具有原子性，不可再分解；

  第二范式：2NF是對記錄的惟一性約束，要求記錄有惟一標識，即實體的惟一性；

  第三范式：3NF是對字段冗余性的約束，即任何字段不能由其他字段派生出來，它要求字段沒有冗余。。

  范式化設計優缺點:

  優點:

  可以盡量得減少數據冗余，使得更新快，體積小

  缺點:對于查詢需要多個表進行關聯，減少寫得效率增加讀得效率，更難進行索引優化

  反范式化:

  優點:可以減少表得關聯，可以更好得進行索引優化

  缺點:數據冗余以及數據異常，數據得修改需要更多的成

• 什么是基本表？什么是視圖？

  答：基本表是本身獨立存在的表，在 SQL 中一個關系就對應一個表。 視圖是從一個或幾個基本表導出的表。視圖本身不獨立存儲在數據庫中，是一個虛表

• 試述視圖的優點？

  答：(1) 視圖能夠簡化用戶的操作 (2) 視圖使用戶能以多種角度看待同一數據； (3) 視圖為數據庫提供了一定程度的邏輯獨立性； (4) 視圖能夠對機密數據提供安全保護。

• NULL是什么意思

  答：NULL這個值表示UNKNOWN(未知):它不表示“”(空字符串)。對NULL這個值的任何比較都會生產一個NULL值。您不能把任何值與一個 NULL值進行比較，并在邏輯上希望獲得一個答案。

  使用IS NULL來進行NULL判斷

• 主鍵. ? 外鍵和索引的區別？
  主鍵. ? 外鍵和索引的區別
  定義：
  主鍵–唯一標識一條記錄，不能有重復的，不允許為空
  外鍵–表的外鍵是另一表的主鍵, 外鍵可以有重復的, 可以是空值
  索引–該字段沒有重復值，但可以有一個空值
  作用：
  主鍵–用來保證數據完整性
  外鍵–用來和其他表建立聯系用的
  索引–是提高查詢排序的速度
  個數：
  主鍵–主鍵只能有一個
  外鍵–一個表可以有多個外鍵
  索引–一個表可以有多個唯一索引

• 你可以用什么來確保表格里的字段只接受特定范圍里的值?
  Check限制，它在數據庫表格里被定義，用來限制輸入該列的值。
  觸發器也可以被用來限制數據庫表格里的字段能夠接受的值，但是這種辦法要求觸發器在表格里被定義，這可能會在某些情況下影響到性能。

• 說說對SQL語句優化有哪些方法？（選擇幾條）

  （1）Where子句中：where表之間的連接必須寫在其他Where條件之前，那些可以過濾掉最大數量記錄的條件必須寫在Where子句的末尾.HAVING最后。

  （2）用EXISTS替代IN. ? 用NOT EXISTS替代NOT IN。

  （3） 避免在索引列上使用計算

  （4）避免在索引列上使用IS NULL和IS NOT NULL

  （5）對查詢進行優化，應盡量避免全表掃描，首先應考慮在 where 及 order by 涉及的列上建立索引。

  （6）應盡量避免在 where 子句中對字段進行 null 值判斷，否則將導致引擎放棄使用索引而進行全表掃描

  （7）應盡量避免在 where 子句中對字段進行表達式操作，這將導致引擎放棄使用索引而進行全表掃描

• SQL語句中‘相關子查詢’與‘非相關子查詢’有什么區別？

  答：子查詢：嵌套在其他查詢中的查詢稱之。

  子查詢又稱內部，而包含子查詢的語句稱之外部查詢（又稱主查詢）。

  所有的子查詢可以分為兩類，即相關子查詢和非相關子查詢

  （1）非相關子查詢是獨立于外部查詢的子查詢，子查詢總共執行一次，執行完畢后將值傳遞給外部查詢。

  （2）相關子查詢的執行依賴于外部查詢的數據，外部查詢執行一行，子查詢就執行一次。

  故非相關子查詢比相關子查詢效率高

• char和varchar的區別？

  答：是一種固定長度的類型，varchar則是一種可變長度的類型，它們的區別是：

  char(M)類型的數據列里，每個值都占用M個字節，如果某個長度小于M，MySQL就會在它的右邊用空格字符補足．（在檢索操作中那些填補出來的空格字符將被去掉）在varchar(M)類型的數據列里，每個值只占用剛好夠用的字節再加上一個用來記錄其長度的字節（即總長度為L+1字節）．

  varchar得適用場景:

  字符串列得最大長度比平均長度大很多 2.字符串很少被更新，容易產生存儲碎片 3.使用多字節字符集存儲字符串

  Char得場景:

  存儲具有近似得長度（md5值,身份證，手機號）,長度比較短小得字符串（因為varchar需要額外空間記錄字符串長度），更適合經常更新得字符串，更新時不會出現頁分裂得情況，避免出現存儲碎片，獲得更好的io性能

• (考題) Mysql對大批量數據進行存儲和操作，如何選擇存儲引擎？如何設計表？如何優化操作？事務是什么如何管理？

考點： 5萬條數據，高并發情況下？如何選擇Mysql存儲引擎？如何設計表（三大范式）？如何優化（索引）？并發操作時符合保證事務的一致性（事務）？ (考題)MySQL數據庫作為發布系統的存儲，一天五萬條以上的增量，預計運維三年,如何設計表？如何優化操作？事務如何管理？1. &nbsp; 設計表？· 設計表需要考慮約束和三大范式，如下？（1）完整性約束包括哪些？數據完整性(Data Integrity)是指數據的精確(Accuracy)和可靠性(Reliability)。分為以下四類：1) 實體完整性：規定表的每一行在表中是惟一的實體。2) 域完整性：是指表中的列必須滿足某種特定的數據類型約束，其中約束又包括取值范圍. &nbsp; 精度等規定。3) 參照完整性：是指兩個表的主關鍵字和外關鍵字的數據應一致，保證了表之間的數據的一致性，防止了數據丟失或無意義的數據在數據庫中擴散。4) 用戶定義的完整性：不同的關系數據庫系統根據其應用環境的不同，往往還需要一些特殊的約束條件。用戶定義的完整性即是針對某個特定關系數據庫的約束條件，它反映某一具體應用必須滿足的語義要求。與表有關的約束：包括列約束(NOT NULL（非空約束）)和表約束(PRIMARY KEY. &nbsp; foreign key. &nbsp; check. &nbsp; UNIQUE) 。（2）設計表必須遵循三個范式？如下第一范式：1NF是對屬性的原子性約束，要求屬性具有原子性，不可再分解；第二范式：2NF是對記錄的惟一性約束，要求記錄有惟一標識，即實體的惟一性； 第三范式：3NF是對字段冗余性的約束，即任何字段不能由其他字段派生出來，它要求字段沒有冗余。。范式化設計優缺點:優點: 可以盡量得減少數據冗余，使得更新快，體積小 缺點:對于查詢需要多個表進行關聯，減少寫得效率增加讀得效率，更難進行索引優化 反范式化: 優點:可以減少表得關聯，可以更好得進行索引優化 缺點:數據冗余以及數據異常，數據得修改需要更多的成2. &nbsp; 優化操作？a設計良好的數據庫結構，允許部分數據冗余，盡量避免join查詢，提高效率。b. 選擇合適的表字段數據類型和存儲引擎，適當的添加索引。c. mysql庫主從讀寫分離。d. 找規律分表，減少單表中的數據量提高查詢速度。e. 添加緩存機制，比如memcached，apc等。f. 不經常改動的頁面，生成靜態頁面。g. 書寫高效率的SQL。比如 SELECT * FROM TABEL 改為 SELECT field_1, field_2, field_3 FROM TABLE.存儲引擎. &nbsp; 優化字段數據類型. &nbsp; 為搜索字段添加索引. &nbsp; 使用 ENUM 而不是 VARCHAR. &nbsp; 盡可能的使用 NOT NULL. &nbsp; 固定長度的表會更快（1）存儲引擎選擇（1）Mysql的存儲引擎有myisam和innodb,區別有兩點:1.MyISAM 是非事務的存儲引擎，適合用于頻繁查詢的應用。表鎖，不會出現死鎖，適合小數據，小并發。是MySQL官方提供的存儲引擎，主要面向OLAP(Online Analytical Processing,在線分析處理)方面的應用。特點：不支持事務，鎖粒度是支持并發插入得表級鎖，支持表所和全文索引。操作速度快，不能讀寫操作太頻繁；2.innodb是支持事務的存儲引擎，合于插入和更新操作比較多的應用，設計合理的話是行鎖（最大區別就在鎖的級別上），適合大數據，大并發。主要面向OLTP(Online Transaction Processing，在線事務處理)方面的應用，是第一個完整支持ACID事務的存儲引擎(BDB第一個支持事務的存儲引擎，已經停止開發)。特點：· 行鎖設計. &nbsp; 支持外鍵,支持事務，支持并發，鎖粒度是支持mvcc得行級鎖；綜述：選擇innodb作為存儲引擎；（2）優化字段數據類型記住一個原則，越小的列會越快。如果一個表只會有幾列罷了（比如說字典表，配置表），那么，我們就沒有理由使用INT來做主鍵，使用 MEDIUMINT, SMALLINT 或是更小的 TINYINT 會更經濟一些。如果你不需要記錄時間，使用 DATE 要比 DATETIME 好得多。當然，你也需要留夠足夠的擴展空間。（3）為搜索字段添加索引mysql中有索引，主鍵，唯一索引，聯合索引，對數據庫的性能有什么影響（從讀寫兩方面）,區別如下？索引是一種特殊的文件(InnoDB數據表上的索引是表空間的一個組成部分)，它們包含著對數據表里所有記錄的引用指針。普通索引(由關鍵字KEY或INDEX定義的索引)的唯一任務是加快對數據的訪問速度。普通索引允許被索引的數據列包含重復的值。如果能確定某個數據列將只包含彼此各不相同的值，在為這個 數據列創建索引的時候就應該用關鍵字UNIQUE把它定義為一個唯一索引。也就是說，唯一索引可以保證數據記錄的唯一性。主鍵，是一種特殊的唯一索引，在一張表中只能定義一個主鍵索引，主鍵用于唯一標識一條記錄，使用關鍵字 PRIMARY KEY 來創建。索引可以覆蓋多個數據列，如像INDEX(columnA, columnB)索引，這就是聯合索引。索引可以極大的提高數據的查詢速度，但是會降低插入. &nbsp; 刪除. &nbsp; 更新表的速度，因為在執行這些寫操作時，還要操作索引文件。a). &nbsp; 索引的目的是什么？快速訪問數據表中的特定信息，提高檢索速度創建唯一性索引，保證數據庫表中每一行數據的唯一性。加速表和表之間的連接使用分組和排序子句進行數據檢索時，可以顯著減少查詢中分組和排序的時間b). &nbsp; 索引對數據庫系統的負面影響是什么？負面影響：創建索引和維護索引需要耗費時間，這個時間隨著數據量的增加而增加；索引需要占用物理空間，不光是表需要占用數據空間，每個索引也需要占用物理空間；當對表進行增. &nbsp; 刪. &nbsp; 改. &nbsp; 的時候索引也要動態維護，這樣就降低了數據的維護速度。c). &nbsp; 為數據表建立索引的原則有哪些？在最頻繁使用的. &nbsp; 用以縮小查詢范圍的字段上建立索引。在頻繁使用的. &nbsp; 需要排序的字段上建立索引d). &nbsp; 什么情況下不宜建立索引？對于查詢中很少涉及的列或者重復值比較多的列，不宜建立索引。對于一些特殊的數據類型，不宜建立索引，比如文本字段（text）等綜述：索引并不一定就是給主鍵或是唯一的字段。如果在你的表中，有某個字段你總要會經常用來做搜索，那么最好是為其建立索引，除非你要搜索的字段是大的文本字段，那應該建立全文索引。（4）SQl語句進行少用通配符. &nbsp; 要精確避免使用Select*從數據庫里讀出越多的數據，那么查詢就會變得越慢。并且，如果你的數據庫服務器和WEB服務器是兩臺獨立的服務器的話，這還會增加網絡傳輸的負載。即使你要查詢數據表的所有字段，也盡 量不要用通配符，善用內置提供的字段排除定義也許能給帶來更多的便利。（5）使用 ENUM 而不是 VARCHARENUM 類型是非常快和緊湊的。在實際上，其保存的是 TINYINT，但其外表上顯示為字符串。這樣一來，用這個字段來做一些選項列表變得相當的完美。例如，性別. &nbsp; 民族. &nbsp; 部門和狀態之類的這些字段的取值是有限而且固定的，那么，你應該使用 ENUM 而不是 VARCHAR。（6）盡可能的使用 NOT NULL除非你有一個很特別的原因去使用 NULL 值，你應該總是讓你的字段保持 NOT NULL。 NULL其實需要額外的空間，并且，在你進行比較的時候，你的程序會更復雜。 當然，這里并不是說你就不能使用NULL了，現實情況是很復雜的，依然會有些情況下，你需要使用NULL值。（7）固定長度的表會更快如果表中的所有字段都是“固定長度”的，整個表會被認為是 “static” 或 “fixed-length”。 例如，表中沒有如下類型的字段：VARCHAR，TEXT，BLOB。只要你包括了其中一個這些字段，那么這個表就不是“固定長度靜態表”了，這樣，MySQL 引擎會用另一種方法來處理。固定長度的表會提高性能，因為MySQL搜尋得會更快一些，因為這些固定的長度是很容易計算下一個數據的偏移量的，所以讀取的自然也會很快。而如果字段不是定長的，那么，每一次要找下一條的話，需要程序找到主鍵。并且，固定長度的表也更容易被緩存和重建。不過，唯一的副作用是，固定長度的字段會浪費一些空間，因為定長的字段無論你用不用，他都是要分配那么多的空間。3. &nbsp; 事務管理？（1）事務（transaction）是作為一個單元的一組有序的數據庫操作。如果組中的所有操作都成功，則認為事務成功，即使只有一個操作失敗，事務也不成功。如果所有操作完成，事務則提交，其修改將作用于所有其他數據庫進程。如果一個操作失敗，則事務將回滾，該事務所有操作的影響都將取消。ACID 四大特性,原子性. &nbsp; 隔離性. &nbsp; 一致性. &nbsp; 持久性。（2）Myql中的事務回滾機制概述事務是用戶定義的一個數據庫操作序列，這些操作要么全做要么全不做，是一個不可分割的工作單位，事務回滾是指將該事務已經完成的對數據庫的更新操作撤銷。要同時修改數據庫中兩個不同表時，如果它們不是一個事務的話，當第一個表修改完，可能第二個表修改過程中出現了異常而沒能修改，此時就只有第二個表依舊是未修改之前的狀態，而第一個表已經被修改完畢。而當你把它們設定為一個事務的時候，當第一個表修改完，第二表修改出現異常而沒能修改，第一個表和第二個表都要回到未修改的狀態，這就是所謂的事務回滾

基礎知識

| name | population | area |

±-------------±------------±-------------+

| Afghanistan | 25500100 | 652230 |

| Algeria | 37100000 | 2381741 |

±-------------±------------±-------------+

（1）SQL Schema

SQL Schema 用于在本地環境下創建表結構并導入數據，從而方便在本地環境解答。

DROP TABLE

什么是事務

事務指的是滿足 ACID 特性的一組操作，可以通過 Commit 提交一個事務，也可以使用 Rollback 進行回滾。

2．ACID
（1）原子性（Atomicity）
事務被視為不可分割的最小單元，事務的所有操作要么全部提交成功，要么全部失敗回滾。
回滾可以用回滾日志來實現，回滾日志記錄著事務所執行的修改操作，在回滾時反向執行這些修改操作即可。
（2）一致性（Consistency）
數據庫在事務執行前后都保持一致性狀態。在一致性狀態下，所有事務對一個數據的讀取結果都是相同的。
（3）隔離性（Isolation）
一個事務所做的修改在最終提交以前，對其它事務是不可見的。
（4）持久性（Durability）
一旦事務提交，則其所做的修改將會永遠保存到數據庫中。即使系統發生崩潰，事務執行的結果也不能丟失。
使用重做日志來保證持久性。

事務的 ACID 特性概念簡單，但不是很好理解，主要是因為這幾個特性不是一種平級關系：

• 只有滿足一致性，事務的執行結果才是正確的。

• 在無并發的情況下，事務串行執行，隔離性一定能夠滿足。此時只要能滿足原子性，就一定能滿足一致性。

• 在并發的情況下，多個事務并行執行，事務不僅要滿足原子性，還需要滿足隔離性，才能滿足一致性。

• 事務滿足持久化是為了能應對數據庫崩潰的情況。
  
  3．封鎖粒度

MySQL 中提供了兩種封鎖粒度：行級鎖以及表級鎖。

應該盡量只鎖定需要修改的那部分數據，而不是所有的資源。鎖定的數據量越少，發生鎖爭用的可能就越小，系統的并發程度就越高。

但是加鎖需要消耗資源，鎖的各種操作（包括獲取鎖. ? 釋放鎖. ? 以及檢查鎖狀態）都會增加系統開銷。因此封鎖粒度越小，系統開銷就越大。

在選擇封鎖粒度時，需要在鎖開銷和并發程度之間做一個權衡。

4．范式

范式理論是為了解決以上提到四種異常。

高級別范式的依賴于低級別的范式，1NF 是最低級別的范式。

（1）第一范式（1NF）
??屬性不可分。

（2）第二范式（2NF）

??每個非主屬性完全函數依賴于鍵碼。

??可以通過分解來滿足。

（3）第三范式（3NF）

??非主屬性不傳遞函數依賴于鍵碼。

??上面的 關系-1 中存在以下傳遞函數依賴：

5．ER圖
??Entity-Relationship，有三個組成部分：實體. ? 屬性. ? 聯系。

??用來進行關系型數據庫系統的概念設計。

（1）實體的三種聯系

??包含一對一，一對多，多對多三種。

• 如果 A 到 B 是一對多關系，那么畫個帶箭頭的線段指向 B；

• 如果是一對一，畫兩個帶箭頭的線段；

• 如果是多對多，畫兩個不帶箭頭的線段。

下圖的 Course 和 Student 是一對多的關系。

（2）表示出現多次的關系

??一個實體在聯系出現幾次，就要用幾條線連接。

??下圖表示一個課程的先修關系，先修關系出現兩個 Course 實體，第一個是先修課程，后一個是后修課程，因此需要用兩條線來表示這種關系。

（3）聯系的多向性

雖然老師可以開設多門課，并且可以教授多名學生，但是對于特定的學生和課程，只有一個老師教授，這就構成了一個三元聯系。

（4）表示子類

用一個三角形和兩條線來連接類和子類，與子類有關的屬性和聯系都連到子類上，而與父類和子類都有關的連到父類上。

MySQL -SQL

1．Big Countries習題

（1）Description

±----------------±-----------±-----------±-------------±--------------+

| name | continent | area | population | gdp |

±----------------±-----------±-----------±-------------±--------------+

| Afghanistan | Asia | 652230 | 25500100 | 20343000 |

| Albania | Europe | 28748 | 2831741 | 12960000 |

| Algeria | Africa | 2381741 | 37100000 | 188681000 |

| Andorra | Europe | 468 | 78115 | 3712000 |

| Angola | Africa | 1246700 | 20609294 | 100990000 |

±----------------±-----------±-----------±-------------±--------------+

查找面積超過 3,000,000 或者人口數超過 25,000,000 的國家。

±-------------±------------±-------------+

EXISTS World;CREATE TABLE World ( NAME VARCHAR ( 255 ), continent VARCHAR ( 255 ), area INT, population INT, gdp INT );INSERT INTO World ( NAME, continent, area, population, gdp )VALUES( 'Afghanistan', 'Asia', '652230', '25500100', '203430000' ),( 'Albania', 'Europe', '28748', '2831741', '129600000' ),( 'Algeria', 'Africa', '2381741', '37100000', '1886810000' ),( 'Andorra', 'Europe', '468', '78115', '37120000' ),( 'Angola', 'Africa', '1246700', '20609294', '1009900000' );

（2）Solution

SELECT name,population,areaFROMWorld WHEREarea > 3000000OR population > 25000000;

Swap Salary習題

（1）Description

| id | name | sex | salary |

|----|------|-----|--------|

| 1 | A | m | 2500 |

| 2 | B | f | 1500 |

| 3 | C | m | 5500 |

| 4 | D | f | 500 |

只用一個 SQL 查詢，將 sex 字段反轉。

| id | name | sex | salary |

|----|------|-----|--------|

| 1 | A | f | 2500 |

| 2 | B | m | 1500 |

| 3 | C | f | 5500 |

| 4 | D | m | 500 |

（2）SQL Schema

DROP TABLEIFEXISTS salary;CREATE TABLE salary ( id INT, NAME VARCHAR ( 100 ), sex CHAR ( 1 ), salary INT );INSERT INTO salary ( id, NAME, sex, salary )VALUES( '1', 'A', 'm', '2500' ),( '2', 'B', 'f', '1500' ),( '3', 'C', 'm', '5500' ),( '4', 'D', 'f', '500' );

（3）Solution

使用異或操作，兩個相等的數異或的結果為 0，而 0 與任何一個數異或的結果為這個數。

‘f’ ^ ‘m’ ^ ‘f’ = ‘m’

‘m’ ^ ‘m’ ^ ‘f’ = ‘f’

UPDATE salarySET sex = CHAR ( ASCII(sex) ^ ASCII( ‘m’ ) ^ ASCII( ‘f’ ) );

3.7.3.5. ? MYsql -知識點概述

1．索引的優點

• 大大減少了服務器需要掃描的數據行數。

• 幫助服務器避免進行排序和分組，以及避免創建臨時表（B+Tree 索引是有序的，可以用于 ORDER BY 和 GROUP BY 操作。臨時表主要是在排序和分組過程中創建，不需要排序和分組，也就不需要創建臨時表）。

• 將隨機 I/O 變為順序 I/O（B+Tree 索引是有序的，會將相鄰的數據都存儲在一起）。

2．索引的使用條件

• 對于非常小的表. ? 大部分情況下簡單的全表掃描比建立索引更高效；

• 對于中到大型的表，索引就非常有效；

• 但是對于特大型的表，建立和維護索引的代價將會隨之增長。這種情況下，需要用到一種技術可以直接區分出需要查詢的一組數據，而不是一條記錄一條記錄地匹配，例如可以使用分區技術。

3．數據類型

（1）整型

??TINYINT, SMALLINT, MEDIUMINT, INT, BIGINT 分別使用 8, 16, 24, 32, 64 位存儲空間，一般情況下越小的列越好。

I??NT(11) 中的數字只是規定了交互工具顯示字符的個數，對于存儲和計算來說是沒有意義的。

（2）浮點數
??FLOAT 和 DOUBLE 為浮點類型，DECIMAL 為高精度小數類型。CPU 原生支持浮點運算，但是不支持 DECIMAl 類型的計算，因此 DECIMAL 的計算比浮點類型需要更高的代價。

??FLOAT. ? DOUBLE 和 DECIMAL 都可以指定列寬，例如 DECIMAL(18, 9) 表示總共 18 位，取 9 位存儲小數部分，剩下 9 位存儲整數部分。

（3）字符串

??主要有 CHAR 和 VARCHAR 兩種類型，一種是定長的，一種是變長的。

??VARCHAR 這種變長類型能夠節省空間，因為只需要存儲必要的內容。但是在執行 UPDATE 時可能會使行變得比原來長，當超出一個頁所能容納的大小時，就要執行額外的操作。MyISAM 會將行拆成不同的片段存儲，而 InnoDB 則需要分裂頁來使行放進頁內。

??在進行存儲和檢索時，會保留 VARCHAR 末尾的空格，而會刪除 CHAR 末尾的空格。

（4）時間和日期

??MySQL 提供了兩種相似的日期時間類型：DATETIME 和 TIMESTAMP。

① DATETIME

??能夠保存從 1000 年到 9999 年的日期和時間，精度為秒，使用 8 字節的存儲空間。

??它與時區無關。

??默認情況下，MySQL 以一種可排序的. ? 無歧義的格式顯示 DATETIME 值，例如“2008-01-16 22:37:08”，這是 ANSI 標準定義的日期和時間表示方法。

② TIMESTAMP

??和 UNIX 時間戳相同，保存從 1970 年 1 月 1 日午夜（格林威治時間）以來的秒數，使用 4 個字節，只能表示從 1970 年到 2038 年。

??它和時區有關，也就是說一個時間戳在不同的時區所代表的具體時間是不同的。

??MySQL 提供了 FROM_UNIXTIME() 函數把 UNIX 時間戳轉換為日期，并提供了 UNIX_TIMESTAMP() 函數把日期轉換為 UNIX 時間戳。

??默認情況下，如果插入時沒有指定 TIMESTAMP 列的值，會將這個值設置為當前時間。

??應該盡量使用 TIMESTAMP，因為它比 DATETIME 空間效率更高。

4．切分

（1）水平切分

??水平切分又稱為 Sharding，它是將同一個表中的記錄拆分到多個結構相同的表中。

??當一個表的數據不斷增多時，Sharding 是必然的選擇，它可以將數據分布到集群的不同節點上，從而緩存單個數據庫的壓力。

（2）垂直切分

??垂直切分是將一張表按列切分成多個表，通常是按照列的關系密集程度進行切分，也可以利用垂直切分將經常被使用的列和不經常被使用的列切分到不同的表中。

??在數據庫的層面使用垂直切分將按數據庫中表的密集程度部署到不同的庫中，例如將原來的電商數據庫垂直切分成商品數據庫. ? 用戶數據庫等。

5．Sharding 策略

• 哈希取模：hash(key) % N；

• 范圍：可以是 ID 范圍也可以是時間范圍；

• 映射表：使用單獨的一個數據庫來存儲映射關系。

6．Sharding 存在的問題

（1）事務問題

使用分布式事務來解決，比如 XA 接口。

（2）連接

可以將原來的連接分解成多個單表查詢，然后在用戶程序中進行連接。

（3）ID唯一性

• 使用全局唯一 ID（GUID）

• 為每個分片指定一個 ID 范圍

• 分布式 ID 生成器 (如 Twitter 的 Snowflake 算法)

7．主從復制

主要涉及三個線程：binlog 線程. ? I/O 線程和 SQL 線程。

• binlog 線程 ：負責將主服務器上的數據更改寫入二進制日志（Binary log）中。

• I/O 線程 ：負責從主服務器上讀取二進制日志，并寫入從服務器的中繼日志（Relay log）。

• SQL 線程 ：負責讀取中繼日志，解析出主服務器已經執行的數據更改并在從服務器中重放（Replay）。
  
  8．讀寫分離

主服務器處理寫操作以及實時性要求比較高的讀操作，而從服務器處理讀操作。

讀寫分離能提高性能的原因在于：

• 主從服務器負責各自的讀和寫，極大程度緩解了鎖的爭用；

• 從服務器可以使用 MyISAM，提升查詢性能以及節約系統開銷；

• 增加冗余，提高可用性。

讀寫分離常用代理方式來實現，代理服務器接收應用層傳來的讀寫請求，然后決定轉發到哪個服務器。

算法

簡答題

編程題

有序數組的 Two Sum

Input: numbers={2, 7, 11, 15}, target=9

Output: index1=1, index2=2

題目描述：在有序數組中找出兩個數，使它們的和為 target。

使用雙指針，一個指針指向值較小的元素，一個指針指向值較大的元素。指向較小元素的指針從頭向尾遍歷，指向較大元素的指針從尾向頭遍歷。

• 如果兩個指針指向元素的和 sum == target，那么得到要求的結果；

• 如果 sum > target，移動較大的元素，使 sum 變小一些；

• 如果 sum < target，移動較小的元素，使 sum 變大一些。

public int[] twoSum(int[] numbers, int target) {int i = 0, j = numbers.length - 1;while (i < j) {int sum = numbers[i] + numbers[j];if (sum == target) {return new int[]{i + 1, j + 1};} else if (sum < target) {i++;} else {j--;}}return null; }

2．兩數平方和

Input: 5

Output: True

Explanation: 1 * 1 + 2 * 2 = 5

題目描述：判斷一個數是否為兩個數的平方和。

public boolean judgeSquareSum(int c) {int i = 0, j = (int) Math.sqrt(c);while (i <= j) {int powSum = i * i + j * j;if (powSum == c) {return true;} else if (powSum > c) {j--;} else {i++;}}return false;}

3．反轉字符串中的元音字符

Given s = “leetcode”, return “leotcede”.

使用雙指針指向待反轉的兩個元音字符，一個指針從頭向尾遍歷，一個指針從尾到頭遍歷。

private final static HashSet<Character> vowels = new HashSet<>(Arrays.asList('a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U'));public String reverseVowels(String s) {int i = 0, j = s.length() - 1;char[] result = new char[s.length()];while (i <= j) {char ci = s.charAt(i);char cj = s.charAt(j);if (!vowels.contains(ci)) {result[i++] = ci;} else if (!vowels.contains(cj)) {result[j--] = cj;} else {result[i++] = cj;result[j--] = ci;}}return new String(result);}

4．回文字符串

Input: “abca”

Output: True

Explanation: You could delete the character ‘c’.

題目描述：可以刪除一個字符，判斷是否能構成回文字符串。

public boolean validPalindrome(String s) {for (int i = 0, j = s.length() - 1; i < j; i++, j--) {if (s.charAt(i) != s.charAt(j)) {return isPalindrome(s, i, j - 1) || isPalindrome(s, i + 1, j);}}return true;}private boolean isPalindrome(String s, int i, int j) {while (i < j) {if (s.charAt(i++) != s.charAt(j--)) {return false;}}return true;}

5．歸并兩個有序數組

Input:
nums1 = [1,2,3,0,0,0], m = 3
nums2 = [2,5,6], n = 3
Output: [1,2,2,3,5,6]

題目描述：把歸并結果存到第一個數組上。

需要從尾開始遍歷，否則在 nums1 上歸并得到的值會覆蓋還未進行歸并比較的值。

public void merge(int[] nums1, int m, int[] nums2, int n) {int index1 = m - 1, index2 = n - 1;int indexMerge = m + n - 1;while (index1 >= 0 || index2 >= 0) {if (index1 < 0) {nums1[indexMerge--] = nums2[index2--];} else if (index2 < 0) {nums1[indexMerge--] = nums1[index1--];} else if (nums1[index1] > nums2[index2]) {nums1[indexMerge--] = nums1[index1--];} else {nums1[indexMerge--] = nums2[index2--];}}}

6．判斷鏈表是否存在環

使用雙指針，一個指針每次移動一個節點，一個指針每次移動兩個節點，如果存在環，那么這兩個指針一定會相遇。

public boolean hasCycle(ListNode head) {if (head == null) {return false;}ListNode l1 = head, l2 = head.next;while (l1 != null && l2 != null && l2.next != null) {if (l1 == l2) {return true;}l1 = l1.next;l2 = l2.next.next;}return false;}

7．最長子序列

Input:
s = “abpcplea”, d = [“ale”,“apple”,“monkey”,“plea”]
Output:
“apple”

題目描述：刪除 s 中的一些字符，使得它構成字符串列表 d 中的一個字符串，找出能構成的最長字符串。如果有多個相同長度的結果，返回字典序的最小字符串。

通過刪除字符串 s 中的一個字符能得到字符串 t，可以認為 t 是 s 的子序列，我們可以使用雙指針來判斷一個字符串是否為另一個字符串的子序列。

public String findLongestWord(String s, List<String> d) {String longestWord = "";for (String target : d) {int l1 = longestWord.length(), l2 = target.length();if (l1 > l2 || (l1 == l2 && longestWord.compareTo(target) < 0)) {continue;}if (isSubstr(s, target)) {longestWord = target;}}return longestWord; }private boolean isSubstr(String s, String target) {int i = 0, j = 0;while (i < s.length() && j < target.length()) {if (s.charAt(i) == target.charAt(j)) {j++;}i++;}return j == target.length();}

數據結構

選擇題

• 選擇排序的思想是，將數據序列劃分為兩個子列，一個子列是排好序的，另一個是尚未排序的。現若想將數據序列由小到大排序，則每次放到有序子列尾部位置的元素,應從無序序列中選擇(A )。
  A.?最大的
  B.?最小的
  C.?任意的
  D.?頭上的

填空題

• 對于樹的結構，最上層的點稱為 根 結點。
• 一個結點沒有任何的子結點，則稱該結點為 葉子/終端 結點。
• 在Java中， Treemap/TreeSet 是建立樹結構的類。

簡答題

數據結構——樹——知識點總結

數據結構——樹 定義：樹是一個n(n>=0)個結點的有序合集名詞理解：結點：指樹中的一個元素；結點的度：指結點擁有的子樹的個數，二叉樹的度不大于2；數的度：指樹中的最大結點度數；葉子：度為0的結點，也稱為終端結點；高度：葉子節點的高度為1，根節點高度最高；層：根在第一層，以此類推；二叉樹的定義：由一個結點和兩顆互不相交. &nbsp; 分別稱為這個根的左子樹和右子樹的二叉樹構成（遞歸定義）二叉樹的性質：1：二叉樹的第i層上至多有2^(i-1)個結點2：深度為k的二叉樹，至多有2^k-1個結點滿二叉樹：葉子節點一定要在最后一層，并且所有非葉子節點都存在左孩子和右孩子；最特別的二叉樹：完全二叉樹：從左到右. &nbsp; 從上到下構建的二叉樹；完全二叉樹的性質：1：結點 i 的子結點為2*i 和 2*i+1(前提是都小于總結點數)2：結點 i 的父結點為 i/2 二叉樹的遍歷(要有遞歸的思想！！！)：1：先序遍歷：根->左子樹->右子樹（先序）2：中序遍歷：左子樹->根->右子樹（中序）3：后序遍歷：左子樹->右子樹->根（后序）這三種遍歷方法只是訪問結點的時機不同，訪問結點的路徑都是一樣的，時間和空間復雜度皆為O(n)

二叉樹的存儲結構

找出兩個鏈表的交點

例如以下示例中 A 和 B 兩個鏈表相交于 c1：

A: a1 → a2↘c1 → c2 → c3↗ B: b1 → b2 → b3

但是不會出現以下相交的情況，因為每個節點只有一個 next 指針，也就只能有一個后繼節點，而以下示例中節點 c 有兩個后繼節點。

A: a1 → a2 d1 → d2↘ ↗c↗ ↘ B: b1 → b2 → b3 e1 → e2

要求時間復雜度為 O(N)，空間復雜度為 O(1)。如果不存在交點則返回 null。

設 A 的長度為 a + c，B 的長度為 b + c，其中 c 為尾部公共部分長度，可知 a + c + b = b + c + a。

當訪問 A 鏈表的指針訪問到鏈表尾部時，令它從鏈表 B 的頭部開始訪問鏈表 B；同樣地，當訪問 B 鏈表的指針訪問到鏈表尾部時，令它從鏈表 A 的頭部開始訪問鏈表 A。這樣就能控制訪問 A 和 B 兩個鏈表的指針能同時訪問到交點。

如果不存在交點，那么 a + b = b + a，以下實現代碼中 l1 和 l2 會同時為 null，從而退出循環。

public ListNode getIntersectionNode(ListNode headA, ListNode headB) {ListNode l1 = headA, l2 = headB;while (l1 != l2) {l1 = (l1 == null) ? headB : l1.next;l2 = (l2 == null) ? headA : l2.next;}return l1;}

如果只是判斷是否存在交點，那么就是另一個問題，有兩種解法：

• 把第一個鏈表的結尾連接到第二個鏈表的開頭，看第二個鏈表是否存在環；

• 或者直接比較兩個鏈表的最后一個節點是否相同。

樹的高度

public int maxDepth(TreeNode root) {if (root == null) return 0;return Math.max(maxDepth(root.left), maxDepth(root.right)) + 1;}

數組中兩個數的和為給定值

可以先對數組進行排序，然后使用雙指針方法或者二分查找方法。這樣做的時間復雜度為 O(NlogN)，空間復雜度為 O(1)。

用 HashMap 存儲數組元素和索引的映射，在訪問到 nums[i] 時，判斷 HashMap 中是否存在 target - nums[i]，如果存在說明 target - nums[i] 所在的索引和 i 就是要找的兩個數。該方法的時間復雜度為 O(N)，空間復雜度為 O(N)，使用空間來換取時間。

public int[] twoSum(int[] nums, int target) {HashMap<Integer, Integer> indexForNum = new HashMap<>();for (int i = 0; i < nums.length; i++) {if (indexForNum.containsKey(target - nums[i])) {return new int[]{indexForNum.get(target - nums[i]), i};} else {indexForNum.put(nums[i], i);}}return null;}

編程題

容器

選擇題

• 編譯并運行以下程序段的結果是：（ B ）

public static void main(String[] args) {Frame f=new Frame ("Visual");f.setSize(300,300);f.setVisible(true);Point p=f.getLocation();//p.setLocation(30,30);System.out.println("x is "+ p.x);System.out.println("y is "+ p.y);}

??A. ? x is 300

?? y is 300

?? B. ? x is 0

?? y is 0

?? C. ? x is 0
?? y is 300

?? D. ? x is 300

?? y is 0

• 哪個布局管理器使用的是組件的最佳尺寸? ( A )

A. FlowLayout B. BorderLayout
C. GridLayout D. CardLayout

• Frame的默認的布局管理器是下列哪一個? ( B )
  A.FlowLayout
  B.BorderLayout
  C.GridLayout
  D.CardLayout

• 下列哪個用戶圖形界面組件在軟件安裝程序中是常見的? ( B )
  A.滑塊
  B.進度條
  C.對話框
  D.標簽

• 包含可單擊按鈕的類的Java類庫是哪個? C
  A.AWT
  B.Swing
  C.二者都有
  D.二者都沒有

• 下面的哪個用戶界面組件不是容器? ( D )
  A. JScrollPane
  B. JFrame
  C. JWindows
  D. JScrollBar

• 在下列事件處理機制中哪個不是機制中的角色? ( C )
  A. 事件　　　　　　　　　　　　
  B. 事件源
  C. 事件接口　　　　　　　
  D. 事件處理者

• 容器被重新設置大小后，哪種布局管理器的容器中的組件大小不隨容器大小的變化而改變？ ( B )
  A. ? CardLayout
  B. ? FlowLayout
  C. ? BorderLayout
  D. ? GridLayout

• 監聽事件和處理事件( C )
  A. ? 都由Listener完成　　
  B. ? 都由相應事件Listener處登記過的構件完成　　
  C. ? 由Listener和構件分別完成　　
  D. ? 由Listener和窗口分別完成

• 如果希望所有的控件在界面上均勻排列，應使用下列那種布局管理器？( D )
  A. ? BoxLayout
  B. ? GridLayout
  C. ? BorderLayout
  D. ? FlowLouLayout

填空題

• Java的抽象窗口工具包中包含了許多類來支持__設計。GUI
• Button類、Label類是包java.awt中的類,并且是java.awt包中的___的子類。Component
• Java把有Component類的子類或間接子類創建的對象稱為一個____。組件
• Java程序中可以向容器添加組件,一個容器可以使用__方法將組件添加到該容器中。add( )
• Applet類是包__中的一個類,同時還是包java.awt中容器類的子類。java.applet
• 一個Java Applet小應用程序是有若干個類組成,且必須有一個類擴展了___類。Applet
• 一個完整的Java Applet的生命周期包含init( )、、stop( )、destroy( )、paint(Graphics g)方法。stat( )
• 在Java Applet程序中,對象首先自動調用___方法完成必要的初始化工作。init( )
• 在Java Applet程序中,初始化之后,緊接著自動調用__方法。start( )
• 在Java Applet程序中,當瀏覽器離開Java Applet所在的頁面轉到其他頁面時, _____方法被調用。stop( )
• 在Java Applet程序中,當瀏覽器結束瀏覽時,執行___方法,結束applet的生命。destroy( )
• Java Applet的主類的實例是一個____,因此Java Applet可以添加交互組件。容器
• 在java.awt包中的___類是專門用來建立文本框,它的一個對象就是一個文本框。TextField
• 一個Java Applet 不再需要main方法,但必須有一個類擴展了_____類。Applet
• Java Applet 必須有____來運行。瀏覽器
• 用JDK工具,顯示Applet程序運行結果的命令是___。appletviewer
• 運行一個Applet程序,可通過雙擊其相應的超文本文件(A.html)來顯示運行結果,或在命令控制臺窗口下輸入執行瀏覽器的命令: appletviewer A.html 。
• java.awt 包封裝了提供用戶圖形界面功能的抽象窗口工具類。
• TextField類 是對單行文本進行編輯的組件。
• 設置文本內容的方法是setText(String t)。
• 獲取文本內容的方法是 getText() 。
• TextArea 是對多行文本進行編輯的組件。
• 如果一個Java程序實現了監聽接口ActionListener，則該程序的最開頭必須引用類包 java.awt.event.* 。
• Label 是用戶只能查看其內容但不能修改的文本組件。
• 獲取按鈕上的標簽內容的方法是 getText() 。
• 為了使組件能在面板上顯示出來，需用 add 方法把組件添加到面板上。
• 假若一個按鈕產生了一個ActionEvent事件，則事件監聽器會將該事件傳遞給 actionPerformed()方法來進行事件處理。
• Java中最常見的3種布局方式：FlowLayout、BorderLayout和 GridLayout。
• Applet容器的默認布局方式是 FlowLayout 。
• Frame窗體的默認布局方式是 BorderLayout 。
• FlowLayout 類是按組件的順序，從左到右一行排列，一行放不下時自動換行。
• BorderLayout 類把容器劃分成東、西、南、北、中5個區域。
• GridLayout 類是以行、列形式將容器劃分成大小相等的單元格。
• 假若一個按鈕btn要產生一個ActionEvent事件，則使用 addActiionListener 方法 來注冊監聽器。
• 事件處理者通常是一個類，該類如果能夠處理某種類型的事件，就必須實 現與該事件類型相對應的 接口 。
• 假若一個類實現了某個接口，則該類必須實現接口中所有的方法，但 Adapter 類只需重寫需要的方法，而無關方法不用實現。

簡答題

編程題

協議

簡答題

TCP的三次握手和四次揮手，瀏覽器訪問一個網址的過程

位碼即tcp標志位,有6種表示:SYN(synchronous建立連接)、ACK(acknowledgement 表示響應、確認)、PSH(push表示有DATA數據傳輸)、FIN(finish關閉連接)、RST(reset表示連接重置)、URG(urgent緊急指針字段值有效)

三次握手（建立連接）：

第一次握手：客戶端發送syn包(syn=x)到服務器，并進入SYN_SEND狀態，等待服務器確認；

第二次握手：服務器收到syn包，必須確認客戶的SYN（ack=x+1），同時自己也發送一個SYN包（syn=y），即SYN+ACK包，此時服務器進入SYN_RECV狀態；

第三次握手：客戶端收到服務器的SYN＋ACK包，向服務器發送確認包ACK(ack=y+1)，此包發送完畢，客戶端和服務器進入ESTABLISHED狀態，完成三次握手。

四次揮手（斷開連接）：

第一次揮手：主動關閉方發送一個FIN，用來關閉主動方到被動關閉方的數據傳送。也就是主動關閉方告訴被動關閉方：我已經不會再給你發數據了。

第二次揮手：被動關閉方收到FIN包后，發送一個ACK給對方，確認序號為收到序號+1（與SYN相同，一個FIN占用一個序號）。

第三次揮手：被動關閉方發送一個FIN，用來關閉被動關閉方到主動關閉方的數據傳送，也就是告訴主動關閉方，我的數據也發送完了，不會再給你發數據了。

第四次揮手：主動關閉方收到FIN后，發送一個ACK給被動關閉方，確認序號為收到序號+1，至此，完成四次揮手。

訪問過程：域名解析–>三次握手–>傳輸數據–>四次揮手。

TCP與UDP區別

TCP面向連接（如打電話要先撥號建立連接）;UDP是無連接的，即發送數據之前不需要建立連接；

TCP提供可靠的服務。也就是說，通過TCP連接傳送的數據，無差錯，不丟失，不重復，且按序到達;UDP盡最大努力交付，即不保證可靠交付；

每一條TCP連接只能是點到點的;UDP支持一對一，一對多，多對一和多對多的交互通信；

UDP具有較好的實時性，工作效率比TCP高，適用于對高速傳輸和實時性有較高的通信或廣播通信；

HTTP、HTTPS區別

a. HTTP協議傳輸的數據都是未加密的，也就是明文的；HTTPS協議是由SSL+HTTP協議構建的可進行加密傳輸

b. https協議需要到ca申請證書。

總結

以上是生活随笔為你收集整理的Java高级：面试题-1的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。