[Java面經]干貨整理, Java面試題(覆蓋Java基礎,Java高級,JavaEE,數據庫,設計模式等)

如若轉載請注明出處: http://www.cnblogs.com/wang-meng/p/5898837.html   謝謝.
上一篇發了一個找工作的面經, 找工作不宜, 希望這一篇的內容能夠幫助到大家.
對於這次跳槽找工作, 我准備了挺長的時間, 其中也收集了很多比較好的筆試面試題, 大都是一些常用的基礎, 很多都是由於時間原因沒有來得及給出答案, 但是題目大都是比較經典實用的, 現在都放到這里, 希望對正處於找工作的博友有一定的幫助.


第一部分: Java基礎(此部分面試題題目來自:http://www.hollischuang.com/archives/10  答案是搜集與互聯網)
(為了方便，我把他們分了類，有一些是必看的，我用！標注，有一些進階型的我用%標注，有一些需要了解的，我用？標注。)

一：繼承、抽象類與接口區別、訪問控制(private, public, protected，默認)、多態相關
！1、interface和 abstract class的區別
interface是接口，abstract class是抽象類。
1，語法層次
抽象類中可以擁有任意范圍的成員數據，可以定義非抽象方法。而接口中只能擁有靜態的不能修改的成員數據，同時所有的方法必須是抽象的。
所以說接口是抽象類的一種特例。
2，跨域不同
a,抽象類是對類的整體進行抽象，包括類的屬性和行為。接口是對類的局部(行為)進行抽象。
b,抽象類是is-a，跨域的是具有相似特點的類。接口是like-a,可以跨域不同的類。
例如貓、狗可以抽象一個動物類的抽象類，具備叫的方法。鳥、飛機可以實現Fly接口，具備飛的行為。
3，設計層次
抽象類是自下而上的一種設計思想，而接口是自頂而下的一種設計思想。
抽象類中我們要知道子類才能抽象出父類。而接口不同，它只需要定義一個規則即可。

！2、是否可以繼承多個接口，是否可以繼承多個抽象類
java可以實現多個接口，對於類是單繼承體系結構。

%3、Static Nested Class 和 Inner Class的不同
靜態內部類沒有了指向外部的引用，可以直接被實例化而不需要依附與外部類的實例化。
非靜態內部類保留了指向外部的引用，必須依附於外部類的實例化才能夠實例化內部類。
靜態嵌套類內部中：內部類不能訪問外部類的非靜態成員。外部類不能直接訪問靜態類中的屬性，需要通過內部類去訪問。
非靜態內部類中：內部類可以直接訪問外部類的屬性成員。外部類不能直接訪問靜態類中的屬性，需要通過內部類去訪問。
延伸：使用內部類最吸引人的原因是：每個內部類都能獨立地繼承一個類，所以無論外圍類是否已經繼承某個類，對內部類都沒有影響。
內部類：成員內部類(直接在外部類中)、局部內部類(內部類在方法或者作用域中)、嵌套內部類(static 修飾的內部類)、匿名內部類
這里需要說明一點：局部內部類和匿名內部類訪問局部變量時為和需要加final關鍵字？
局部變量的生命周期與局部內部類的對象的生命周期的不一致性。例如內部類innerClass在方法f()中，而方法f()中定義局部變量i且被內部類使用。
當方法f()運行結束后，局部變量i就已經死亡不存在了，但局部內部類對象可能還存在(直道沒有人再引用該對象才會消亡)，這時出現一種情況就是
局部內部類要訪問一個已經不存在的局部變量。而當變量被final修飾時，通過final將局部變量"復制"一份，復制品直接作為局部變量中的數據成員。

！4、Overload和Override的區別。Overloaded的方法是否可以改變返回值的類型?
overload重載和override重寫是Java多態性的不同表現。
overload是一個類多態性的表現，override是父類與之類多態性的不同表現。
override:子類中定義與父類相同的名稱及簽名. overload:方法相同方法簽名不同。
注意：不能通過訪問權限、返回類型、拋出的異常進行重載

！5、abstract的method是否可同時是static,是否可同時是native，是否可同時是synchronized
static 修飾的方法不能夠被重寫。

！6、是否可以繼承String類
不可以，String是被final修飾的類。

！7、構造器Constructor是否可被override?
構造器不能被繼承，所以也不能夠被重寫。

！8、作用域public,protected,private,以及不寫時的區別?
不寫時默認是default，這里主要說明這幾個作用域的使用范圍。
作用域 當前類 同一package 子孫類 其他package
public √ √ √ √
protected √ √ √ ×
friendly √ √ × ×
private √ × × ×
這里需要說明的是在同一個package， public、protected、friendly使用范圍一致。
而在其他package中，只有子孫類中protected才能被訪問。

二：collections相關的數據結構及API
http://cmsblogs.com/?p=106
！1、列舉幾個Java Collection類庫中的常用類
此處應該有Collection類圖。
Collection是java.util 中的一個接口。繼承自Iterable。
子接口：List、Set、Queue...
實現類：ArrayList、LinkedList、HashSet、TreeSet、Vector、Stack
其他相關類：Iterator、TreeMap、HashTable、HashMap
Collection接口是最基本的集合接口，它不提供直接的實現，Java SDK提供的類都是繼承自Collection的"子接口"
如List和Set。Collection所代表的是一種規則，它所包含的元素都必須遵循一條或者多條規則。
如有些允許重復而有些則不能重復、有些必須要按照順序插入而有些則是散列，有些支持排序但是有些則不支持。

！2、List、Set、Map是否都繼承自Collection接口？
List、Set繼承自Collection接口，而Map不是。
(1)List 所代表的是有序的Collection。實現List接口的集合主要有：ArratList、LinkedList、Vector、Stack。
(2) Set是一種不包括重復元素的Collection。實現了Set接口的集合有：EnumSet、HashSet、TreeSet。
(3)Map與List、Set接口不同，它是由一系列鍵值對組成的集合，提供了key到Value的映射。同時它也沒有繼承Collection。
實現map的有：HashMap、TreeMap、HashTable、Properties、EnumMap。

！3、HashMap和Hashtable的區別
需查看源碼。
1、歷史原因:Hashtable是基於陳舊的Dictionary類的，HashMap是Java 1.2引進的Map接口的一個實現 。
2、同步性:Hashtable是線程安全的，也就是說是同步的，而HashMap是線程序不安全的，不是同步的 。
3、值：只有HashMap可以讓你將空值作為一個表的條目的key或value 。

1.HashTable的方法是同步的，在方法的前面都有synchronized來同步，HashMap未經同步，所以在多線程場合要手動同步
2.HashTable不允許null值(key和value都不可以) ,HashMap允許null值(key和value都可以)。
3.HashTable有一個contains(Object value)功能和containsValue(Object value)功能一樣。
4.HashTable使用Enumeration進行遍歷，HashMap使用Iterator進行遍歷。
5.HashTable中hash數組默認大小是11，增加的方式是 old*2+1。HashMap中hash數組的默認大小是16，而且一定是2的指數。
6.哈希值的使用不同，HashTable直接使用對象的hashCode，代碼是這樣的：
int hash = key.hashCode();
int index = (hash & 0x7FFFFFFF) % tab.length;
而HashMap重新計算hash值，而且用與代替求模：

int hash = hash(k); 2 int i = indexFor(hash, table.length); 3 static int hash(Object x) { 4     h ^= (h >>> 20) ^ (h >>> 12); 5     return h ^ (h >>> 7) ^ (h >>> 4); 6 }

 

&&延展：
A、HashMap與HashSet的關系
1、HashSet底層是采用HashMap實現的：

public HashSet() { map = new HashMap<E,Object>(); }

2、調用HashSet的add方法時，實際上是向HashMap中增加了一行(key-value對)，該行的key就是向HashSet增加的那個對象，該行的value就是一個Object類型的常量。

private static final Object PRESENT = new Object(); public boolean add(E e) { return map.put(e, PRESENT)==null; } public boolean remove(Object o) { return map.remove(o)==PRESENT; }

 

B、HashMap 和 ConcurrentHashMap 的關系
關於這部分內容建議自己去翻翻源碼，ConcurrentHashMap 也是一種線程安全的集合類，他和HashTable也是有區別的，主要區別就是加鎖的粒度以及如何加鎖，ConcurrentHashMap 的加鎖粒度要比HashTable更細一點。將數據分成一段一段的存儲，然后給每一段數據配一把鎖，當一個線程占用鎖訪問其中一個段數據的時候，其他段的數據也能被其他線程訪問。

%4、HashMap中是否任何對象都可以做為key,用戶自定義對象做為key有沒有什么要求？
用戶自定義的對象當作key需要實現Map中的hashCode和Equals方法。
HashMap用可以的哈希值來存儲和查找鍵值對。
當插入一個Entry時，HashMap會計算Entry Key 的哈希值。Map會根據這個哈希值把Entry插入到相應的位置。
查找時，HashMap通過計算Key的哈希值到特定的位置查找這個Entry。
如果我們在使用自定義對象做為Key時，我們需要保證當改變對象的狀態的時候，不改變它的哈希值。

！5、Collection 和 Collections的區別
Collection 是一個接口，它是各種集合結構的父接口。
Collections是一個包裝類，它包含有各種有關集合操作的靜態方法。Collcetions不能被實例化，它的構造函數是私有的。
例如：
sort():專門針對LIST進行排序，在實際開發中，我們確實經常需要對一個裝有一些對象的LIST進行排序！
min/max():如果，我們想取一個集合中的最小、最大值，如何快速的取到呢？上面的方法將幫我們實現。
reverse():如果，我們僅僅需要得到一個LIST的相反順序！
Shuffle():通過這個方法，將使得LIST中元素的順序不可預測，即順序是隨機的，混排的。
synchronizedList():返回指定列表支持的同步（線程安全的）列表。
...

%6、其他的集合類：concurrenthashmap,treemap,treeset,linkedhashmap等。
(1)ConcurrentHashMap:http://www.cnblogs.com/ITtangtang/p/3948786.html
(2)TreeMap:
(3)TreeSet:
(4)LinkedHashMap:

三：異常體系
！1、Error、Exception和RuntimeException的區別，作用又是什么？列舉3個以上的RuntimeException
Throwable是java語言中所有錯誤和異常的超類。它有兩個子類：Error、Exception。
Error為錯誤的意思，是程序無法處理的，如OutOfMemoryErro、ThreadDeath等，出現這種情況你唯一能做的就是聽之任之，交由JVM來處理，不過JVM在大多數情況下會選擇中止線程。
Exception是程序可以處理的異常，分為CheckedException(受檢異常)，另一種是UncheckedException(不受檢異常)。其中CheckExpection是發生在編譯階段，必須要使用try...catch(或者throws)，否則編譯不通過。
而UnceckedException發生在運行期，具有不確定性，主要是由程序的邏輯問題引起的，難以排查，我們一般需要縱觀全局才能夠發現這類的異常錯誤。所以在程序設計中我們需要認真考慮，盡量處理異常，即使產生了異常，也能盡量保證程序朝着有利方向發展。

！2、Java中的異常處理機制的簡單原理和應用
(1)當Java程序違反了Java的語義規則時，Java虛擬機就會將發生的錯誤表示為一個異常。
違反語義規則包括2種情況：
(a)一種是Java類庫內置的語義檢查。
(b)另一種情況就是Java允許程序員擴展這種語義檢查，程序員可以創建自己的異常，並自由選擇在何時用throw關鍵字引發異常。
(2)所有的異常都是java.lang.Throwable的子類。

！3、內存溢出和內存泄露
http://wade6.iteye.com/blog/1842907
內存溢出：指在指定大小的內存空間，寫入了超出大小的數據，從而導致了內存益處。通俗地說，就是內存不夠，沒辦法支持當前程序。
當發生內存益出時，程序將無法進行，強制終止。
內存泄露：指某個程序已不再執行，卻始終占用着內存，不釋放，從而消耗着資源，稱其為內存泄露。
當發生內存泄露，那么可用內存會逐漸減少，從而降低性能。

(a)對於內存的溢出可能發生的情況，大概有幾種：
1、在程序中存在死循環，或者循環過多，而產生了過多重復的對象的實例。
2、存在對象的引用，使用完后沒有清除，導致Java虛擬機不能回收。
3、一次操作時，在內存中加載了大量的數據，原則上說，在java中，由於它的自動垃圾回收機制，出現內存溢出的可能性並不是很大。

(b)對於內存泄露可能發生的情況，大概有幾種：
1、長生命周期的對象持有短生命周期的引用。
這是內存泄露最常見的場景，也是代碼設計中經常出現的問題。
例如：在全局靜態map中緩存局部變量，且沒有清空操作，隨着時間的推移，這個map會越來越大，造成內存泄露。

2、修改hashset中對象的參數值，且參數是計算哈希值的字段。
當一個對象被存儲進HashSet集合中以后，就不能修改這個對象中的那些參與計算哈希值的字段，否則對象修改后的哈希值與最初存儲進HashSet集合中時的哈希值就不同了，在這種情況下，即使在contains方法使用該對象的當前引用作為參數去HashSet集合中檢索對象，也將返回找不到對象的結果，這也會導致無法從HashSet集合中刪除當前對象，造成內存泄露。

3、機器的連接數和關閉時間設置。
長時間開啟非常耗費資源的連接，也會造成內存泄露。

解決方案：
1、盡早釋放無用對象的引用
2、使用字符串處理，避免使用String，應大量使用StringBuffer，每一個String對象都得獨立占用內存一塊區域
3、盡量少用靜態變量，因為靜態變量存放在永久代（方法區），永久代基本不參與垃圾回收
4、避免在循環中創建對象
5、開啟大型文件或從數據庫一次拿了太多的數據很容易造成內存溢出，所以在這些地方要大概計算一下數據量的最大值是多少，並且設定所需最小及最大的內存空間值。

四：其他
！1、String和StringBuffer、StringBuilder的區別
http://www.cnblogs.com/xudong-bupt/p/3961159.html
1，可變與不可變化性
String類中使用字符數組保存字符串，因為有final修飾，所以string是不可變的。
private final char value[];
關於不可變性：http://www.hollischuang.com/archives/1230
StringBUilder和StringBuffer的公共父類是：AbstracStringBuilder類，在AbstracStringBu中也是使用字符數組保存字符串，可知這兩種對象都是可變的。
char[] value;

2，是否多線程安全
String中對象是不可變得，也可以理解為常量，顯然是線程安全的。
StringBuffer對方法加了同步鎖或者對調用的方法加了同步鎖，所以是線程安全的。
StringBuilder並沒有對方法進行加同步鎖，所以是非線程安全的。

！2、String s = “123”;這個語句有幾個對象產生
創建了一個對象，將“123”存儲到常量池中。
延展：String s = new String("abc")這個語句創建了幾個對象？
這種題目主要就是為了考察程序員對字符串對象的常量池掌握與否。上述的語句中是創建了2個對象，第一個對象是”abc”字符串存儲在常量池中，第二個對象在JAVA Heap中的 String 對象。

！3、reader和inputstream區別
首先要分清reader和inputstream，一個是讀取字符流，一個是讀取字節流。
InputStream是表示字節輸入流的所有類的超類，Reader是用於讀取字符流的抽象類
InputStream提供的是字節流的讀取，而非文本讀取，這是和Reader類的根本區別。
即用Reader讀取出來的是char數組或者String ，使用InputStream讀取出來的是byte數組。
http://blog.sina.com.cn/s/blog_6d3183b50101cri5.html

！4、==和equals的區別
1.基本數據類型，也稱原始數據類型。byte,short,char,int,long,float,double,boolean
他們之間的比較，應用雙等號（==）,比較的是他們的值。
2.復合數據類型(類)
當他們用（==）進行比較的時候，比較的是他們在內存中的存放地址，所以，除非是同一個new出來的對象，他們的比較后的結果為true，否則比較后結果為false。
JAVA當中所有的類都是繼承於Object這個基類的，在Object中的基類中定義了一個equals的方法，這個方法的初始行為是比較對象的內存地 址，但在一些類庫當中這個方法被覆蓋掉了，如String,Integer,Date在這些類當中equals有其自身的實現，而不再是比較類在堆內存中的存放地址了。
對於復合數據類型之間進行equals比較，在沒有覆寫equals方法的情況下，他們之間的比較還是基於他們在內存中的存放位置的地址值的，因為Object的equals方法也是用雙等號（==）進行比較的，所以比較后的結果跟雙等號（==）的結果相同。

對於String復寫Object的equals方法，只是比較字符串值是否相等：
String類中的equals()方法：

public boolean equals(Object anObject)  2 {  3     //如果是同一個對象
    if (this == anObject)  5  {  6         return true;  7  }  8     //如果傳遞進來的參數是String類的實例
    if (anObject instanceof String) 10  { 11         String anotherString = (String)anObject; 12         int n = count;//字符串長度
        if (n == anotherString.count) //如果長度相等就進行比較
 { 15             char v1[] = value;//取每一個位置的字符
            char v2[] = anotherString.value; 17             int i = offset; 18             int j = anotherString.offset; 19             while (n-- != 0) //對於每一位置逐一比較
 { 21                 if (v1[i++] != v2[j++]) 22                 return false; 23  } 24             return true; 25  } 26  } 27     return false; 28 }

%5、hashCode的作用
http://www.cnblogs.com/dolphin0520/p/3681042.html
很多地方都會利用到hash表來提高查找效率。在Java的Object類中有一個方法:
public native int hashCode();
hashCode方法的主要作用是為了配合基於散列的集合一起正常運行，這樣的散列集合包括HashSet、HashMap以及HashTable。
考慮一種情況，當向集合中插入對象時，如何判別在集合中是否已經存在該對象了？（注意：集合中不允許重復的元素存在）
也許大多數人都會想到調用equals方法來逐個進行比較，這個方法確實可行。但是如果集合中已經存在一萬條數據或者更多的數據，如果采用equals方法去逐一比較，效率必然是一個問題。此時hashCode方法的作用就體現出來了，當集合要添加新的對象時，先調用這個對象的hashCode方法，得到對應的hashcode值，實際上在HashMap的具體實現中會用一個table保存已經存進去的對象的hashcode值，如果table中沒有該hashcode值，它就可以直接存進去，不用再進行任何比較了；如果存在該hashcode值， 就調用它的equals方法與新元素進行比較，相同的話就不存了，不相同就散列其它的地址，所以這里存在一個沖突解決的問題，這樣一來實際調用equals方法的次數就大大降低了，說通俗一點：Java中的hashCode方法就是根據一定的規則將與對象相關的信息（比如對象的存儲地址，對象的字段等）映射成一個數值，這個數值稱作為散列值。

%6、hashCode和equals方法的關系
在有些情況下，程序設計者在設計一個類的時候為需要重寫equals方法，比如String類，但是千萬要注意，在重寫equals方法的同時，必須重寫hashCode方法。
也就是說對於兩個對象，如果調用equals方法得到的結果為true，則兩個對象的hashcode值必定相等；
如果equals方法得到的結果為false，則兩個對象的hashcode值不一定不同；
如果兩個對象的hashcode值不等，則equals方法得到的結果必定為false；
如果兩個對象的hashcode值相等，則equals方法得到的結果未知。

？7、Object類中有哪些方法，列舉3個以上（可以引導）
媽蛋，這個在我校招也是我參加的第一次面試時問到了，當時覺得怎么會問這么簡單的問題，但是最后自己還是回答不全。
Object方法：equals()、toString()、finalize()、hashCode()、getClass()、clone()、wait()、notify()、notifyAll()

！8、char型變量中能不能存貯一個中文漢字?為什么?
CHAR類型變量時能夠定義成為一個中文的，因為java中以unicode編碼，一個char占16個字節，所以放一個中文是沒問題的。
char型變量是用來存儲Unicode編碼的字符的，unicode編碼字符集中包含了漢字，所以，char型變量中當然可以存儲漢字啦。不過，如果某個特殊的漢字沒有被包含在unicode編碼字符集中，那么，這個char型變量中就不能存儲這個特殊漢字。補充說明：unicode編碼占用兩個字節，所以，char類型的變量也是占用兩個字節。

%9、了解過哪些JDK8的新特性，舉例描述下相應的特性？
！10、Input/OutputStream和Reader/Writer有何區別？何為字符，何為字節？
！11、如何在字符流和字節流之間轉換？
InputStreamReader是字節流向字符流的橋梁，它使用指定的charset讀取字節並將其解碼為字符。
OutputStreamWriter是字符流通向字節流的橋梁，它使用指定的charset將要寫入流中的字符編碼成字節，它使用的字符集可以由名稱指定或顯示給定，否則將接受默認的字符集：

！12、啟動一個線程是用run()還是start()?
start()方法是啟動（即開辟)一個線程的方法，因此線程的啟動必須通過此方法，
而run()方法，只是Thread類的一個方法，它本身並不能開辟線程。

