Java 面試題彙總

一.Java基礎知識

1.Java 中成員變量訪問權限

1）private：只有在當前類內部中能使用
2）default：在類內部可以被訪問，也可以被同個包（同一目錄下）下其他類訪問
3）protected：可以在類內部被訪問，也可以被同個包下其他類訪問,也可以被其子類訪問
4）public：可以被任何地方訪問

2.super()與 this()的區別

解答：
this()：指當前類的對象的引用
super()：指父類對象的引用

在Java類中使用super來引用父類的成份，用this來引用當前對象,如果一個類從另一個類繼承，我們new這個子類的實例對象的時候，這個子類對象裏面會有一個父類對象，怎麼去引用裏面的父類的對象呢？使用super來引用，this指的是當前對象的引用，super是當前對象裏面的父對象的引用

3.編程圖形輸出

3.1 圖形1

 public void TuXing1(){
        for(int j = 0;j < 4;j++){
            for(int i = 4;i > j;i--){
                System.out.print("*");
            }
            System.out.print("\n");
        }
    }

3.2 圖形2 倒序輸出99乘法表

public void TuXing2(){
        for(int i = 9;i>0;i--){
            for(int j = i;j>0 ;j--){
                System.out.print(i + " * "+ j + " = "+ (i * j) + "\t");
            }
            System.out.println();
        }
    }

public void TuXing3(){
	for(int i = 9; i>0; i--){
		for(int j = 1;j <= i;j++){
			System.out.print(j + " * " + i +" = "+ j*i + "\t");
			}
	System.out.print("\n");
   }
}

public TuXing4(){
	for(int i = 1; i<=9;i++){
		for(int j = 1;j<=i;j++){
			System.out.print(j + " * " + i +" = "+ j*i + "\t");
          }
		}
  }

public void TuXing6(){
	for(int i=1;i<=9;i++){
	//空格
	for(int a=i ;a > 9;a++){
		System.out.print("\t")
	  }
	for(int j= i ; j>0 ; j--){
		System.out.print(j + " * " + i + "=" + i * j + "*")		
	  }
	}
}

public void TuXing7(){
	for(int i = 9;i>0;i++){
		//打印空格
		for(int a = 0;a < 9-i;a++){
			System.out.print("\t")
		}
		for(int j = i;j>0;j--){
			System.out.print(j + " * "+ i  + " = " + i * j+"\t")
		}
	}
}

4.Java的事件委託機制和垃圾回收機制

事件委託機制：一個源產生一個事件並將它送到一個或多個監聽器那裏。在這種方案中，監聽器簡單的等待，直到它收到一個事件，一旦事件被接受，監聽器將處理這個事件，然後返回
垃圾回收機制：垃圾收集是將分配給對象但不再使用的內存回收或釋放的過程。如果一個對象沒有指向它的引用或者其賦值爲null,則此對象適合進行垃圾回收

5.在Java中，如何跳出當前的多重嵌套循環

用break,return方法

6.什麼是Java序列化，如何實現Java序列化 ？（寫一個實例）

序列化：處理對象流的機制，所謂對象流就是將對象的內容進行流化。可以對流化後的對象進行讀寫操作，也可以將流化後的對象傳輸於網絡之間。序列化是爲了解決在對對象流 進行讀寫操作時所引發的問題
序列化的實現：將需要被實例化的類實現Serializable接口，該接口沒有需要實現的方法，implements Serializable

7.一個“.java”源文件中是否可以包括多個類（不是內部類）？有什麼限制？

解答：
可以。如果這個類的修飾符是public,其類名與文件名必須相同

8.排序都有哪幾種方法？請列舉。用Java實現一個快速排序？