%13、海量數據查詢、存儲
！14、switch可以使用那些數據類型
A switch works with the byte, short, char, and int primitive data types. It also works with enumerated types (discussed in Enum Types), the String class, and a few special classes that wrap certain primitive types: Character, Byte, Short, and Integer (discussed in Numbers and Strings).

！15、多線程與死鎖
實現多線程的幾種方式：
繼承Thread/實現Runnable接口。
所謂死鎖: 是指兩個或兩個以上的進程在執行過程中，因爭奪資源而造成的一種互相等待的現象，若無外力作用，它們都將無法推進下去。

%16、Java的四種引用
！17、序列化與反序列化
！18、自動裝箱與拆箱
！19、正則表達式

五：JAVA開發工具、環境的使用
IDE、maven、svn/git、Linux、Firebug

第二部分: Java高級

一：多線程
！1、多線程的實現方式，有什么區別
java中可以通過繼承Thread和實現Runnable接口來實現多線程。
兩者的區別：
a,一個類只能繼承一個父類，存在局限；一個類中可以實現多個接口。
b,在實現Runable接口的時候調用Thread的Thread(Runnable run)或者Thread(Runnable run, String name)構造方法創建進程時，使用同一個Runnable實例，所以建立的多線程的實例變量是可以共享的。

public class RunThread implements Runnable{} public static void main(String[] args){ RunThread thread = new RunThread(); new Thread(thread).start(); new Thread(thread).start(); }