轉載：https://blog.csdn.net/shujuelin/article/details/82423852
排序的方法有：插入排序（直接插入排序，希爾排序），交換排序（冒泡排序，快速排序），選擇排序（直接選擇排序，堆排序），歸併排序，分配排序（箱排序，基數排序）。
快速排序之所比較快，因爲相比冒泡排序，每次交換是跳躍式的。每次排序的時候設置一個基準點，將小於等於基準點的數全部放到基準點的左邊，將大於等於基準點的數全部放到基準點的右邊。這樣在每次交換的時候就不會像冒泡排序一樣每次只能在相鄰的數之間進行交換，交換的距離就大的多了。因此總的比較和交換次數就少了，速度自然就提高了。當然在最壞的情況下，仍可能是相鄰的兩個數進行了交換。因此快速排序的最差時間複雜度和冒泡排序是一樣的都是O(N2)，它的平均時間複雜度爲O(NlogN)。其實快速排序是基於一種叫做“二分”的思想

public class QuickSort {

	public static void quickSort(int[] arr,int low,int high){
		int i,j,temp,t;
		if(low > height){
			return;
		}
		 i = low;
		 j = high;
		 //temp就是基準位
		 temp = arr[low];
	   while (i<j){
			//先看右邊，依次往左遞減
			while (temp <= arr[j] && i<j) {
				j--;
			}
			//再看左邊，依次往右遞增
			while (temp >= arr[i] && i <j){
					i++;
				}
				//如果滿足條件則交換
				if (i < j){
					t = arr[j];
					 arr[j] = arr[i];
					  arr[i] = t;
			}
		}
		//最後將基準位與i 和 j相等位置的數字交換
		arr[low] = arr[i];
		arr[i] = temp;
		//遞歸調用坐半數組
		quickSort (arr,low,j-1);
		//遞歸調用右半數組
		quickSort (arr,j+1,high);
	}
	public static void main(String[] args){
        int[] arr = {10,7,2,4,7,62,3,4,2,1,8,9,19};
        quickSort(arr, 0, arr.length-1);
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

9.Overload 和Override的區別。Overloaded的方法是否可以改變返回值得類型?

方法的重載和重寫都是實現多態的方式，區別在於前者實現的是編譯時的多態性，而後者實現的運行時的多態性
方法的重寫Override,子類覆蓋父類的方法，將子類傳與父類的引用調用的還是子類的方法
重載Overloading一個類多個方法，名稱相同，參數個數類型不同。
兩者都是Java 多態性的不同表現
Overloaded的方法是可以改變返回值得類型

10.單例模式

什麼是單例模式：
單例：保證一個類僅有一個實例，並提供一個訪問它的全局訪問點
單例模式是一種常用的軟件設計模式之一，其目的是保證整個應用中只存在類的唯一一個實例
幾種單例模式的比較
餓漢式：

• 優點：線程安全，獲取實例速度快
• 缺點：類加載即初始化實例，內存浪費

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

懶漢式：

• 優點：在獲取實例的方法中，進行實例的初始化，節省系統資源
• 缺點：
  • 如果獲取實例時，初始化工作較多，加載速度會變慢，影響系統性能
  • 每次獲取實例都要進行費控檢查，系統開銷大
  • 非線程安全，當多個線程同時訪問getInstance()時，可能會產生多個實例

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

單例模式的優缺點
1.優點：該類只存在一個實例，節省系統資源，對於需要頻繁創建銷燬的對象，使用單例模式可以提高系統性能
2.缺點：不能外部實例化（new）

11.下列哪個爲JSP的隱含對象

A.env
B.page
C.jsp info
D.context
解答：B
JSP有9個隱含對象
request對象：保存了很多客戶端請求的信息
response對象：生成服務器響應，然後將響應結果發送到客戶端
out對象：表示輸出流，此輸出流將作爲請求發送到客戶端
session對象：我們寫個對象放在這個session對象中，這個對象就在我們的會話中都存在
application對象：我們寫個對象放在這個application對象中，這個對象就在整個應用程序中都存在
pageContext對象:對象相當於當前頁面的容器，可以訪問當前頁面的所有對象
paget對象：一般我們使用Page指令來代替使用這個對象
exception對象：用來處理異常的
config對象：一樣的我們在頁面中是使用很少的，一般會在servlet中使用這個

12.執行完以下代碼 int[] x = new int[25];String[] arr = new String[25]後x[24]=?,arr[24]=?

解答：
x[24] = 0,arr[24] = null

13.下面這段代碼片段的運行結果是：

int i = 1;
switch (i){
	Case 0:
	System.out.print("zero");
	break;
	Case 1：
	System.out.print("one")
	Case 2:
	System.out.print("two")
	default:
	System.out.print("default");
}

A.one
B.default
C.onetwodefault
D.編譯錯誤
PS:switch語句可以包含一個default分支，該分支一般是switch的最後一個分支。default在沒有case語句的值和變量值相等的時候執行。default分支不需要break語句

14.下列代碼哪行會報錯：

 (1) public void modify(){
 (2)    int i,j,k;
 (3)     i = 100;
 (4)     while(i > 0){
 (5)       j = i * 2;
 (6)       System.out.println("The value of j is" + j);
 (7)       k = k + 1;
 (8)       i--;
 (9)      };
 (10)   }

A.4
B.6
C.7
D.5
錯誤原因：變量可能沒有被初始化

15.Java關鍵字和保留字（then不是關鍵字）

16.下面關於MVC的說法不正確的是（）。

A . M表示Model層，是存儲數據的地方
B . View表示視圖層，負責向用戶顯示外觀
C . Controller是控制層，負責控制流程
D . 在MVC架構中jsp通常做控制層

17.java中的類修飾符、成員變量修飾符、方法修飾符

18.下列定義變量的語句哪些是正確的（）

A. int $a = 10;
B. float f = 1.01;
C.long _int = 120
D.String[] str = {“a”,“b”,“c”};
原因：因爲Java裏帶有小數點的數默認是double類型，所以1.01在這裏是double類型，把他賦值給比他小的float類型就會出錯。你想通過編譯的話有3種方法改：
double f=1.01;
或者
float f=1.01f;
或者
float f=(float)1.01;

19.面向對象的特徵有哪些方面？

1.抽象：抽象是將一類對象的共同特徵總結出來構造類的過程，包括數據抽象和行爲抽象兩方面。抽象只關注對象有哪些屬性和行爲，並不關注這些行爲的細節是什麼

2.繼承 ：繼承是從已有類得到繼承信息創建新類的過程，提供繼承信息的類被稱爲父類，得到繼承信息的類被稱爲子類

3.封裝：通常認爲封裝是把數據和操作數據的方法綁定起來，對數據的訪問只能通過已定義的接口
4.多態：多態性是指允許不同子類型的對象對同一消息做出不同的響應。簡單的說就是用同樣的對象引用調用同樣的方法但是做了不同的事情 。
多態存在的三個必要條件：
繼承，重寫，父類引用指向子類對象
比如：Parent p = new Child();
當使用多態方式調用方法時，首先檢查父類中是否有該方法，如果沒有，則編譯錯誤；如果有，再去調用子類的同名方法。
多態的好處：可以使程序有良好的擴展，並可以對所有類的對象進行通用處理。
以下是一個多態實例的演示，詳細說明請看註釋：

public class Test {
    public static void main(String[] args) {
      show(new Cat());  // 以 Cat 對象調用 show 方法
      show(new Dog());  // 以 Dog 對象調用 show 方法
                
      Animal a = new Cat();  // 向上轉型  
      a.eat();               // 調用的是 Cat 的 eat
      Cat c = (Cat)a;        // 向下轉型  
      c.work();        // 調用的是 Cat 的 work
  }  
            
    public static void show(Animal a)  {
      a.eat();  
        // 類型判斷
        if (a instanceof Cat)  {  // 貓做的事情 
            Cat c = (Cat)a;  
            c.work();  
        } else if (a instanceof Dog) { // 狗做的事情 
            Dog c = (Dog)a;  
            c.work();  
        }  
    }  
}
 
abstract class Animal {  
    abstract void eat();  
}  
  
class Cat extends Animal {  
    public void eat() {  
        System.out.println("吃魚");  
    }  
    public void work() {  
        System.out.println("抓老鼠");  
    }  
}  
  
class Dog extends Animal {  
    public void eat() {  
        System.out.println("吃骨頭");  
    }  
    public void work() {  
        System.out.println("看家");  
    }  
}

結果：

吃魚
抓老鼠
吃骨頭
看家
吃魚
抓老鼠

20.String是基本的數據類型嗎？

解答：不是
Java中的基本數據類型只有8個
byte,short,int,long,float,double,char,boolean

21.float f = 3.4是否正確？

解答：不正確
3.4是雙精度數，將雙精度型（double）賦值給浮點型（float）屬於下轉型（down-casting，也稱爲窄化）會造成精度損失，因此需要強制類型轉換float f =(float)3.4; 或者寫成float f =3.4F;

22.short s1 = 1; s1 = s1 + 1 有錯嗎? short s1 = 1; s1 += 1 有錯嗎？

對於short s1 = 1; s1 = s1 + 1;由於1是int類型，因此s1+1運算結果也是int 型，需要強制轉換類型才能賦值給short型。而short s1 = 1; s1 += 1;可以正確編譯，因爲s1+= 1;相當於s1 = (short)(s1 + 1);其中有隱含的強制類型轉換

23.int和Integer有什麼區別？

爲了編程的方便還是引入了基本數據類型，但是爲了能夠將這些基本數據類型當成對象操作，Java爲每一個基本數據類型都引入了對應的包裝類型（wrapper class），int的包裝類就是Integer，從Java 5開始引入了自動裝箱/拆箱機制，使得二者可以相互轉換。 Java 爲每個原始類型提供了包裝類型：

• 原始類型: boolean，char，byte，short，int，long，float，double
• 包裝類型：Boolean，Character，Byte，Short，Integer，Long，Float，Double

class AutoUnboxingTest {
    public static void main(String[] args) {
        Integer a = new Integer(3);
        Integer b = 3;                  // 將3自動裝箱成Integer類型
        int c = 3;
        System.out.println(a == b);     // false 兩個引用沒有引用同一對象
        System.out.println(a == c);     // true a自動拆箱成int類型再和c比較
    }
}

public class Test03 {
    public static void main(String[] args) {
        Integer f1 = 100, f2 = 100, f3 = 150, f4 = 150;
        System.out.println(f1 == f2);   //true
        System.out.println(f3 == f4);   //false
    }
}

注意：如果整型字面量的值在-128 到127之間，那麼不會new新的Integer對象，而是直接用引用常量池中的Integer對象

24.Math.round(11.5) 等於多少？Math.round(-11.5)等於多少？

解答：
Math.round(11.5)的返回值是12，Math.round(-11.5)的返回值是-11。四捨五入的原理是在參數上加0.5然後進行下取整

25.數組有沒有length()方法？String有沒有length()方法？

解答：
數組沒有length()方法，有length的屬性。String有length()方法

26.是否可以繼承String類？

解答：
String類是final類，不可以被繼承

27.String和StringBuilder,StringBuffer的區別？

解答：

• String是隻讀字符串，也就意味着String引用的字符串內容是不能被改變
• StringBuffer和StringBuilder類表示的字符串對象可以直接進行修改

28.闡述final,finally,finalize的區別？

final:修飾符（關鍵字）有三種用法：

• 如果一個類被聲明爲final,意味着它不能再派生出新的子類，即不能被繼承
• 如果一個變量爲final,可以保證他們在使用中不被改變，被聲明爲final的變量必須在聲明時給定初值，而在以後的引用中只能讀取不可修改。
• 被聲明爲final的方法也同樣只能使用，不能在子類中被重寫

finally:通常放在try…catch…的後面構造總是執行代碼塊，無論正常執行還是發生異常這裏的代碼只要JVM不關閉都能執行

finalize:Object類中定義的方法，Java中允許使用finalize（）方法在垃圾收集器將對象從內存中清除出去之前做必要的清理工作。這個方法是由垃圾收集器在銷燬對象時調用的，通過重寫finalize（）方法可以整理系統資源或者執行其他清理工作

29.Collection和Collections的區別？

解答：

• Collection是一個接口，它是Set,List等容器的父接口
• Collections是一個工具類，提供一系列的靜態方法來輔助容器操作，這些方法包括對容器的搜索，排序，線程安全化等等

30.List,Map,Set三個接口存取元素時，各有什麼特點？

解答：

• List以特定索引來存取元素，可以有重複元素
• Set不能存放重複元素
• Map保存鍵值對映射，映射關係可以是一對一或者多對一

31.TreeMap和TreeSet在排序時如何比較元素？Collections工具類中的sort()方法如何比較元素？

解答：
TreeSet要求存放的對象所屬的類必須實現Comparable接口，該接口提供了比較元素的compareTo()方法，當插入元素時會回調該方法比較元素的大小。
TreeMap要求存放的鍵值對映射的鍵必須實現Comparable接口從而根據鍵對元素進行排序。
Collections工具類的sort方法有兩種重載的形式

• 第一種要求傳入的待排序容器中存放的對象必須實現Comparable接口以實現元素的比較
• 第二種不強制性的要求容器中的元素必須可比較，但是要求傳入第二個參數，參數是Comparator接口的子類型（需要重寫compare方法實現元素的比較）

32.Thread類的sleep()方法和對象的wait()方法都可以讓線程暫停執行，它們有什麼區別?

解答：
sleep()方法是線程類的靜態方法，調用此方法會讓當前線程暫停執行指定的時間，將執行機會讓給其他線程，因此休眠時間結束後會自動恢復
wait()是Object類的方法，調用對象的wait（）方法導致當前線程放棄對象的鎖，進入對象的等待池，只有調用對象的notify方法時才能喚醒等待池中的線程進入等鎖池，如果線程重新獲得對象的鎖就可以進入就緒狀態

33.請說出與線程同步以及線程調度相關的方法

解答:
wait()：使一個線程處於等待（阻塞）狀態，並且釋放鎖持有的對象的鎖
sleep()：使一個正在運行的線程處於睡眠狀態，是一個靜態方法，調用此方法要處理InterruptedException異常
notify()：喚醒一個處於等待狀態的線程，當然在調用此方法的時候，並不能確切的喚醒某一個等待狀態的線程，而是有Jvm確定喚醒哪個線程，而且與優先級無關
notityAll()：喚醒所有處於等待狀態的線程，該方法並不是將對象的鎖給所有線程，而是讓他們競爭，只有獲得鎖的線程才能進入就緒狀態

34.寫一個方法，輸入一個文件名和一個字符串，統計這個字符串在這個文件中出現的次數

public final class FileUtil{
 /**
 * @param filename 文件名
 * @param word 字符串
 */
 public static int countWordFile(String filename,String word){
  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() >= wword.length() && (index = line.indexOf(word)) >= 0){
			counter++;
			line = line.substring(index + word.length());
          }
	   }
     }
  } catch (Exceptino ex){
	ex.printStackTrace();
   }
  }
   return counter;
  }
 }