c,Runnable接口和Thread之間的聯系：
public class Thread extends Object implements Runnable

%2、同步和並發是如何解決的

3、什么叫守護線程，用什么方法實現守護線程（Thread.setDeamon()的含義）
在Java中有兩類線程：User Thread(用戶線程)、Daemon Thread(守護線程)
用個比較通俗的比如，任何一個守護線程都是整個JVM中所有非守護線程的保姆：
只要當前JVM實例中尚存在任何一個非守護線程沒有結束，守護線程就全部工作；只有當最后一個非守護線程結束時，守護線程隨着JVM一同結束工作。
JVM內部的實現是如果運行的程序只剩下守護線程的話，程序將終止運行，直接結束。所以守護線程是作為輔助線程存在的，主要的作用是提供計數等等輔助的功能。

%4、如何停止一個線程？
終止線程的三種方法：
1. 使用退出標志，使線程正常退出，也就是當run方法完成后線程終止。
在定義退出標志exit時，使用了一個Java關鍵字volatile，這個關鍵字的目的是使exit同步，也就是說在同一時刻只能由一個線程來修改exit的值，
2. 使用stop方法強行終止線程（這個方法不推薦使用，因為stop和suspend、resume一樣，也可能發生不可預料的結果）。
使用stop方法可以強行終止正在運行或掛起的線程。我們可以使用如下的代碼來終止線程：
thread.stop();
雖然使用上面的代碼可以終止線程，但使用stop方法是很危險的，就象突然關閉計算機電源，而不是按正常程序關機一樣，可能會產生不可預料的結果，因此，並不推薦使用stop方法來終止線程。
3. 使用interrupt方法中斷線程。
使用interrupt方法來終端線程可分為兩種情況：
（1）線程處於阻塞狀態，如使用了sleep方法。
（2）使用while（！isInterrupted（））{……}來判斷線程是否被中斷。
在第一種情況下使用interrupt方法，sleep方法將拋出一個InterruptedException例外，而在第二種情況下線程將直接退出。下面的代碼演示了在第一種情況下使用interrupt方法。
注意：在Thread類中有兩個方法可以判斷線程是否通過interrupt方法被終止。一個是靜態的方法interrupted（），一個是非靜態的方法isInterrupted（），這兩個方法的區別是interrupted用來判斷當前線是否被中斷，而isInterrupted可以用來判斷其他線程是否被中斷。因此，while （！isInterrupted（））也可以換成while （！Thread.interrupted（））。