35.簡述一下你常用的設計模式

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

36.Java實現冒泡排序

public class BubbleSort{
	public static void sortMethods(int[] arr){
		int temp; //定義一個臨時變量
		for(int i= 0 ;i < arr.length-1;i++){
			for(int j= 0;j < arr.length-1-i;j++){
			if(arr[j+1] < arr[j]){
				temp = arr[j];
				arr[j] = arr[j+1];
				arr[j+1] = temp;
			  }
			 }
			}
       }
     public static void main(String[] args) {
	      int arr[] = new int[]{1,6,2,2,5};
	      BubbleSort.sortMethods(arr);
	      System.out.println(Arrays.toString(arr));
  }
}

37.Struts2面試題

1. Struts2工作流程

舉例說明：

2. Struts2 優點：
   (1)基於MVC架構，框架結構清晰
   (2)使用OGNL，可以快速的訪問值棧中的數據，調用值棧中對象的方法
   (3)Struts2中有很多特性都是通過攔截器實現的，例如異常處理，驗證。使用攔截器時會配置與重用
   (4)多種表現層技術，JSP，FreeMarker等
3. Struts2攔截器和過濾器的區別
   (1)過濾器依賴於Servlet容器，而攔截器不依賴於Servlet容器
   (2)Struts2攔截器只能對Action請求起作用，而過濾器則可以幾乎對所有的請求起作用
   (3)攔截器可以訪問Action上下文（ActionContext），而過濾器不行
   (4)在Action的生命週期中，攔截器可以多次調用，而過濾器只能在容器初始化時被調用一次