！5、解釋是一下什么是線程安全？舉例說明一個線程不安全的例子。解釋Synchronized關鍵字的作用。
線程安全就是多線程訪問時，采用了加鎖機制，當一個線程訪問該類的某個數據時，進行保護，其他線程不能進行訪問直到該線程讀取完，其他線程才可使用。不會出現數據不一致或者數據污染。
線程不安全就是不提供數據訪問保護，有可能出現多個線程先后更改數據造成所得到的數據是臟數據
在多線程的情況下，由於同一進程的多個線程共享同一片存儲空間，在帶來方便的同時，也帶來了訪問沖突這個嚴重的問題。Java語言提供了專門機制以解決這種沖突，有效避免了同一個數據對象被多個線程同時訪問。
由於我們可以通過 private 關鍵字來保證數據對象只能被方法訪問，所以我們只需針對方法提出一套機制，這套機制就是 synchronized 關鍵字，它包括兩種用法：synchronized 方法和 synchronized 塊。

 

！6、當一個線程進入一個對象的一個synchronized方法后，其它線程是否可進入此對象的其它方法?
可進入其他對象的非synchronized方法，但是如果其他有加synchronized的方法將處於阻塞狀態。

二：內存結構，GC
！1、gc的概念，如果A和B對象循環引用，是否可以被GC？
兩個對象相互引用，是會不會被GC沒有直接關系。采用的GC Roots可達性來決定是否會被GC回收。
現在的GC都采用分代收集的方式，不同的區采用不同的算法，大致有：復制，標記-清掃，標記-壓縮，標記-清掃-壓縮等。

%2、Java中的內存溢出是如何造成的
http://outofmemory.cn/java/OutOfMemoryError/PermGen-space-Java-heap-space-unable-create-new-native-thread
jvm管理的內存大致包括三種不同類型的內存區域：Permanent Generation space（永久保存區域）、Heap space(堆區域)、Java Stacks(Java棧）。
其中永久保存區域主要存放Class（類）和Meta的信息，Class第一次被Load的時候被放入PermGen space區域，Class需要存儲的內容主要包括方法和靜態屬性。
堆區域用來存放Class的實例（即對象），對象需要存儲的內容主要是非靜態屬性。每次用new創建一個對象實例后，對象實例存儲在堆區域中，這部分空間也被jvm的垃圾回收機制管理。
而Java棧跟大多數編程語言包括匯編語言的棧功能相似，主要基本類型變量以及方法的輸入輸出參數。Java程序的每個線程中都有一個獨立的堆棧。容易發生內存溢出問題的內存空間包括：Permanent Generation space和Heap space。

第一種OutOfMemoryError： PermGen space
發生這種問題的原意是程序中使用了大量的jar或class，使java虛擬機裝載類的空間不夠，與Permanent Generation space有關。解決這類問題有以下兩種辦法：
1,增加java虛擬機中的XX:PermSize和XX:MaxPermSize參數的大小，其中XX:PermSize是初始永久保存區域大小，XX:MaxPermSize是最大永久保存區域大小。如針對tomcat6.0，在catalina.sh 或catalina.bat文件中一系列環境變量名說明結束處（大約在70行左右） 增加一行： JAVA_OPTS=" -XX:PermSize=64M -XX:MaxPermSize=128M" 如果是windows服務器還可以在系統環境變量中設置。感覺用tomcat發布sprint+struts+hibernate架構的程序時很容易發生這種內存溢出錯誤。使用上述方法，我成功解決了部署ssh項目的tomcat服務器經常宕機的問題。
2,清理應用程序中web-inf/lib下的jar，如果tomcat部署了多個應用，很多應用都使用了相同的jar，可以將共同的jar移到tomcat共同的lib下，減少類的重復加載。這種方法是網上部分人推薦的，我沒試過，但感覺減少不了太大的空間，最靠譜的還是第一種方法。
第二種OutOfMemoryError： Java heap space
發生這種問題的原因是java虛擬機創建的對象太多，在進行垃圾回收之間，虛擬機分配的到堆內存空間已經用滿了，與Heap space有關。解決這類問題有兩種思路：
1,檢查程序，看是否有死循環或不必要地重復創建大量對象。找到原因后，修改程序和算法。 我以前寫一個使用K-Means文本聚類算法對幾萬條文本記錄（每條記錄的特征向量大約10來個）進行文本聚類時，由於程序細節上有問題，就導致了Java heap space的內存溢出問題，后來通過修改程序得到了解決。
2,增加Java虛擬機中Xms（初始堆大小）和Xmx（最大堆大小）參數的大小。如：set JAVA_OPTS= -Xms256m -Xmx1024m

%3、jvm gc如何判斷對象是否需要回收，有哪幾種方式？
(1)、引數記數 (Reference Counting)
給對象添加一個引用計數其，每有一個地方引用這個對象，計數器值加1，每有一個引用失效則減1。
優點：實現簡單、判斷效率高。 缺點：難以解決對象之間的循環引用問題。
(2)、可達性分析(Reachability Analysis)
從GC Roots(每種具體實現對GC Roots有不同的定義)作為起點，向下搜索它們引用的對象，可以生成一棵引用樹，樹的節點視為可達對象，反之視為不可達。
JVM使用“可達性分析算法”來判定一個對象是否會可以被回收，有兩個細節需要注意：
1.Java的GC Roots如何定義
Java中GC Roots包括以下幾種對象：
a.虛擬機棧（幀棧中的本地變量表）中引用的對象
b.方法區中靜態屬性引用的對象
c.方法區中常量引用的對象
d.本地方法棧中JNI引用的對象

2.不可達對象一定會被回收嗎
不是。
執行垃圾回收前JVM會執行不可達對象的finalize方法，如果執行完畢之后該對象變為可達，則不會被回收它。
但一個對象的finalize方法只會被執行一次。

？4、Java中的內存溢出和C＋＋中的內存溢出，是一個概念嗎？
！5、引用計數，對象引用遍歷；jvm有哪幾種垃圾回收機制？講講分代回收機制
引用技術法 Reference Counting：
引用計數器的實現很簡單，對於一個對象 A，只要有任何一個對象引用了 A，則 A 的引用計數器就加 1，當引用失效時，引用計數器就減 1。只要對象 A 的引用計數器的值為 0，則對象 A 就不可能再被使用。
引用計數器的實現也非常簡單，只需要為每個對象配置一個整形的計數器即可。但是引用計數器有一個嚴重的問題，即無法處理循環引用的情況。因此，在 Java 的垃圾回收器中沒有使用這種算法。
分帶回收：Generational Collection

 

三：CLASSLOADER
！1、ClassLoader的功能和工作模式
Java中的所有類，必須被裝載到jvm中才能運行，這個裝載工作是由jvm中的類裝載器完成的，類裝載器所做的工作實質是把類文件從硬盤讀取到內存中，JVM在加載類的時候，都是通過ClassLoader的loadClass（）方法來加載class的，loadClass使用雙親委派模式。

 

四：NIO
？1、IO和NIO本質不同在實際項目使用場景及如何使用

五：其他
？1、hashcode 有哪些算法
%2、反射,是否可以調用私有方法,在框架中的運用
？3、知道范型的實現機制嗎？
？4、Socket編程通常出現的異常有哪些，什么情況下會出現
？5、了解JVM啟動參數嗎？-verbose -Xms -Xmx的意思是什么？
%6、StringBuffer的實現方式，容量如何擴充
%7、代理機制的實現

第三部分: JavaEE

一：Servlet的掌握，包括新的異步Servlet
！1、Servelt的概念。常問http request能獲得的參數
Servlet 是一種基於java技術的web組件，是一種基於java的且與第三方平台無關的類。通常，它可以被Web 服務器編譯、加載和運行，最后生成動態的資源內容。

%2、servlet中，如何定制session的過期時間？
在web.xml中配置：
<session-config>
<session-timeout>20</session-timeout>
</session-config>
上面這種設置，對整個web應用生效。當客戶端20分鍾內都沒有發起請求時，容器會將session干掉。單位為分鍾。

session.setMaxInactiveInterval(30*60);
單位是秒。Session設置產生效果的優先循序是，先程序后配置，先局部后整體。

！3、Servlet中的session工作原理 （禁用cookie如何使用session）
http://dxz.iteye.com/blog/2193399?utm_source=tuicool&utm_medium=referral
session，中文經常翻譯為會話，其本來的含義是指有始有終的一系列動作/消息。
Cookies是一種能夠讓網站服務器把少量數據儲存到客戶端的硬盤或內存，或是從客戶端的硬盤讀取數據的一種技術。Cookies是當你瀏覽某網站時，由Web服務器置於你硬盤上的一個非常小的文本文件，它可以記錄你的用戶ID、密碼、瀏覽過的網頁、停留的時間等信息。
session: 當用戶請求來自應用程序的 Web 頁時，如果該用戶還沒有會話，則 Web 服務器將自動創建一個 Session 對象。當會話過期或被放棄后，服務器將終止該會話。
cookie機制：采用的是在客戶端保持狀態的方案，而session機制采用的是在服務端保持狀態的方案。同時我們看到由於服務器端保持狀態的方案在客戶端也需要保存一個標識，所以session機制可能需要借助cookie機制來達到保存標識的目的。
session機制：服務器首先檢查這個客戶端的請求里是否已經包含了一個session標識（session id）如果含有sessionid則說明以前為此客戶端創建過session服務器就會把這個按照session Id把session給檢索出來（如果檢索不到就會重新建立一個session），如果客戶端請求不包含session id，
則為此客戶端創建一個session並且生成一個與此對應的session id，session id是一個不會重復的字符串，該id會在本次響應客戶端的時候傳送給客戶端。
保存這個session id的方式：
a、可以采用cookie，這樣就可以在交互的過程中自動的按照規則把這個表示發送給服務器。一般這個cookie的名字類似於SEEESIONID的，但是cookie可以被人為禁止。
b、所以也經常使用一種使用一種叫做URL重寫的技術，就是把sessionid直接附加在URL路徑的后面。
c、還有一種技術叫做表單隱藏字段。就是服務器會自動修改表單添加一個隱藏的字段，在表單提交的時候就會把這個session id傳遞會服務器。

session和cookie的區別：
cookie數據放在客戶端，session數據放在服務器端。
cookie不是很安全，別人可以分析存放在本地的cookie並進行cookie欺騙考慮安全性的話應該使用session。
session因為在服務器上保存了很多信息，當在訪問量比較大的時候會增加服務器的負擔，從這方面考慮應該使用cookie
單個cookie的數據不能超過4K，很多瀏覽器都限制一個站點最多保存20個cookie
有人建議將登錄信息等重要信息放在session中，非重要的信息可以放在cookie中。

！4、servlet中，filter的應用場景有哪些？
1，通過filter進行全站字符編碼過濾
get/post 提交不同。
post 是表單提交
get方法提交的話是將數據帶在你的url上面傳過去的。
request.setCharacterEncoding("UTF-8");這個是只對post方法有用，如果想對get方法有用就在tomcat配置文件server.xml中Connector元素下設置
URIEncoding="UTF-8"

！5、描述JSP和Servlet的區別、共同點（JSP的工作原理）。
盡管JSP在本質上就是SERVLET,但是兩者的創建方式不一樣.Servlet完全是JAVA程序代碼構成擅長於流程控制和事務處理而通過Servlet
來生成動態網頁很不直觀;JSP由HTML代碼和JSP標簽構成可以方便地編寫動態網頁因此在實際應用中采用Servlet來控制業務流程,而采
用JSP來生成動態網頁.在struts框架中,JSP位於MVC設計模式的視圖層,而Servlet位於控制層。

服務器在執行jsp的時候，首先把jsp翻譯成一個Servlet，所以我們訪問jsp時，其實不是在訪問jsp，而是在訪問jsp翻譯過后的那個Servlet

？6、JSP的動態include和靜態include
！7、Servlet的生命周期
init service destory

二：WEB框架的掌握(挑其掌握的一種)
！1、Struts中請求的實現過程
！2、MVC概念
%3、談一下自己最熟悉的web框架？然后就了解的web框架再深入下去
%4、Spring mvc與Struts mvc的區別 （什么是Mvc框架）
？5、Service嵌套事務處理，如何回滾

三：http相關(內部重定向，外部重定向)，http返回碼
！1、session和cookie的區別
！2、HTTP請求中Session實現原理？
%3、如果客戶端禁止Cookie能實現Session嗎？
！4、http get和post區別
GET在瀏覽器回退時是無害的，而POST會再次提交請求。
GET產生的URL地址可以被Bookmark，而POST不可以。
GET請求會被瀏覽器主動cache，而POST不會，除非手動設置。
GET請求只能進行url編碼，而POST支持多種編碼方式。
GET請求參數會被完整保留在瀏覽器歷史記錄里，而POST中的參數不會被保留。
GET請求在URL中傳送的參數是有長度限制的，而POST么有。
對參數的數據類型，GET只接受ASCII字符，而POST沒有限制。
GET比POST更不安全，因為參數直接暴露在URL上，所以不能用來傳遞敏感信息。
GET參數通過URL傳遞，POST放在Request body中。

！5、在web開發中，用redirect與forward做跳轉有什么區別？web應用服務器對用戶請求通常返回一些狀態碼，請描述下分別以4和5開頭的狀態碼
100-199:表示成功接收請求，要求客戶端繼續提交下一次請求才能完成整個處理過程。
200-299：表示成功接收請求並已完成整個處理過程，常用200.
300-399：為完成請求，客戶需進一步細化請求。例如，請求的資源已經移動一個新地址，常用302、307和304
400-499：客戶端的請求有錯誤，常用404.
500-599：服務器出現錯誤，常用500。

四：spring，ibatis，hibernate相關
？1、Hibernate/Ibatis兩者的區別
？2、OR Mapping的概念
%3、hibernate一級和二級緩存是否知道
？4、使用hibernate實現集群部署，需要注意些什么
！5、Spring如何實現AOP和IOC的？
！6、Spring的核心理念是什么？是否了解IOC和AOP
！7、Spring的事務管理 ，Spring bean注入的幾種方式
！8、Spring AOP解決了什么問題

五：jboss，tomcat等容器相關
？1、Tomcat和weblogic的最根本的區別
？2、Jboss端口在哪個配置文件中修改

六：web安全，SQL注入，XSS, CSRF等
%1、SQL注入 SQL安全

七：AJAX相關
？1、AJAX感受，有什么缺點？
%2、你使用的是Ajax的那種框架？
？3、Ajax如何解決跨域問題

八：Web Service
？1、簡述WebService是怎么實現的

九：JMS
？1、JMS的模式兩種模式
隊列模式: 一對一
主題(訂閱)模式: 一對多

十：其他
？1、Js:confirm()方法
？2、Iframe的優缺點
%3、我們在web應用開發過程中經常遇到輸出某種編碼的字符，如iso8859-1等，如何輸出一個某種編碼的字符串?（主要是考量有沒有碰到過編碼問題，問題是如何解決的）
？4、怎么獲取到客戶端的真實IP?
？5、名詞解釋：jndi，rmi，jms，事務，如果有了解的話可以深入
？6、WEB層如何實現Cluster

 

第四部分: 數據庫相關

一：關系模型理論：
！1、范式
？2、rownum和rowid的區別與使用

二：事務相關
%1、Transaction有哪幾種隔離級別？（Isolation Level）
？2、Global transaction的原理是什么?
！3、事務是什么？

三：並發控制
%1、樂觀鎖，悲觀鎖

四：ORACLE或MYSQL題目
！1、分頁如何實現（Oracle，MySql）
！2、Mysql引擎

五：其他
%1、數據庫操作的性能瓶頸通常在哪里, 1000萬級別訪問，在數據庫和java程序上考慮哪些來進行性能優化
%2、性能方面。多數結合多線程、同步來問，以提取一張大表數據來作為例子 解決性能的方法
！3、表關聯時，內連接，左連接，右連接怎么理解？
！4、Statement和PreparedStatement之間的區別
！5、用JDBC怎樣從數據庫中查詢一條記錄
%6、索引以及索引的實現(B+樹介紹、和B樹、R樹區別

 

第五部分: 設計模式

一：高內聚，低耦合方面的理解
？1、在項目中是否采用分層的結構，是怎樣划分的，各層之間采用了哪些相關技術？ 對哪些設計模式比較熟悉？
%2、什么是低耦合和高聚合？封裝原則又是什么意思？
%3、類A依賴類B，會產生什么問題？怎樣解除這種耦合？

二：設計模式方面
%1、談一下自己了解或者熟悉的設計模式
！2、Singleton的幾種實現方式
？3、工廠模式和抽象工廠模式之間的區別
！4、簡述M-V-C模式解決了什么問題？

三：其他
%1、說說你所知道的UML圖，在項目中是如何運用

 

 

第六部分: 其他清單 只有題目

J2SE基礎
1. 九種基本數據類型的大小，以及他們的封裝類。
（2）byte——1 byte——Byte
（3）short——2 bytes——Short
（4）int——4 bytes——Integer
（5）long——8 bytes——Long
（6）float——4 bytes——Float
（7）double——8 bytes——Double
（8）char——2 bytes——Character
static Integer valueOf(int i) : 切記-127--+127范圍， 使用cache


2. Switch能否用string做參數？
可以。在 Java 7之前，switch 只能支持 byte、short、char、int或者其對應的封裝類以及 Enum 類型。
在 Java 7中，String支持被加上了。

3. equals與==的區別。
在java中的數據類型可以分為兩類。
1，基本數據類型，他們之間的比較用==表示比較它們的值。
2，引用數據類型，當使用==進行比較時，比較的是它們內存中的存放地址是否相同。而equals內部也是直接引用的==。
但是equals是Object中的方法， 我們可以通過復寫來改變equals的用法， 比如String中的equals只是比較兩個變量的值是否相等：
public boolean equals(Object anObject) {
    if (this == anObject) {
        return true;
    }
    if (anObject instanceof String) {
        String anotherString = (String)anObject;
        int n = count;
        if (n == anotherString.count) {
            char v1[] = value;
            char v2[] = anotherString.value;
            int i = offset;
            int j = anotherString.offset;
            while (n-- != 0) {
                if (v1[i++] != v2[j++])
                    return false;
            }
            return true;
        }
    }
    return false;
}


4. Object有哪些公用方法？
equals(), toString(), hashCode(), getClass(), notify(), notifyAll(), wait(), finalize(), clone()

5. Java的四種引用，強弱軟虛，用到的場景。


6. Hashcode的作用。(這里來說明equals和hashCode的關聯)
如果兩個對象相等，那么他們一定有相同的哈希值（hash code）。
如果兩個對象的哈希值相等，那么這兩個對象有可能相等也有可能不相等。（需要再通過equals來判斷）
1、equals方法用於比較對象的內容是否相等（覆蓋以后）
2、hashcode方法只有在集合中用到
3、當覆蓋了equals方法時，比較對象是否相等將通過覆蓋后的equals方法進行比較（判斷對象的內容是否相等）。
4、將對象放入到集合中時，首先判斷要放入對象的hashcode值與集合中的任意一個元素的hashcode值是否相等，
   如果不相等直接將該對象放入集合中。如果hashcode值相等，然后再通過equals方法判斷要放入對象與集合中的任意一個對象是否相等，
   如果equals判斷不相等，直接將該元素放入到集合中，否則不放入。

7. ArrayList、LinkedList、Vector的區別。
ArrayList: 內部采用數組存儲元素，支持高效隨機訪問，支持動態調整大小
    增刪慢，查詢快。
LinkedList: 內部采用鏈表來存儲元素，支持快速插入/刪除元素，但不支持高效地隨機訪問.
    增刪快，查詢慢。
Vector: 可以看作線程安全版的ArrayList

8. String、StringBuffer與StringBuilder的區別。
這里插入知識點：String的intern
直接使用雙引號聲明出來的String對象會直接存儲在常量池中。
如果不是用雙引號聲明的String對象，可以使用String提供的intern方法。intern 方法會從字符串常量池中查詢當前字符串是否存在，若不存在就會將當前字符串放入常量池中
1. String類型是Java內的對象，是個不可變的對象，當每次對String進行改變時都需要生成一個新的String對象，然后將指針指向一個新的對象，如果在一個循環里面，不斷的改變一個對象，就要不斷的生成新的對象，而且對象多了，Java的垃圾自動回收機制會開始工作，所以效率很低，建議在不斷更改String對象的地方不要使用String類型
2. StringBuffer 是個可變的對象，就是每次操作都是對對象本身進行操作，而不用生成新的對象，這樣效率肯定就會有有很大的提高，在大部分情況下StringBuffer的效率要比String類型要高
3. StringBuilder 與StringBuffer一樣是個可變的字符序列，提供與StringBuffer兼容的API，但是不能保證同步，用在字符串緩沖區被當個線程使用的情況，在單機非多線程的情況下使用StringBuilder會有比較好的效率，因為StringBuilder沒有處理同步(Synchronized)問題。StringBuffer則會處理同步問題，如果StringBuilder會在多線程下被操作，則要改用StringBuffer，讓對象自行管理同步問題。

9. Map、Set、List、Queue、Stack的特點與用法。
10. HashMap和HashTable的區別。
11. HashMap和ConcurrentHashMap的區別，HashMap的底層源碼。
12. TreeMap、HashMap、LindedHashMap的區別。
13. Collection包結構，與Collections的區別。
14. try catch finally，try里有return，finally還執行么？
15. Excption與Error包結構。OOM你遇到過哪些情況，SOF你遇到過哪些情況。
16. Java面向對象的三個特征與含義。
17. Override和Overload的含義去區別。
18. Interface與abstract類的區別。
19. Static class 與non static class的區別。
20. java多態的實現原理。
21. 實現多線程的兩種方法：Thread與Runable。
22. 線程同步的方法：sychronized、lock、reentrantLock等。
23. 鎖的等級：方法鎖、對象鎖、類鎖。
24. 寫出生產者消費者模式。
25. ThreadLocal的設計理念與作用。
26. ThreadPool用法與優勢。
27. Concurrent包里的其他東西：ArrayBlockingQueue、CountDownLatch等等。
28. wait()和sleep()的區別。
29. foreach與正常for循環效率對比。
30. Java IO與NIO。
31. 反射的作用於原理。
32. 泛型常用特點，List<String>能否轉為List<Object>。
33. 解析XML的幾種方式的原理與特點：DOM、SAX、PULL。
34. Java與C++對比。
35. Java1.7與1.8新特性。
36. 設計模式：單例、工廠、適配器、責任鏈、觀察者等等。
37. JNI的使用。

JVM
1. 內存模型以及分區，需要詳細到每個區放什么。
2. 堆里面的分區：Eden，survival from to，老年代，各自的特點。
3. 對象創建方法，對象的內存分配，對象的訪問定位。
4. GC的兩種判定方法：引用計數與引用鏈。
5. GC的三種收集方法：標記清除、標記整理、復制算法的原理與特點，分別用在什么地方，如果讓你優化收集方法，有什么思路？
6. GC收集器有哪些？CMS收集器與G1收集器的特點。
7. Minor GC與Full GC分別在什么時候發生？
8. 幾種常用的內存調試工具：jmap、jstack、jconsole。
9. 類加載的五個過程：加載、驗證、准備、解析、初始化。
10. 雙親委派模型：Bootstrap ClassLoader、Extension ClassLoader、ApplicationClassLoader。
11. 分派：靜態分派與動態分派。

操作系統
1. 進程和線程的區別。
2. 死鎖的必要條件，怎么處理死鎖。
3. Window內存管理方式：段存儲，頁存儲，段頁存儲。
4. 進程的幾種狀態。
5. IPC幾種通信方式。
6. 什么是虛擬內存。
7. 虛擬地址、邏輯地址、線性地址、物理地址的區別

TCP/IP
1. OSI與TCP/IP各層的結構與功能，都有哪些協議。
2. TCP與UDP的區別。
3. TCP報文結構。
4. TCP的三次握手與四次揮手過程，各個狀態名稱與含義，TIMEWAIT的作用。
5. TCP擁塞控制。
6. TCP滑動窗口與回退N針協議。
7. Http的報文結構。
8. Http的狀態碼含義。
9. Http request的幾種類型。
10. Http1.1和Http1.0的區別
11. Http怎么處理長連接。
12. Cookie與Session的作用於原理。
13. 電腦上訪問一個網頁，整個過程是怎么樣的：DNS、HTTP、TCP、OSPF、IP、ARP。
14. Ping的整個過程。ICMP報文是什么。
15. C/S模式下使用socket通信，幾個關鍵函數。
16. IP地址分類。
17. 路由器與交換機區別。

數據結構與算法
1. 鏈表與數組。
2. 隊列和棧，出棧與入棧。
3. 鏈表的刪除、插入、反向。
4. 字符串操作。
5. Hash表的hash函數，沖突解決方法有哪些。
6. 各種排序：冒泡、選擇、插入、希爾、歸並、快排、堆排、桶排、基數的原理、平均時間復雜度、最壞時間復雜度、空間復雜度、是否穩定。
7. 快排的partition函數與歸並的Merge函數。
8. 對冒泡與快排的改進。
9. 二分查找，與變種二分查找。
10. 二叉樹、B+樹、AVL樹、紅黑樹、哈夫曼樹。
11. 二叉樹的前中后續遍歷：遞歸與非遞歸寫法，層序遍歷算法。
12. 圖的BFS與DFS算法，最小生成樹prim算法與最短路徑Dijkstra算法。
13. KMP算法。
14. 排列組合問題。
15. 動態規划、貪心算法、分治算法。（一般不會問到）
16. 大數據處理：類似10億條數據找出最大的1000個數.........等等

 

基礎篇

JAVA基礎

1、  JAVA基礎

1)      抽象類和接口的區別？

補充問題：JAVA8中為什么要加入默認方法？

2)      靜態內部類(static class)的作用？