4. ValueStack
   (1) ValueStack是多實例的，因爲Action是多實例的（Servlet是單例的）每一個Action都有一個對應的值棧，Action對象默認保存在棧頂
   (2) ValueStack貫穿整個Action的生命週期，保存在request域中，所以ValueStack和request的生命週期時一樣的
5. 標籤（Struts2項目大多用到的標籤）
   • El表達式
   • JSP自定義標籤
   • JSTL標籤ku
   • OGNL表達式

38. Hibernate常見面試題詳解（樂觀鎖，悲觀鎖）

1. Hibernate數據三種狀態
   1.1 臨時的（剛new出來的數據，內存有，數據庫沒有）
   1.2 持久的（從數據庫查詢的，或者保存到數據庫，session沒關閉的，數據庫有，內存也有）
   1.3 遊離的 （數據庫有，內存沒有）
   三種狀態之間的轉化：
2. Hibernate概述
   Hibernate是一個開放源代碼的ORM（對象關係映射）框架，它對JDBC進行了非常輕量級的對象封裝
3. 什麼是對象持久化
   所謂持久化，即把數據保存到持久化設備，既可以永久保存的存儲設備中（磁盤，數據庫，XML數據文件中）
4. 爲什麼要持久化
   4.1 內存不能持久
   4.2 內存容量有限
   4.3 業務數據共享的需要
   4.4 爲了使用大規模的檢索
   4.5 數據管理的需要