3)      序列化和反序列化

4)      動態代理和靜態代理的區別？

贈送問題：代理模式，什么是代理模式？如何實現？代理模式結構圖是怎樣的？代理模式應用在什么場景？

5)      nio熟悉嗎，nio和io的區別？

6)      java8有哪些新特性？

2、  JAVA API

1)      transient關鍵字的作用？

2)      volatile關鍵字的作用？

3)      abstract和final是否可同時使用？

4)      ArrayList、LinkedList、vector的區別？

5)      HashMap、LinkedHashMap，concurrentHashMap的區別，concurrentHashMap為什么特別好用，你看過源碼嗎？

6)      collection的繼承結構，你是否看過源碼？

3、  JVM調優(性能)

1)      有哪些調優工具

2)      如何快速定位有問題代碼

3)      內存溢出如何處理，如何調優

4)      垃圾回收機制，有哪些垃圾回收算法，如何配置垃圾回收策略

5)      新生代和老年代

4、  Tomcat

tomcat可以穩定支持的最大並發用戶數

Tomcat集群如何架設：Tomcat+Apache

集群時特別關注兩個問題：

 1：如何實現多應用服務器間的session共享：（一台服務器崩潰，另外一台服務器可以繼續支持）

 2：如何分發請求到各個應用服務器實現壓力分解：（這里的解決方案是用apache做 web服務器）

 

算法問題

1、  生產者和消費者問題？

2、  查找算法有幾種，寫出實現代碼？

3、  排序算法有幾種，寫出實現代碼？

4、  遍歷二叉樹，分別按照前序、中序、后續？

5、  紅黑樹

程序題

1、  寫出一個字符串，打印出字符串中字符的所有排序

2、  無序的有重復數據的list變成有序的無重復數據的list

 

框架篇

1、  Spring核心：

 分別說說aop和IOC

事務配置的幾種方式？

spring有幾種注入方式？

spring依賴注入的四種裝配方式？

spring的幾個重要注解@Component（不推薦使用）、@Repository、@Service、@Controller

2、  SpringMVC和Struts2：兩者的區別

3、  Mybatis和Hibernate：兩者的區別

           mybatis如何實現多表關聯查詢

           mybatis的resultMap

           mybatis的#和$

4、  是否可以用maven搭建項目，maven如何構建web項目？

5、  git的使用

6、  當日志非常大時，如何查找需要的日志？

7、  SSH的局限有哪些

 數據庫篇

數據庫基礎

1、  MySQL和oracle的區別

2、  Oracle移植到mysql需要處理哪些

3、  存儲過程

4、  mysql存儲引擎innodb和myisam的區別

 

數據庫優化

1、  sql優化