5. Hibernate緩存機制
   5.1 一級緩存：session緩存
   5.2 二級緩存：sessionFactory緩存，可以跨session訪問（通過第三方緩存框架實現，例如：EHcache）
6. Hibernate的get和load方法的區別
   6.1 get和load都是利用主鍵策略查詢數據
   6.2 get默認不使用懶加載機制，load默認要使用懶加載，所謂懶加載就是我們這個數據如果不使用，hibernate就不發送sql到數據庫查詢數據
   6.3 當查詢數據庫中不存在的數據的時候，get方法返回null，load方法拋出空指針異常（原因是因爲，load方法採用的動態代理的方式實現的，我們使用load方法的時候，hibernate會創建一個該實體的代理對象，該代理只保存了該對象的ID，當我們訪問該實體對象其他屬性，hibernate就發送SQL查詢數據封裝到代理對象，然後在利用代理對象返回給我們實際的數據）

39.Mybatis面試題

1. mybatis概述：
   1.1 mybatis是一個半ORM(對象關係映射)框架，它內部封裝了JDBC,可以之間寫原生態sql,可以嚴格控制sql執行性能，靈活度高
   1.2 mybatis可以使用XML或註解來配置和映射原生信息
   1.3 通過XML文件或註解的方式將要執行的各種statement配置起來，並通過java對象和statement中sql的動態參數進行映射生成最終執行的sql語句
2. mybatis優點：
   2.1基於sql語句編程
   2.2與JDBC相比，代碼量會減少
   2.3能夠與Spring很好的集成
   2.4提供映射標籤
3. mybais缺點:
   3.1 sql語句的編寫工作量大
   3.2 sql語句以來數據庫，導致數據庫移值性差，不能隨意更換數據庫

40.Springboot面試題

1. Springboot的概述：用來簡化spring應用的初始搭建以及開發過程 使用特定的方式來進行配置（properties或yml文件）,習慣優於配置的方法（@EnableAutoConfiguration)
2. Spring boot 優點：
   2.1 獨立運行
   2.2 簡化配置
   2.3 自動配置
   2.4 無代碼生成和XML配置
   2.5 應用監控（actuator依賴）
   2.6 上手容易
   2.7 starters自動依賴與版本控制
   2.8 大量的自動配置，簡化開發，也可修改默認值
3. Springboot自動配置的原理：在Spring程序main方法中添加@SpringbootApplication或@EnablrAutoConfiguration會自動去maven中讀取每個starter中的spring.factories文件，該文件裏配置了所有需要被創建spring容器的bean
4. Spring Boot、Spring MVC 和 Spring 有什麼區別？
   4.1 SpringFramework最重要的特徵是依賴注入。所有SpringModules不是依賴注入就是IOC控制反轉
   4.2 SpringMvc提供了一種分離式的方法來開發 web應用。開發web應用比較簡單
   4.3 Spring boot 通過一個自動配置和啓動的項目解決這個問題