2、  索引

關於索引：聯合索引A和B，當按照A、A和B、B查詢時索引使用情況？

3、  數據庫優化，使用過哪些優化工具：常用的SQLYOG、基准測試，expain、status等

具體問題：

           如何找到並定位慢SQL？

           如何確定表和查詢是否是最優的？

           枚舉類型如何使用，枚舉類型的誤用帶來的損失？

有沒有什么工具可以監控數據庫，快速查看有問題的sql?如果存在大批量有問題的sql，如何排查？

如何診斷響應差的(太多線程)，僵屍進程(無響應或長時間運行)，或者診斷連接問題？

如果在某段時間內用戶反映服務器變慢，如何知道服務器性能差？

           假設已經檢查了所有常規信息——內存、磁盤等，而所有這些信息都在正常范圍內，沒有出現錯誤和異常，這時，你怎么知道系統是否運行變慢？

 

數據庫進階

1、  當數據庫存儲數據出現瓶頸，如何處理？——數據庫水平拆分、垂直拆分

2、  說說水平拆分和垂直拆分，什么時候水平拆分，什么時候垂直拆分，分別解決了哪些問題，分別存在哪些不能解決的問題，如何結合使用？

3、  當水平拆分時，到不同的表和庫中或不同的分布式服務器上時：不同的表可以聯合查詢(union)、不同的庫可以加上庫名進行聯合查詢；如果需要查詢的數據分布在不同的服務器之間，如何查詢？如何在存儲數據時就將需要同時查詢的數據放在同一服務器上(存儲時取模或者按照時間分布數據，查詢的時候取模或者按照時間查詢)

4、  mysql讀寫分離

5、  數據庫集群

 

升級篇

分布式

1、  有哪些分布式框架，對比其性能優劣？

同步調用：RSET(JAX-RS、Spring Boot)、RPC(Thrift、Dubbo、HSF)

異步調用：Kafka、Notify、MetaQ

同步和異步的區別，分別用於什么場景？

2、  dubbo + zookeeper

3、  nosql(redis、memcache、mongodb)

 

大並發的處理

1、  負載均衡

2、  分布式

3、  緩存

4、  數據庫分庫分表

5、  數據庫集群

6、  圖片服務器分離

7、  首頁靜態化

 

大數據問題：

假如每天產生5億行日志文件，如何搜索到指定內容？

有一個100T大小的文件存放在磁盤中，不借助任何外部存儲設備，如何統計指定字符串的個數？

同上，有一個文件，存放每天訪問的URL，每天有100萬條，如何統計URL的個數？

測試1000萬條數據的查詢

 

多線程

1、  有哪些多線程的應用場景

2、  你自己有寫過多線程嗎，在哪些場景

3、  線程池,java提供的線程池有哪幾種？

4、  隊列

5、  servlet是線程安全的嗎，如何改進？

6、  實現同步的幾種方式?

 

安全

關於安全方面做了哪些工作？

手機、支付如何保證信息安全？

sql注入問題

如何保證訪問URL安全：如何不暴露真實的URL地址；如何防止篡改URL地址；如何防止在URL中SQL注入？

 

設計模式

1、  你熟悉哪些設計模式

2、  框架中用到哪些設計模式

           JAVA IO：裝飾器模式(Decorator)、適配器模式(Adapt)

           Spring ：訪問者模式(Visitor)、代理模式(Proxy)、策略模式(Strategy)

           SpringMVC：模版模式(TempleteMethod)

           Mybatis： 簡單工廠模式、工廠方法模式(FactoryMethod)、抽象工廠模式(Abstract Factory)

           Tomcat：門面模式、觀察者模式(Observer)、命令模式(Command)、責任鏈模式(chainof responsible)

           Velocity ：合成模式
3、  裝飾模式和適配器模式的區別
4、  寫一個單例模式
 

linux
1、會使用哪些命令
查看端口是否被占用
如何查看指定的日志


網絡
1、  通信協議是否有了解，TCP/UDP等、HTTP
2、  http反向代理


業務篇
1、  訂單：大並發問題

2、  訂單或產品數據量變大之后如何優化

3、  交易付款如何操作

4、  與物流接口

5、  畫出你負責的項目的架構圖

大概總結就這么多了, 文章內容有點多, 大家可以慢慢去看, 很多答案的話需要自己百度了, 學習是一個積累的過程, 這些東西只是一些濃縮的映射, 如果哪里有不太清楚就說明你還沒有掌握透徹了.
希望對真正找工作的朋友有些幫助, 加油吧.