41.Redis 爲什麼查詢速度快？

1.完全基於內存
2.數據結構簡單
3.採用單線程

二.數據庫基礎知識

1.簡述或舉例說明什麼是數據庫的事務特性(ACID)？

（1）.原子性：
一個事物內所有操作共同組成一個原子包，要麼全部成功，要麼全部失敗，這是最基本的特性，保證了因爲一些其他因素導致數據庫異常，或者宕機
（2）.一致性：
一致性是指事物必須使數據庫從一個一致性狀態變換到另一個一致性狀態，也就是說一個事物執行之前和執行之後都必須處於一致性狀態
舉例：拿轉賬來說，假設用戶A和用戶B兩者的錢加起來一共是5000，那麼不管A和B之間如何轉賬，轉幾次帳，事物結束後兩個用戶的錢相加起來應該還得是5000，這就是事物的一致性
（3）.隔離性：（不考慮事務隔離性，會發生髒讀，不可重複讀，虛讀）
當多個用戶併發訪問數據庫時，比如操作同一張表時，數據庫爲每一個用戶開啓事物，不能被其他事物的操作所幹擾，多個併發事物之間要相互隔離。
即要達到這麼一種效果：對於任意兩個併發的事務T1和T2,在事務T1看來，T2要麼在T1開始之前就已經結束，要麼在T1結束之後纔開始，這樣每個事務都感覺不到其他事物在併發地執行
（4）.持久性:
持久性是指一個事物一旦被提交了，那麼對數據庫中的數據的改變就是永久性的，即便是在數據庫系統遇到故障的情況下也不會丟失提交事務的操作

2.以如下兩張表爲基礎，按照要求編寫sql:

要求：查詢每個部門員工總薪資是多少？
1.SELECT SUM(a.salary),b.department from emp a,dept b where a.`name` = b.`name` GROUP BY b.department

2.SELECT SUM(a.salary),b.department from emp a INNER JOIN dept b on a.`name` = b.`name` GROUP BY b.department

3.oracel常用函數及示例

一.單行函數：

• 字符函數：
  • concat(str1,str2) 字符串拼接函數
  • initcap(str) 將每個單詞首字母大寫，其他字母小寫
  • instr(x,find_string[,start][,occurrence]) 返回指定字符在某字符串中的位置，可以指定搜索的開始位置和返回第幾次搜索出來的結果
    select instr('Hello World!','o',1,2) from dual;--從1位置開始搜索，返回第二次出現o的位置，結果爲8
  • length(str) 返回表達式中的字符數
  • lengthb(str) 返回表達式中的字節數
  • lower(str) 將字符串轉換爲小寫
  • upper(str) 將字符串轉爲大寫
    …

二.聚焦函數

• 常用函數：
  • avg(x)：返回x的平均值
  • count(x)：返回統計的行數
  • max(x)：返回x的最大值
  • min(x)：返回x的最小值
  • sum(x)：返回x的總計值

4.SQL語句中修改表結構的命令是______。

A．MODIFY TABLE
B．MODIFY STRUCTURE
C．ALTER TABLE
D．ALTER STRUCTURE

5.ORACLE中的比較運算符

在ORACLE中有以下9種比較運算符：
（1）等於 =
（2）不等於 <> 或者！=
（3）大於 >
（4）小於 <
（5）大於或等於 >=
（6）小於或等於 <=
（7）ANY（使用ANY將一個值與某個列表中的任何值進行比較，此時必須在ANY之前添加一個（1）-（6）比較運算符中的一個）
例如：SELECT customers WHERE customer_id > ANY(1,2,3)
（8）SOME（等同於ANY操作符，可以使用ANY代替SOME比較操作符）
（9）ALL（使用ALL操作符將一個值與某個列表中的所有的值進行比較，此時必須在All之前添加一個（1）-（6）比較運算符中的一個）
例如：SELECT customers WHERE customer_id > ALL(1,2,3)

6.權限表的設計

三.邏輯面試題

1.中國女排在雅典奧運會奪冠的事實，使我們明白許多道理。例如，在失敗還未成爲最後的事實時。決不能輕易接受失敗!在勝利尚存一絲微弱的希望時，仍要拼盡全力去爭取勝利!否則，就不是真正的強者。從上述題幹可以推出下面哪個選項（）

A．真正的強者決不接受失敗

B．只有在失敗成爲不可改變的事實時，真正的強者纔會去接受失敗

C．失敗者會輕易地接受失敗

D．正如女排隊員愛唱的那首歌說的，陽光總在風雨後

2.某鎮有八個村，其中趙村所有的人都是在白天祭祀祖先，李莊所有的人都是在晚上才祭祀祖先。現在我們知道李明是晚上祭祀祖先的人。 由此，可以推斷______

A．李明一定是趙村的人
B．李明一定不是趙村的人
C．李明一定是李莊的人
D．李明一定不是李莊的人

3.媒體上最近充斥着有關某名人的八卦新聞，這使該名人陷入一種尷尬的境地：如果她不出面做澄清和反駁，那些謠言就會被大衆信以爲真；如果她出面做澄清和反駁，反而會引起更多人的關注，使那些八卦新聞傳播得更快更廣。這也許就是當名人不得不付出的代價吧。如果題幹中的陳述爲真，則下面哪一項必定爲真？

A．該名人實際上無法阻止那些八卦新聞對她個人聲譽的損害。

B．一位名人的聲譽不會受媒體上八卦新聞的影響。

C．在面對八卦新聞時，該名人所能採取的最好策略就是澄清真相。

D．該名人的一些朋友出面誇獎她，反而會起反效果。

4.趙、錢、孫、李、吳、鄭、王七名保安每週輪流值夜班。就值班時間而言，現 已知趙比孫晚一天；李比吳晚兩天；錢比王早三天；鄭在錢、孫之間，並且是在星期四。 根據上述題幹，下面哪一個關於值夜班的選項是真的___________。

A．吳在星期日
B．李在星期二
C．錢在星期二
D．孫在星期五

5.過度工作和壓力不可避免地導致失眠症。森達公司的所有管理人員都有壓力。儘管醫生已經提出警告，但大多數的管理人員每週工作仍然超過60小時，而其餘的管理人員每週僅僅工作40小時。只有每週工作超過40小時的員工才能得到一定的獎金。
以上的陳述最能支持下面哪項結論？（）

A.大多數得到一定獎金的森達公司管理人員患有失眠症
B.森達公司員工的大部分獎金給了管理人員
C.每週工作40小時的管理人員工作沒有過度
D.森達公司管理人員比任何別的員工組更易患失眠症