JAVA常見面試題及解答

 

JAVA相關基礎知識
一、面向對象的特徵有哪些方面 
1.抽象:
抽象就是忽略一個主題中與當前目標無關的那些方面,以便更充分地注意與當前目標有關的方面。抽象並不打算了解所有問題,而只是選擇其中的一部分,暫時不用部分細節。抽象包括兩個方面,一是過程抽象,二是數據抽象。
2.繼承:
繼承是一種聯結類的層次模型,而且容許和鼓勵類的重用,它提供了一種明確表述共性的方法。對象的一個新類能夠從現有的類中派生,這個過程稱爲類繼承。新類繼承了原始類的特性,新類稱爲原始類的派生類(子類),而原始類稱爲新類的基類(父類)。派生類能夠從它的基類那裏繼承方法和實例變量,而且類能夠修改或增長新的方法使之更適合特殊的須要。
3.封裝:
封裝是把過程和數據包圍起來,對數據的訪問只能經過已定義的界面。面向對象計算始於這個基本概念,即現實世界能夠被描繪成一系列徹底自治、封裝的對象,這些對象經過一個受保護的接口訪問其餘對象。
4. 多態性:
多態性是指容許不一樣類的對象對同一消息做出響應。多態性包括參數化多態性和包含多態性。多態性語言具備靈活、抽象、行爲共享、代碼共享的優點,很好的解決了應用程序函數同名問題。
二、String是最基本的數據類型嗎?
基本數據類型包括byte、int、char、long、float、double、boolean和short。
java.lang.String類是final類型的,所以不能夠繼承這個類、不能修改這個類。爲了提升效率節省空間,咱們應該用StringBuffer類
三、int 和 Integer 有什麼區別
Java 提供兩種不一樣的類型:引用類型和原始類型(或內置類型)。Int是java的原始數據類型,Integer是java爲int提供的封裝類。Java爲每一個原始類型提供了封裝類。
原始類型封裝類
booleanBoolean
charCharacter
byteByte
shortShort
intInteger
longLong
floatFloat
doubleDouble
引用類型和原始類型的行爲徹底不一樣,而且它們具備不一樣的語義。引用類型和原始類型具備不一樣的特徵和用法,它們包括:大小和速度問題,這種類型以哪一種類型的數據結構存儲,當引用類型和原始類型用做某個類的實例數據時所指定的缺省值。對象引用實例變量的缺省值爲 null,而原始類型實例變量的缺省值與它們的類型有關。
四、String 和StringBuffer的區別
JAVA平臺提供了兩個類:String和StringBuffer,它們能夠儲存和操做字符串,即包含多個字符的字符數據。這個String類提供了數值不可改變的字符串。而這個StringBuffer類提供的字符串進行修改。當你知道字符數據要改變的時候你就能夠使用StringBuffer。典型地,你能夠使用StringBuffers來動態構造字符數據。
五、運行時異常與通常異常有何異同?
異常表示程序運行過程當中可能出現的非正常狀態,運行時異常表示虛擬機的一般操做中可能遇到的異常,是一種常見運行錯誤。java編譯器要求方法必須聲明拋出可能發生的非運行時異常,可是並不要求必須聲明拋出未被捕獲的運行時異常。
六、說出Servlet的生命週期,並說出Servlet和CGI的區別。
Servlet被服務器實例化後,容器運行其init方法,請求到達時運行其service方法,service方法自動派遣運行與請求對應的doXXX方法(doGet,doPost)等,當服務器決定將實例銷燬的時候調用其destroy方法。
與cgi的區別在於servlet處於服務器進程中,它經過多線程方式運行其service方法,一個實例能夠服務於多個請求,而且其實例通常不會銷燬,而CGI對每一個請求都產生新的進程,服務完成後就銷燬,因此效率上低於servlet。
七、說出ArrayList,Vector, LinkedList的存儲性能和特性
ArrayList和Vector都是使用數組方式存儲數據,此數組元素數大於實際存儲的數據以便增長和插入元素,它們都容許直接按序號索引元素,可是插入元素要涉及數組元素移動等內存操做,因此索引數據快而插入數據慢,Vector因爲使用了synchronized方法(線程安全),一般性能上較ArrayList差,而LinkedList使用雙向鏈表實現存儲,按序號索引數據須要進行前向或後向遍歷,可是插入數據時只須要記錄本項的先後項便可,因此插入速度較快。
八、EJB是基於哪些技術實現的?並說出SessionBean和EntityBean的區別,StatefulBean和StatelessBean的區別。
EJB包括Session Bean、Entity Bean、Message Driven Bean,基於JNDI、RMI、JAT等技術實現。
SessionBean在J2EE應用程序中被用來完成一些服務器端的業務操做,例如訪問數據庫、調用其餘EJB組件。EntityBean被用來表明應用系統中用到的數據。
對於客戶機,SessionBean是一種非持久性對象,它實現某些在服務器上運行的業務邏輯。
對於客戶機,EntityBean是一種持久性對象,它表明一個存儲在持久性存儲器中的實體的對象視圖,或是一個由現有企業應用程序實現的實體。
Session Bean 還能夠再細分爲 Stateful Session Bean 與 Stateless Session Bean ,這兩種的 Session Bean均可以將系統邏輯放在 method之中執行,不一樣的是 Stateful Session Bean 能夠記錄呼叫者的狀態,所以一般來講,一個使用者會有一個相對應的 Stateful Session Bean 的實體。Stateless Session Bean 雖然也是邏輯組件,可是他卻不負責記錄使用者狀態,也就是說當使用者呼叫 Stateless Session Bean 的時候,EJB Container 並不會找尋特定的 Stateless Session Bean 的實體來執行這個 method。換言之,極可能數個使用者在執行某個 Stateless Session Bean 的 methods 時,會是同一個 Bean 的 Instance 在執行。從內存方面來看, Stateful Session Bean 與 Stateless Session Bean 比較, Stateful Session Bean 會消耗 J2EE Server 較多的內存,然而 Stateful Session Bean 的優點卻在於他能夠維持使用者的狀態。
九、Collection 和 Collections的區別。 
  Collection是集合類的上級接口,繼承與他的接口主要有Set 和List.
Collections是針對集合類的一個幫助類,他提供一系列靜態方法實現對各類集合的搜索、排序、線程安全化等操做。
十、&和&&的區別。 
&是位運算符,表示按位與運算,&&是邏輯運算符,表示邏輯與(and)。
十一、HashMap和Hashtable的區別。 
HashMap是Hashtable的輕量級實現(非線程安全的實現),他們都完成了Map接口,主要區別在於HashMap容許空(null)鍵值(key),因爲非線程安全,效率上可能高於Hashtable。
HashMap容許將null做爲一個entry的key或者value,而Hashtable不容許。
HashMap把Hashtable的contains方法去掉了,改爲containsvalue和containsKey。由於contains方法容易讓人引發誤解。 
Hashtable繼承自Dictionary類,而HashMap是Java1.2引進的Map interface的一個實現。
最大的不一樣是,Hashtable的方法是Synchronize的,而HashMap不是,在多個線程訪問Hashtable時,不須要本身爲它的方法實現同步,而HashMap 就必須爲之提供外同步(若是是ArrayList:List lst = Collections.synchronizedList(new ArrayList());若是是HashMap:Map map = Collections.synchronizedMap(new HashMap());)。
Hashtable和HashMap採用的hash/rehash算法都大概同樣,因此性能不會有很大的差別。
十二、final, finally, finalize的區別。 
  final 用於聲明屬性,方法和類,分別表示屬性不可變,方法不可覆蓋,類不可繼承。
finally是異常處理語句結構的一部分,表示老是執行。
finalize是Object類的一個方法,在垃圾收集器執行的時候會調用被回收對象的此方法,能夠覆蓋此方法提供垃圾收集時的其餘資源回收,例如關閉文件等。
1三、sleep() 和 wait() 有什麼區別? 
sleep是線程類(Thread)的方法,致使此線程暫停執行指定時間,給執行機會給其餘線程,可是監控狀態依然保持,到時後會自動恢復。調用sleep不會釋放對象鎖。
wait是Object類的方法,對此對象調用wait方法致使本線程放棄對象鎖,進入等待此對象的等待鎖定池,只有針對此對象發出notify方法(或notifyAll)後本線程才進入對象鎖定池準備得到對象鎖進入運行狀態。
1四、Overload和Override的區別。Overloaded的方法是否能夠改變返回值的類型?
方法的重寫Overriding和重載Overloading是Java多態性的不一樣表現。重寫Overriding是父類與子類之間多態性的一種表現,重載Overloading是一個類中多態性的一種表現。若是在子類中定義某方法與其父類有相同的名稱和參數,咱們說該方法被重寫 (Overriding)。子類的對象使用這個方法時,將調用子類中的定義,對它而言,父類中的定義如同被「屏蔽」了。若是在一個類中定義了多個同名的方法,它們或有不一樣的參數個數或有不一樣的參數類型,則稱爲方法的重載(Overloading)。Overloaded的方法是能夠改變返回值的類型。
1五、error和exception有什麼區別?
error 表示恢復不是不可能但很困難的狀況下的一種嚴重問題。好比說內存溢出。不可能期望程序能處理這樣的狀況。
exception 表示一種設計或實現問題。也就是說,它表示若是程序運行正常,從不會發生的狀況。javascript

 

 

 

1六、同步和異步有何異同,在什麼狀況下分別使用他們?舉例說明。
若是數據將在線程間共享。例如正在寫的數據之後可能被另外一個線程讀到,或者正在讀的數據可能已經被另外一個線程寫過了,那麼這些數據就是共享數據,必須進行同步存取。
當應用程序在對象上調用了一個須要花費很長時間來執行的方法,而且不但願讓程序等待方法的返回時,就應該使用異步編程,在不少狀況下采用異步途徑每每更有效率。
1七、abstract class和interface有什麼區別?
聲明方法的存在而不去實現它的類被叫作抽象類(abstract class),它用於要建立一個體現某些基本行爲的類,併爲該類聲明方法,但不能在該類中實現該類的狀況。不能建立abstract 類的實例。然而能夠建立一個變量,其類型是一個抽象類,並讓它指向具體子類的一個實例。不能有抽象構造函數或抽象靜態方法。Abstract 類的子類爲它們父類中的全部抽象方法提供實現,不然它們也是抽象類爲。取而代之,在子類中實現該方法。知道其行爲的其它類能夠在類中實現這些方法。
接口(interface)是抽象類的變體。在接口中,全部方法都是抽象的。多繼承性可經過實現這樣的接口而得到。接口中的全部方法都是抽象的,沒有一個有程序體。接口只能夠定義static final成員變量。接口的實現與子類類似,除了該實現類不能從接口定義中繼承行爲。當類實現特殊接口時,它定義(即將程序體給予)全部這種接口的方法。而後,它能夠在實現了該接口的類的任何對象上調用接口的方法。因爲有抽象類,它容許使用接口名做爲引用變量的類型。一般的動態聯編將生效。引用能夠轉換到接口類型或從接口類型轉換,instanceof 運算符能夠用來決定某對象的類是否實現了接口。
1八、heap和stack有什麼區別。
棧是一種線形集合,其添加和刪除元素的操做應在同一段完成。棧按照後進先出的方式進行處理。
堆是棧的一個組成元素
1九、forward 和redirect的區別
forward是服務器請求資源,服務器直接訪問目標地址的URL,把那個URL的響應內容讀取過來,而後把這些內容再發給瀏覽器,瀏覽器根本不知道服務器發送的內容是從哪兒來的,因此它的地址欄中仍是原來的地址。
redirect就是服務端根據邏輯,發送一個狀態碼,告訴瀏覽器從新去請求那個地址,通常來講瀏覽器會用剛纔請求的全部參數從新請求,因此session,request參數均可以獲取。
20、EJB與JAVA BEAN的區別?
Java Bean 是可複用的組件,對Java Bean並無嚴格的規範,理論上講,任何一個Java類均可以是一個Bean。但一般狀況下,因爲Java Bean是被容器所建立(如Tomcat)的,因此Java Bean應具備一個無參的構造器,另外,一般Java Bean還要實現Serializable接口用於實現Bean的持久性。Java Bean實際上至關於微軟COM模型中的本地進程內COM組件,它是不能被跨進程訪問的。Enterprise Java Bean 至關於DCOM,即分佈式組件。它是基於Java的遠程方法調用(RMI)技術的,因此EJB能夠被遠程訪問(跨進程、跨計算機)。但EJB必須被佈署在諸如Webspere、WebLogic這樣的容器中,EJB客戶從不直接訪問真正的EJB組件,而是經過其容器訪問。EJB容器是EJB組件的代理,EJB組件由容器所建立和管理。客戶經過容器來訪問真正的EJB組件。
2一、Static Nested Class 和 Inner Class的不一樣。 
Static Nested Class是被聲明爲靜態(static)的內部類,它能夠不依賴於外部類實例被實例化。而一般的內部類須要在外部類實例化後才能實例化。
2二、JSP中動態INCLUDE與靜態INCLUDE的區別?
動態INCLUDE用jsp:include動做實現 <jsp:include page="included.jsp" flush="true" />它老是會檢查所含文件中的變化,適合用於包含動態頁面,而且能夠帶參數。
靜態INCLUDE用include僞碼實現,定不會檢查所含文件的變化,適用於包含靜態頁面<%@ include file="included.htm" %> 
2三、何時用assert。 
assertion(斷言)在軟件開發中是一種經常使用的調試方式,不少開發語言中都支持這種機制。在實現中,assertion就是在程序中的一條語句,它對一個boolean表達式進行檢查,一個正確程序必須保證這個boolean表達式的值爲true;若是該值爲false,說明程序已經處於不正確的狀態下,系統將給出警告或退出。通常來講,assertion用於保證程序最基本、關鍵的正確性。assertion檢查一般在開發和測試時開啓。爲了提升性能,在軟件發佈後,assertion檢查一般是關閉的。
2四、GC是什麼? 爲何要有GC? 
  GC是垃圾收集的意思(Gabage Collection),內存處理是編程人員容易出現問題的地方,忘記或者錯誤的內存回收會致使程序或系統的不穩定甚至崩潰,Java提供的GC功能能夠自動監測對象是否超過做用域從而達到自動回收內存的目的,Java語言沒有提供釋放已分配內存的顯示操做方法。 
2五、short s1 = 1; s1 = s1 + 1;有什麼錯? short s1 = 1; s1 += 1;有什麼錯? 
short s1 = 1; s1 = s1 + 1; (s1+1運算結果是int型,須要強制轉換類型)
short s1 = 1; s1 += 1;(能夠正確編譯)
2六、Math.round(11.5)等於多少? Math.round(-11.5)等於多少? 
Math.round(11.5)==12
Math.round(-11.5)==-11
round方法返回與參數最接近的長整數,參數加1/2後求其floor.
2七、String s = new String("xyz");建立了幾個String Object? 
兩個
2八、設計4個線程,其中兩個線程每次對j增長1,另外兩個線程對j每次減小1。寫出程序。
如下程序使用內部類實現線程,對j增減的時候沒有考慮順序問題。
public class ThreadTest1{
private int j;
public static void main(String args[]){
ThreadTest1 tt=new ThreadTest1();
Inc inc=tt.new Inc();
Dec dec=tt.new Dec();
for(int i=0;i<2;i++){
Thread t=new Thread(inc);
t.start();
t=new Thread(dec);
t.start();
}
}
private synchronized void inc(){
j++;
System.out.println(Thread.currentThread().getName()+"-inc:"+j);
}
private synchronized void dec(){
j--;
System.out.println(Thread.currentThread().getName()+"-dec:"+j);
}
class Inc implements Runnable{
public void run(){
for(int i=0;i<100;i++){
inc();
}
}
}
class Dec implements Runnable{
public void run(){
for(int i=0;i<100;i++){
dec();
}
}
}
}
2九、Java有沒有goto?
java中的保留字,如今沒有在java中使用。
30、啓動一個線程是用run()仍是start()?
啓動一個線程是調用start()方法,使線程所表明的虛擬處理機處於可運行狀態,這意味着它能夠由JVM調度並執行。這並不意味着線程就會當即運行。run()方法能夠產生必須退出的標誌來中止一個線程。php

 

3一、EJB包括(SessionBean,EntityBean)說出他們的生命週期,及如何管理事務的?
SessionBean:Stateless Session Bean 的生命週期是由容器決定的,當客戶機發出請求要創建一個Bean的實例時,EJB容器不必定要建立一個新的Bean的實例供客戶機調用,而是隨便找一個現有的實例提供給客戶機。當客戶機第一次調用一個Stateful Session Bean 時,容器必須當即在服務器中建立一個新的Bean實例,並關聯到客戶機上,之後此客戶機調用Stateful Session Bean 的方法時容器會把調用分派到與此客戶機相關聯的Bean實例。
EntityBean:Entity Beans能存活相對較長的時間,而且狀態是持續的。只要數據庫中的數據存在,Entity beans就一直存活。而不是按照應用程序或者服務進程來講的。即便EJB容器崩潰了,Entity beans也是存活的。Entity Beans生命週期可以被容器或者 Beans本身管理。
EJB經過如下技術管理實務:對象管理組織(OMG)的對象實務服務(OTS),Sun Microsystems的Transaction Service(JTS)、Java Transaction API(JTA),開發組(X/Open)的XA接口。
3二、應用服務器有那些?
BEA WebLogic Server,IBM WebSphere Application Server,Oracle9i Application Server,jBoss,Tomcat
3三、給我一個你最多見到的runtime exception。
ArithmeticException, ArrayStoreException, BufferOverflowException, BufferUnderflowException, CannotRedoException, CannotUndoException, ClassCastException, CMMException, ConcurrentModificationException, DOMException, EmptyStackException, IllegalArgumentException, IllegalMonitorStateException, IllegalPathStateException, IllegalStateException, ImagingOpException, IndexOutOfBoundsException, MissingResourceException, NegativeArraySizeException, NoSuchElementException, NullPointerException, ProfileDataException, ProviderException, RasterFormatException, SecurityException, SystemException, UndeclaredThrowableException, UnmodifiableSetException, UnsupportedOperationException
3四、接口是否可繼承接口? 抽象類是否可實現(implements)接口? 抽象類是否可繼承實體類(concrete class)?
接口能夠繼承接口。抽象類能夠實現(implements)接口,抽象類是否可繼承實體類,但前提是實體類必須有明確的構造函數。
3五、List, Set, Map是否繼承自Collection接口?
List,Set是,Map不是
3六、說出數據鏈接池的工做機制是什麼?
J2EE服務器啓動時會創建必定數量的池鏈接,並一直維持很多於此數目的池鏈接。客戶端程序須要鏈接時,池驅動程序會返回一個未使用的池鏈接並將其表記爲忙。若是當前沒有空閒鏈接,池驅動程序就新建必定數量的鏈接,新建鏈接的數量有配置參數決定。當使用的池鏈接調用完成後,池驅動程序將此鏈接表記爲空閒,其餘調用就能夠使用這個鏈接。
3七、abstract的method是否可同時是static,是否可同時是native,是否可同時是synchronized?
都不能
3八、數組有沒有length()這個方法? String有沒有length()這個方法?
數組沒有length()這個方法,有length的屬性。String有有length()這個方法。
3九、Set裏的元素是不能重複的,那麼用什麼方法來區分重複與否呢? 是用==仍是equals()? 它們有何區別?
Set裏的元素是不能重複的,那麼用iterator()方法來區分重複與否。equals()是判讀兩個Set是否相等。
equals()和==方法決定引用值是否指向同一對象equals()在類中被覆蓋,爲的是當兩個分離的對象的內容和類型相配的話,返回真值。
40、構造器Constructor是否可被override?
構造器Constructor不能被繼承,所以不能重寫Overriding,但能夠被重載Overloading。
4一、是否能夠繼承String類?
String類是final類故不能夠繼承。
4二、swtich是否能做用在byte上,是否能做用在long上,是否能做用在String上?
switch(expr1)中,expr1是一個整數表達式。所以傳遞給 switch 和 case 語句的參數應該是 int、 short、 char 或者 byte。long,string 都不能做用於swtich。
4三、try {}裏有一個return語句,那麼緊跟在這個try後的finally {}裏的code會不會被執行,何時被執行,在return前仍是後?
會執行,在return前執行。
4四、編程題: 用最有效率的方法算出2乘以8等於幾? 
2 << 3
4五、兩個對象值相同(x.equals(y) == true),但卻可有不一樣的hash code,這句話對不對?
不對,有相同的hash code。

4六、當一個對象被看成參數傳遞到一個方法後,此方法可改變這個對象的屬性,並可返回變化後的結果,那麼這裏究竟是值傳遞仍是引用傳遞? 
是值傳遞。Java 編程語言只有值傳遞參數。當一個對象實例做爲一個參數被傳遞到方法中時,參數的值就是對該對象的引用。對象的內容能夠在被調用的方法中改變,但對象的引用是永遠不會改變的。
4七、當一個線程進入一個對象的一個synchronized方法後,其它線程是否可進入此對象的其它方法?
不能,一個對象的一個synchronized方法只能由一個線程訪問。
4八、編程題: 寫一個Singleton出來。
Singleton模式主要做用是保證在Java應用程序中,一個類Class只有一個實例存在。
通常Singleton模式一般有幾種種形式:
第一種形式: 定義一個類,它的構造函數爲private的,它有一個static的private的該類變量,在類初始化時實例話,經過一個public的getInstance方法獲取對它的引用,繼而調用其中的方法。
public class Singleton {
private Singleton(){}
   //在本身內部定義本身一個實例,是否是很奇怪?
   //注意這是private 只供內部調用
   private static Singleton instance = new Singleton();
   //這裏提供了一個供外部訪問本class的靜態方法,能夠直接訪問  
   public static Singleton getInstance() {
     return instance;   
   } 

第二種形式: 
public class Singleton { 
  private static Singleton instance = null;
  public static synchronized Singleton getInstance() {
  //這個方法比上面有所改進,不用每次都進行生成對象,只是第一次     
  //使用時生成實例,提升了效率!
  if (instance==null)
    instance=new Singleton();
return instance;   } 

其餘形式:
定義一個類,它的構造函數爲private的,全部方法爲static的。
通常認爲第一種形式要更加安全些 
4九、Java的接口和C++的虛類的相同和不一樣處。
因爲Java不支持多繼承,而有可能某個類或對象要使用分別在幾個類或對象裏面的方法或屬性,現有的單繼承機制就不能知足要求。與繼承相比,接口有更高的靈活性,由於接口中沒有任何實現代碼。當一個類實現了接口之後,該類要實現接口裏面全部的方法和屬性,而且接口裏面的屬性在默認狀態下面都是public static,全部方法默認狀況下是public.一個類能夠實現多個接口。
50、Java中的異常處理機制的簡單原理和應用。
當JAVA程序違反了JAVA的語義規則時,JAVA虛擬機就會將發生的錯誤表示爲一個異常。違反語義規則包括2種狀況。一種是JAVA類庫內置的語義檢查。例如數組下標越界,會引起IndexOutOfBoundsException;訪問null的對象時會引起NullPointerException。另外一種狀況就是JAVA容許程序員擴展這種語義檢查,程序員能夠建立本身的異常,並自由選擇在什麼時候用throw關鍵字引起異常。全部的異常都是java.lang.Thowable的子類。
5一、垃圾回收的優勢和原理。並考慮2種回收機制。
Java語言中一個顯著的特色就是引入了垃圾回收機制,使c++程序員最頭疼的內存管理的問題迎刃而解,它使得Java程序員在編寫程序的時候再也不須要考慮內存管理。因爲有個垃圾回收機制,Java中的對象再也不有「做用域」的概念,只有對象的引用纔有「做用域」。垃圾回收能夠有效的防止內存泄露,有效的使用能夠使用的內存。垃圾回收器一般是做爲一個單獨的低級別的線程運行,不可預知的狀況下對內存堆中已經死亡的或者長時間沒有使用的對象進行清楚和回收,程序員不能實時的調用垃圾回收器對某個對象或全部對象進行垃圾回收。回收機制有分代複製垃圾回收和標記垃圾回收,增量垃圾回收。
5二、請說出你所知道的線程同步的方法。
wait():使一個線程處於等待狀態,而且釋放所持有的對象的lock。
sleep():使一個正在運行的線程處於睡眠狀態,是一個靜態方法,調用此方法要捕捉InterruptedException異常。
notify():喚醒一個處於等待狀態的線程,注意的是在調用此方法的時候,並不能確切的喚醒某一個等待狀態的線程,而是由JVM肯定喚醒哪一個線程,並且不是按優先級。
Allnotity():喚醒全部處入等待狀態的線程,注意並非給全部喚醒線程一個對象的鎖,而是讓它們競爭。
5三、你所知道的集合類都有哪些?主要方法?
最經常使用的集合類是 List 和 Map。 List 的具體實現包括 ArrayList 和 Vector,它們是可變大小的列表,比較適合構建、存儲和操做任何類型對象的元素列表。 List 適用於按數值索引訪問元素的情形。 
Map 提供了一個更通用的元素存儲方法。 Map 集合類用於存儲元素對(稱做「鍵」和「值」),其中每一個鍵映射到一個值。
5四、描述一下JVM加載class文件的原理機制?
JVM中類的裝載是由ClassLoader和它的子類來實現的,Java ClassLoader 是一個重要的Java運行時系統組件。它負責在運行時查找和裝入類文件的類。
5五、char型變量中能不能存貯一箇中文漢字?爲何? 
可以定義成爲一箇中文的,由於java中以unicode編碼,一個char佔16個字節,因此放一箇中文是沒問題的
5六、多線程有幾種實現方法,都是什麼?同步有幾種實現方法,都是什麼? 
多線程有兩種實現方法,分別是繼承Thread類與實現Runnable接口 
同步的實現方面有兩種,分別是synchronized,wait與notify
5七、JSP的內置對象及方法。
request表示HttpServletRequest對象。它包含了有關瀏覽器請求的信息,而且提供了幾個用於獲取cookie, header, 和session數據的有用的方法。 
response表示HttpServletResponse對象,並提供了幾個用於設置送回 瀏覽器的響應的方法(如cookies,頭信息等) 
out對象是javax.jsp.JspWriter的一個實例,並提供了幾個方法使你能用於向瀏覽器回送輸出結果。 
pageContext表示一個javax.servlet.jsp.PageContext對象。它是用於方便存取各類範圍的名字空間、servlet相關的對象的API,而且包裝了通用的servlet相關功能的方法。 
session表示一個請求的javax.servlet.http.HttpSession對象。Session能夠存貯用戶的狀態信息 
applicaton 表示一個javax.servle.ServletContext對象。這有助於查找有關servlet引擎和servlet環境的信息 
config表示一個javax.servlet.ServletConfig對象。該對象用於存取servlet實例的初始化參數。 
page表示從該頁面產生的一個servlet實例
5八、線程的基本概念、線程的基本狀態以及狀態之間的關係
線程指在程序執行過程當中,可以執行程序代碼的一個執行單位,每一個程序至少都有一個線程,也就是程序自己。
Java中的線程有四種狀態分別是:運行、就緒、掛起、結束。 
5九、JSP的經常使用指令
<%@page language=」java」 contenType=」text/html;charset=gb2312」 session=」true」 buffer=」64kb」 autoFlush=」true」 isThreadSafe=」true」 info=」text」 errorPage=」error.jsp」 isErrorPage=」true」 isELIgnored=」true」 pageEncoding=」gb2312」 import=」java.sql.*」%>
isErrorPage(是否能使用Exception對象),isELIgnored(是否忽略表達式)
<%@include file=」filename」%>
<%@taglib prefix=」c」uri=」http://……」%>
60、什麼狀況下調用doGet()和doPost()?
Jsp頁面中的form標籤裏的method屬性爲get時調用doGet(),爲post時調用doPost()。html

 

6一、servlet的生命週期
web容器加載servlet,生命週期開始。經過調用servlet的init()方法進行servlet的初始化。經過調用service()方法實現,根據請求的不一樣調用不一樣的do***()方法。結束服務,web容器調用servlet的destroy()方法。
6二、如何現實servlet的單線程模式
<%@ page isThreadSafe=」false」%>
6三、頁面間對象傳遞的方法
request,session,application,cookie等
6四、JSP和Servlet有哪些相同點和不一樣點,他們之間的聯繫是什麼? 
JSP是Servlet技術的擴展,本質上是Servlet的簡易方式,更強調應用的外表表達。JSP編譯後是"類servlet"。Servlet和JSP最主要的不一樣點在於,Servlet的應用邏輯是在Java文件中,而且徹底從表示層中的HTML裏分離開來。而JSP的狀況是Java和HTML能夠組合成一個擴展名爲.jsp的文件。JSP側重於視圖,Servlet主要用於控制邏輯。
6五、四種會話跟蹤技術
會話做用域ServletsJSP 頁面描述
page否是表明與一個頁面相關的對象和屬性。一個頁面由一個編譯好的 Java servlet 類(能夠帶有任何的 include 指令,可是沒有 include 動做)表示。這既包括 servlet 又包括被編譯成 servlet 的 JSP 頁面
request是是表明與 Web 客戶機發出的一個請求相關的對象和屬性。一個請求可能跨越多個頁面,涉及多個 Web 組件(因爲 forward 指令和 include 動做的關係)
session是是表明與用於某個 Web 客戶機的一個用戶體驗相關的對象和屬性。一個 Web 會話能夠也常常會跨越多個客戶機請求
application是是表明與整個 Web 應用程序相關的對象和屬性。這實質上是跨越整個 Web 應用程序,包括多個頁面、請求和會話的一個全局做用域
6六、Request對象的主要方法:
setAttribute(String name,Object):設置名字爲name的request的參數值
getAttribute(String name):返回由name指定的屬性值
getAttributeNames():返回request對象全部屬性的名字集合,結果是一個枚舉的實例
getCookies():返回客戶端的全部Cookie對象,結果是一個Cookie數組
getCharacterEncoding():返回請求中的字符編碼方式
getContentLength():返回請求的Body的長度
getHeader(String name):得到HTTP協議定義的文件頭信息
getHeaders(String name):返回指定名字的request Header的全部值,結果是一個枚舉的實例
getHeaderNames():返回因此request Header的名字,結果是一個枚舉的實例
getInputStream():返回請求的輸入流,用於得到請求中的數據
getMethod():得到客戶端向服務器端傳送數據的方法
getParameter(String name):得到客戶端傳送給服務器端的有name指定的參數值
getParameterNames():得到客戶端傳送給服務器端的全部參數的名字,結果是一個枚舉的實例
getParameterValues(String name):得到有name指定的參數的全部值
getProtocol():獲取客戶端向服務器端傳送數據所依據的協議名稱
getQueryString():得到查詢字符串
getRequestURI():獲取發出請求字符串的客戶端地址
getRemoteAddr():獲取客戶端的IP地址
getRemoteHost():獲取客戶端的名字
getSession([Boolean create]):返回和請求相關Session
getServerName():獲取服務器的名字
getServletPath():獲取客戶端所請求的腳本文件的路徑
getServerPort():獲取服務器的端口號
removeAttribute(String name):刪除請求中的一個屬性
6七、J2EE是技術仍是平臺仍是框架?
J2EE自己是一個標準,一個爲企業分佈式應用的開發提供的標準平臺。
J2EE也是一個框架,包括JDBC、JNDI、RMI、JMS、EJB、JTA等技術。
6八、咱們在web應用開發過程當中常常遇到輸出某種編碼的字符,如iso8859-1等,如何輸出一個某種編碼的字符串?
Public String translate (String str) {
String tempStr = "";
try {
tempStr = new String(str.getBytes("ISO-8859-1"), "GBK");
tempStr = tempStr.trim();
}
catch (Exception e) {
System.err.println(e.getMessage());
}
return tempStr;
}
6九、簡述邏輯操做(&,|,^)與條件操做(&&,||)的區別。
區別主要答兩點:a.條件操做只能操做布爾型的,而邏輯操做不只能夠操做布爾型,並且能夠操做數值型
b.邏輯操做不會產生短路
70、XML文檔定義有幾種形式?它們之間有何本質區別?解析XML文檔有哪幾種方式? 
a: 兩種形式 dtd schema,b: 本質區別:schema自己是xml的,能夠被XML解析器解析(這也是從DTD上發展schema的根本目的),c:有DOM,SAX,STAX等 
DOM:處理大型文件時其性能降低的很是厲害。這個問題是由DOM的樹結構所形成的,這種結構佔用的內存較多,並且DOM必須在解析文件以前把整個文檔裝入內存,適合對XML的隨機訪問
SAX:不現於DOM,SAX是事件驅動型的XML解析方式。它順序讀取XML文件,不須要一次所有裝載整個文件。當遇到像文件開頭,文檔結束,或者標籤開頭與標籤結束時,它會觸發一個事件,用戶經過在其回調事件中寫入處理代碼來處理XML文件,適合對XML的順序訪問 
STAX:Streaming API for XML (StAX)
7一、簡述synchronized和java.util.concurrent.locks.Lock的異同 ?
主要相同點:Lock能完成synchronized所實現的全部功能
主要不一樣點:Lock有比synchronized更精確的線程語義和更好的性能。synchronized會自動釋放鎖,而Lock必定要求程序員手工釋放,而且必須在finally從句中釋放。
7二、EJB的角色和三個對象
一個完整的基於EJB的分佈式計算結構由六個角色組成,這六個角色能夠由不一樣的開發商提供,每一個角色所做的工做必須遵循Sun公司提供的EJB規範,以保證彼此之間的兼容性。這六個角色分別是EJB組件開發者(Enterprise Bean Provider) 、應用組合者(Application Assembler)、部署者(Deployer)、EJB 服務器提供者(EJB Server Provider)、EJB 容器提供者(EJB Container Provider)、系統管理員(System Administrator)
三個對象是Remote(Local)接口、Home(LocalHome)接口,Bean類
7三、EJB容器提供的服務
主要提供聲明週期管理、代碼產生、持續性管理、安全、事務管理、鎖和併發行管理等服務。
7四、EJB規範規定EJB中禁止的操做有哪些? 
1.不能操做線程和線程API(線程API指非線程對象的方法如notify,wait等),2.不能操做awt,3.不能實現服務器功能,4.不能對靜態屬生存取,5.不能使用IO操做直接存取文件系統,6.不能加載本地庫.,7.不能將this做爲變量和返回,8.不能循環調用。
7五、remote接口和home接口主要做用
remote接口定義了業務方法,用於EJB客戶端調用業務方法。
home接口是EJB工廠用於建立和移除查找EJB實例前端

 

7六、bean 實例的生命週期
對於Stateless Session Bean、Entity Bean、Message Driven Bean通常存在緩衝池管理,而對於Entity Bean和Statefull Session Bean存在Cache管理,一般包含建立實例,設置上下文、建立EJB Object(create)、業務方法調用、remove等過程,對於存在緩衝池管理的Bean,在create以後實例並不從內存清除,而是採用緩衝池調度機制不斷重用實例,而對於存在Cache管理的Bean則經過激活和去激活機制保持Bean的狀態並限制內存中實例數量。
7七、EJB的激活機制
以Stateful Session Bean 爲例:其Cache大小決定了內存中能夠同時存在的Bean實例的數量,根據MRU或NRU算法,實例在激活和去激活狀態之間遷移,激活機制是當客戶端調用某個EJB實例業務方法時,若是對應EJB Object發現本身沒有綁定對應的Bean實例則從其去激活Bean存儲中(經過序列化機制存儲實例)回覆(激活)此實例。狀態變遷前會調用對應的ejbActive和ejbPassivate方法。
7八、EJB的幾種類型
會話(Session)Bean ,實體(Entity)Bean 消息驅動的(Message Driven)Bean
會話Bean又可分爲有狀態(Stateful)和無狀態(Stateless)兩種
實體Bean可分爲Bean管理的持續性(BMP)和容器管理的持續性(CMP)兩種
7九、客服端調用EJB對象的幾個基本步驟
設置JNDI服務工廠以及JNDI服務地址系統屬性,查找Home接口,從Home接口調用Create方法建立Remote接口,經過Remote接口調用其業務方法。
80、如何給weblogic指定大小的內存? 
在啓動Weblogic的腳本中(位於所在Domian對應服務器目錄下的startServerName),增長set MEM_ARGS=-Xms32m -Xmx200m,能夠調整最小內存爲32M,最大200M
8一、如何設定的weblogic的熱啓動模式(開發模式)與產品發佈模式?
能夠在管理控制檯中修改對應服務器的啓動模式爲開發或產品模式之一。或者修改服務的啓動文件或者commenv文件,增長set PRODUCTION_MODE=true。
8二、如何啓動時不需輸入用戶名與密碼?
修改服務啓動文件,增長 WLS_USER和WLS_PW項。也能夠在boot.properties文件中增長加密過的用戶名和密碼.
8三、在weblogic管理制臺中對一個應用域(或者說是一個網站,Domain)進行jms及ejb或鏈接池等相關信息進行配置後,實際保存在什麼文件中?
保存在此Domain的config.xml文件中,它是服務器的核心配置文件。
8四、說說weblogic中一個Domain的缺省目錄結構?好比要將一個簡單的helloWorld.jsp放入何目錄下,然的在瀏覽器上就可打入http://主機:端口號//helloword.jsp就能夠看到運行結果了? 又好比這其中用到了一個本身寫的javaBean該如何辦?
Domain目錄服務器目錄applications,將應用目錄放在此目錄下將能夠做爲應用訪問,若是是Web應用,應用目錄須要知足Web應用目錄要求,jsp文件能夠直接放在應用目錄中,Javabean須要放在應用目錄的WEB-INF目錄的classes目錄中,設置服務器的缺省應用將能夠實如今瀏覽器上無需輸入應用名。
8五、在weblogic中發佈ejb需涉及到哪些配置文件
不一樣類型的EJB涉及的配置文件不一樣,都涉及到的配置文件包括ejb-jar.xml,weblogic-ejb-jar.xmlCMP實體Bean通常還須要weblogic-cmp-rdbms-jar.xml 
8六、如何在weblogic中進行ssl配置與客戶端的認證配置或說說j2ee(標準)進行ssl的配置
缺省安裝中使用DemoIdentity.jks和DemoTrust.jks KeyStore實現SSL,須要配置服務器使用Enable SSL,配置其端口,在產品模式下須要從CA獲取私有密鑰和數字證書,建立identity和trust keystore,裝載得到的密鑰和數字證書。能夠配置此SSL鏈接是單向仍是雙向的。
8七、如何查看在weblogic中已經發布的EJB?
能夠使用管理控制檯,在它的Deployment中能夠查看全部已發佈的EJB
8八、CORBA是什麼?用途是什麼? 
CORBA 標準是公共對象請求代理結構(Common Object Request Broker Architecture),由對象管理組織 (Object Management Group,縮寫爲 OMG)標準化。它的組成是接口定義語言(IDL), 語言綁定(binding:也譯爲聯編)和容許應用程序間互操做的協議。 其目的爲:用不一樣的程序設計語言書寫在不一樣的進程中運行,爲不一樣的操做系統開發。
8九、說說你所熟悉或據說過的j2ee中的幾種經常使用模式?及對設計模式的一些見解
Session Facade Pattern:使用SessionBean訪問EntityBean
Message Facade Pattern:實現異步調用
EJB Command Pattern:使用Command JavaBeans取代SessionBean,實現輕量級訪問
Data Transfer Object Factory:經過DTO Factory簡化EntityBean數據提供特性
Generic Attribute Access:經過AttibuteAccess接口簡化EntityBean數據提供特性
Business Interface:經過遠程(本地)接口和Bean類實現相同接口規範業務邏輯一致性
EJB架構的設計好壞將直接影響系統的性能、可擴展性、可維護性、組件可重用性及開發效率。項目越複雜,項目隊伍越龐大則越能體現良好設計的重要性。
90、說說在weblogic中開發消息Bean時的persistent與non-persisten的差異
persistent方式的MDB能夠保證消息傳遞的可靠性,也就是若是EJB容器出現問題而JMS服務器依然會將消息在此MDB可用的時候發送過來,而non-persistent方式的消息將被丟棄。java

 

9一、Servlet執行時通常實現哪幾個方法?
public void init(ServletConfig config)
public ServletConfig getServletConfig()
public String getServletInfo()
public void service(ServletRequest request,ServletResponse response)
public void destroy()
9二、j2ee經常使用的設計模式?說明工廠模式。
Java中的23種設計模式:
Factory(工廠模式), Builder(建造模式), Factory Method(工廠方法模式),
Prototype(原始模型模式),Singleton(單例模式), Facade(門面模式),
Adapter(適配器模式), Bridge(橋樑模式), Composite(合成模式),
Decorator(裝飾模式), Flyweight(享元模式), Proxy(代理模式),
Command(命令模式), Interpreter(解釋器模式), Visitor(訪問者模式),
Iterator(迭代子模式), Mediator(調停者模式), Memento(備忘錄模式),
Observer(觀察者模式), State(狀態模式), Strategy(策略模式),
Template Method(模板方法模式), Chain Of Responsibleity(責任鏈模式)
工廠模式:工廠模式是一種常常被使用到的模式,根據工廠模式實現的類能夠根據提供的數據生成一組類中某一個類的實例,一般這一組類有一個公共的抽象父類而且實現了相同的方法,可是這些方法針對不一樣的數據進行了不一樣的操做。首先須要定義一個基類,該類的子類經過不一樣的方法實現了基類中的方法。而後須要定義一個工廠類,工廠類能夠根據條件生成不一樣的子類實例。當獲得子類的實例後,開發人員能夠調用基類中的方法而沒必要考慮到底返回的是哪個子類的實例。
9三、EJB需直接實現它的業務接口或Home接口嗎,請簡述理由。
遠程接口和Home接口不須要直接實現,他們的實現代碼是由服務器產生的,程序運行中對應實現類會做爲對應接口類型的實例被使用。
9四、排序都有哪幾種方法?請列舉。用JAVA實現一個快速排序。
排序的方法有:插入排序(直接插入排序、希爾排序),交換排序(冒泡排序、快速排序),選擇排序(直接選擇排序、堆排序),歸併排序,分配排序(箱排序、基數排序)
快速排序的僞代碼。
/ /使用快速排序方法對a[ 0 :n- 1 ]排序
從a[ 0 :n- 1 ]中選擇一個元素做爲m i d d l e,該元素爲支點
把餘下的元素分割爲兩段left 和r i g h t,使得l e f t中的元素都小於等於支點,而right 中的元素都大於等於支點
遞歸地使用快速排序方法對left 進行排序
遞歸地使用快速排序方法對right 進行排序
所得結果爲l e f t + m i d d l e + r i g h t
9五、請對如下在J2EE中經常使用的名詞進行解釋(或簡單描述)
web容器:給處於其中的應用程序組件(JSP,SERVLET)提供一個環境,使JSP,SERVLET直接更容器中的環境變量接口交互,沒必要關注其它系統問題。主要有WEB服務器來實現。例如:TOMCAT,WEBLOGIC,WEBSPHERE等。該容器提供的接口嚴格遵照J2EE規範中的WEB APPLICATION 標準。咱們把遵照以上標準的WEB服務器就叫作J2EE中的WEB容器。
EJB容器:Enterprise java bean 容器。更具備行業領域特點。他提供給運行在其中的組件EJB各類管理功能。只要知足J2EE規範的EJB放入該容器,立刻就會被容器進行高效率的管理。而且能夠經過現成的接口來得到系統級別的服務。例如郵件服務、事務管理。
JNDI:(Java Naming & Directory Interface)JAVA命名目錄服務。主要提供的功能是:提供一個目錄系統,讓其它各地的應用程序在其上面留下本身的索引,從而知足快速查找和定位分佈式應用程序的功能。
JMS:(Java Message Service)JAVA消息服務。主要實現各個應用程序之間的通信。包括點對點和廣播。
JTA:(Java Transaction API)JAVA事務服務。提供各類分佈式事務服務。應用程序只需調用其提供的接口便可。
JAF:(Java Action FrameWork)JAVA安全認證框架。提供一些安全控制方面的框架。讓開發者經過各類部署和自定義實現本身的個性安全控制策略。
RMI/IIOP:(Remote Method Invocation /internet對象請求中介協議)他們主要用於經過遠程調用服務。例如,遠程有一臺計算機上運行一個程序,它提供股票分析服務,咱們能夠在本地計算機上實現對其直接調用。固然這是要經過必定的規範才能在異構的系統之間進行通訊。RMI是JAVA特有的。
9六、JAVA語言如何進行異常處理,關鍵字:throws,throw,try,catch,finally分別表明什麼意義?在try塊中能夠拋出異常嗎?
Java經過面向對象的方法進行異常處理,把各類不一樣的異常進行分類,並提供了良好的接口。在Java中,每一個異常都是一個對象,它是Throwable類或其它子類的實例。當一個方法出現異常後便拋出一個異常對象,該對象中包含有異常信息,調用這個對象的方法能夠捕獲到這個異常並進行處理。Java的異常處理是經過5個關鍵詞來實現的:try、catch、throw、throws和finally。通常狀況下是用try來執行一段程序,若是出現異常,系統會拋出(throws)一個異常,這時候你能夠經過它的類型來捕捉(catch)它,或最後(finally)由缺省處理器來處理。
用try來指定一塊預防全部「異常」的程序。緊跟在try程序後面,應包含一個catch子句來指定你想要捕捉的「異常」的類型。
throw語句用來明確地拋出一個「異常」。
throws用來標明一個成員函數可能拋出的各類「異常」。
Finally爲確保一段代碼無論發生什麼「異常」都被執行一段代碼。
能夠在一個成員函數調用的外面寫一個try語句,在這個成員函數內部寫另外一個try語句保護其餘代碼。每當遇到一個try語句,「異常」的框架就放到堆棧上面,直到全部的try語句都完成。若是下一級的try語句沒有對某種「異常」進行處理,堆棧就會展開,直到遇到有處理這種「異常」的try語句。
9七、一個「.java」源文件中是否能夠包括多個類(不是內部類)?有什麼限制?
能夠。必須只有一個類名與文件名相同。
9八、MVC的各個部分都有那些技術來實現?如何實現? 
MVC是Model-View-Controller的簡寫。"Model" 表明的是應用的業務邏輯(經過JavaBean,EJB組件實現), "View" 是應用的表示面(由JSP頁面產生),"Controller" 是提供應用的處理過程控制(通常是一個Servlet),經過這種設計模型把應用邏輯,處理過程和顯示邏輯分紅不一樣的組件實現。這些組件能夠進行交互和重用。
9九、java中有幾種方法能夠實現一個線程?用什麼關鍵字修飾同步方法? stop()和suspend()方法爲什麼不推薦使用?
有兩種實現方法,分別是繼承Thread類與實現Runnable接口
用synchronized關鍵字修飾同步方法
反對使用stop(),是由於它不安全。它會解除由線程獲取的全部鎖定,並且若是對象處於一種不連貫狀態,那麼其餘線程能在那種狀態下檢查和修改它們。結果很難檢查出真正的問題所在。suspend()方法容易發生死鎖。調用suspend()的時候,目標線程會停下來,但卻仍然持有在這以前得到的鎖定。此時,其餘任何線程都不能訪問鎖定的資源,除非被「掛起」的線程恢復運行。對任何線程來講,若是它們想恢復目標線程,同時又試圖使用任何一個鎖定的資源,就會形成死鎖。因此不該該使用suspend(),而應在本身的Thread類中置入一個標誌,指出線程應該活動仍是掛起。若標誌指出線程應該掛起,便用wait()命其進入等待狀態。若標誌指出線程應當恢復,則用一個notify()從新啓動線程。
100、java中有幾種類型的流?JDK爲每種類型的流提供了一些抽象類以供繼承,請說出他們分別是哪些類?
字節流,字符流。字節流繼承於InputStream OutputStream,字符流繼承於InputStreamReader OutputStreamWriter。在java.io包中還有許多其餘的流,主要是爲了提升性能和使用方便。
10一、java中會存在內存泄漏嗎,請簡單描述。
會。如:int i,i2; return (i-i2); //when i爲足夠大的正數,i2爲足夠大的負數。結果會形成溢位,致使錯誤。
10二、java中實現多態的機制是什麼?
方法的重寫Overriding和重載Overloading是Java多態性的不一樣表現。重寫Overriding是父類與子類之間多態性的一種表現,重載Overloading是一個類中多態性的一種表現。
10三、垃圾回收器的基本原理是什麼?垃圾回收器能夠立刻回收內存嗎?有什麼辦法主動通知虛擬機進行垃圾回收?
對於GC來講,當程序員建立對象時,GC就開始監控這個對象的地址、大小以及使用狀況。一般,GC採用有向圖的方式記錄和管理堆(heap)中的全部對象。經過這種方式肯定哪些對象是"可達的",哪些對象是"不可達的"。當GC肯定一些對象爲"不可達"時,GC就有責任回收這些內存空間。能夠。程序員能夠手動執行System.gc(),通知GC運行,可是Java語言規範並不保證GC必定會執行。
10四、靜態變量和實例變量的區別?
static i = 10; //常量
class A a; a.i =10;//可變
10五、什麼是java序列化,如何實現java序列化?
序列化就是一種用來處理對象流的機制,所謂對象流也就是將對象的內容進行流化。能夠對流化後的對象進行讀寫操做,也可將流化後的對象傳輸於網絡之間。序列化是爲了解決在對對象流進行讀寫操做時所引起的問題。
序列化的實現:將須要被序列化的類實現Serializable接口,該接口沒有須要實現的方法,implements Serializable只是爲了標註該對象是可被序列化的,而後使用一個輸出流(如:FileOutputStream)來構造一個ObjectOutputStream(對象流)對象,接着,使用ObjectOutputStream對象的writeObject(Object obj)方法就能夠將參數爲obj的對象寫出(即保存其狀態),要恢復的話則用輸入流。
10六、是否能夠從一個static方法內部發出對非static方法的調用?
不能夠,若是其中包含對象的method();不能保證對象初始化.
10七、寫clone()方法時,一般都有一行代碼,是什麼?
Clone 有缺省行爲,super.clone();他負責產生正確大小的空間,並逐位複製。
10八、在JAVA中,如何跳出當前的多重嵌套循環?
用break; return 方法。
10九、List、Map、Set三個接口,存取元素時,各有什麼特色?
List 以特定次序來持有元素,可有重複元素。Set 沒法擁有重複元素,內部排序。Map 保存key-value值,value可多值。
1十、J2EE是什麼?
J2EE是Sun公司提出的多層(multi-diered),分佈式(distributed),基於組件(component-base)的企業級應用模型(enterpriese application model).在這樣的一個應用系統中,可按照功能劃分爲不一樣的組件,這些組件又可在不一樣計算機上,而且處於相應的層次(tier)中。所屬層次包括客戶層(clietn tier)組件,web層和組件,Business層和組件,企業信息系統(EIS)層。
1十一、UML方面 
標準建模語言UML。用例圖,靜態圖(包括類圖、對象圖和包圖),行爲圖,交互圖(順序圖,合做圖),實現圖。
1十二、說出一些經常使用的類,包,接口,請各舉5個
經常使用的類:BufferedReader BufferedWriter FileReader FileWirter String Integer
經常使用的包:java.lang java.awt java.io java.util java.sql
經常使用的接口:Remote List Map Document NodeList 
11三、開發中都用到了那些設計模式?用在什麼場合? 
每一個模式都描述了一個在咱們的環境中不斷出現的問題,而後描述了該問題的解決方案的核心。經過這種方式,你能夠無數次地使用那些已有的解決方案,無需在重複相同的工做。主要用到了MVC的設計模式。用來開發JSP/Servlet或者J2EE的相關應用。簡單工廠模式等。
11四、jsp有哪些動做?做用分別是什麼? 
JSP共有如下6種基本動做 jsp:include:在頁面被請求的時候引入一個文件。 jsp:useBean:尋找或者實例化一個JavaBean。 jsp:setProperty:設置JavaBean的屬性。 jsp:getProperty:輸出某個JavaBean的屬性。 jsp:forward:把請求轉到一個新的頁面。 jsp:plugin:根據瀏覽器類型爲Java插件生成OBJECT或EMBED標記。
11五、Anonymous Inner Class (匿名內部類) 是否能夠extends(繼承)其它類,是否能夠implements(實現)interface(接口)? 
能夠繼承其餘類或完成其餘接口,在swing編程中經常使用此方式。
11六、應用服務器與WEB SERVER的區別?
應用服務器:Weblogic、Tomcat、Jboss
WEB SERVER:IIS、 Apache
11七、BS與CS的聯繫與區別。
C/S是Client/Server的縮寫。服務器一般採用高性能的PC、工做站或小型機,並採用大型數據庫系統,如Oracle、Sybase、Informix或 SQL Server。客戶端須要安裝專用的客戶端軟件。
B/S是Brower/Server的縮寫,客戶機上只要安裝一個瀏覽器(Browser),如Netscape Navigator或Internet Explorer,服務器安裝Oracle、Sybase、Informix或 SQL Server等數據庫。在這種結構下,用戶界面徹底經過WWW瀏覽器實現,一部分事務邏輯在前端實現,可是主要事務邏輯在服務器端實現。瀏覽器經過Web Server 同數據庫進行數據交互。
C/S 與 B/S 區別: 
1.硬件環境不一樣: 
  C/S 通常創建在專用的網絡上, 小範圍裏的網絡環境, 局域網之間再經過專門服務器提供鏈接和數據交換服務.
  B/S 創建在廣域網之上的, 沒必要是專門的網絡硬件環境,例與電話上網, 租用設備. 信息本身管理. 有比C/S更強的適應範圍, 通常只要有操做系統和瀏覽器就行 
2.對安全要求不一樣 
  C/S 通常面向相對固定的用戶羣, 對信息安全的控制能力很強. 通常高度機密的信息系統採用C/S 結構適宜. 能夠經過B/S發佈部分可公開信息.
  B/S 創建在廣域網之上, 對安全的控制能力相對弱, 可能面向不可知的用戶。
3.對程序架構不一樣 
  C/S 程序能夠更加註重流程, 能夠對權限多層次校驗, 對系統運行速度能夠較少考慮.
  B/S 對安全以及訪問速度的多重的考慮, 創建在須要更加優化的基礎之上. 比C/S有更高的要求 B/S結構的程序架構是發展的趨勢, 從MS的.Net系列的BizTalk 2000 Exchange 2000等, 全面支持網絡的構件搭建的系統. SUN 和IBM推的JavaBean 構件技術等,使 B/S更加成熟. 
4.軟件重用不一樣 
  C/S 程序能夠不可避免的總體性考慮, 構件的重用性不如在B/S要求下的構件的重用性好.
  B/S 對的多重結構,要求構件相對獨立的功能. 可以相對較好的重用.就入買來的餐桌能夠再利用,而不是作在牆上的石頭桌子 
5.系統維護不一樣 
  C/S 程序因爲總體性, 必須總體考察, 處理出現的問題以及系統升級. 升級難. 多是再作一個全新的系統
  B/S 構件組成,方面構件個別的更換,實現系統的無縫升級. 系統維護開銷減到最小.用戶從網上本身下載安裝就能夠實現升級. 
6.處理問題不一樣 
  C/S 程序能夠處理用戶面固定, 而且在相同區域, 安全要求高需求, 與操做系統相關. 應該都是相同的系統
  B/S 創建在廣域網上, 面向不一樣的用戶羣, 分散地域, 這是C/S沒法做到的. 與操做系統平臺關係最小. 
7.用戶接口不一樣 
  C/S 可能是創建的Window平臺上,表現方法有限,對程序員廣泛要求較高
  B/S 創建在瀏覽器上, 有更加豐富和生動的表現方式與用戶交流. 而且大部分難度減低,減低開發成本. 
8.信息流不一樣 
  C/S 程序通常是典型的中央集權的機械式處理, 交互性相對低
  B/S 信息流向可變化, B-B B-C B-G等信息、流向的變化, 更像交易中心。
11八、LINUX下線程,GDI類的解釋。
LINUX實現的就是基於核心輕量級進程的"一對一"線程模型,一個線程實體對應一個核心輕量級進程,而線程之間的管理在覈外函數庫中實現。 
GDI類爲圖像設備編程接口類庫。
11九、STRUTS的應用(如STRUTS架構) 
Struts是採用Java Servlet/JavaServer Pages技術,開發Web應用程序的開放源碼的framework。 採用Struts能開發出基於MVC(Model-View-Controller)設計模式的應用構架。 Struts有以下的主要功能: 一.包含一個controller servlet,能將用戶的請求發送到相應的Action對象。 二.JSP自由tag庫,而且在controller servlet中提供關聯支持,幫助開發員建立交互式表單應用。 三.提供了一系列實用對象:XML處理、經過Java reflection APIs自動處理JavaBeans屬性、國際化的提示和消息。
120、Jdo是什麼? 
JDO是Java對象持久化的新的規範,爲java data object的簡稱,也是一個用於存取某種數據倉庫中的對象的標準化API。JDO提供了透明的對象存儲,所以對開發人員來講,存儲數據對象徹底不須要額外的代碼(如JDBC API的使用)。這些繁瑣的例行工做已經轉移到JDO產品提供商身上,使開發人員解脫出來,從而集中時間和精力在業務邏輯上。另外,JDO很靈活,由於它能夠在任何數據底層上運行。JDBC只是面向關係數據庫(RDBMS)JDO更通用,提供到任何數據底層的存儲功能,好比關係數據庫、文件、XML以及對象數據庫(ODBMS)等等,使得應用可移植性更強。node

 

12一、內部類能夠引用他包含類的成員嗎?有沒有什麼限制?
一個內部類對象能夠訪問建立它的外部類對象的內容
12二、WEB SERVICE名詞解釋。JSWDL開發包的介紹。JAXP、JAXM的解釋。SOAP、UDDI,WSDL解釋。 
Web ServiceWeb Service是基於網絡的、分佈式的模塊化組件,它執行特定的任務,遵照具體的技術規範,這些規範使得Web Service能與其餘兼容的組件進行互操做。
JAXP(Java API for XML Parsing) 定義了在Java中使用DOM, SAX, XSLT的通用的接口。這樣在你的程序中你只要使用這些通用的接口,當你須要改變具體的實現時候也不須要修改代碼。
JAXM(Java API for XML Messaging) 是爲SOAP通訊提供訪問方法和傳輸機制的API。
WSDL是一種 XML 格式,用於將網絡服務描述爲一組端點,這些端點對包含面向文檔信息或面向過程信息的消息進行操做。這種格式首先對操做和消息進行抽象描述,而後將其綁定到具體的網絡協議和消息格式上以定義端點。相關的具體端點即組合成爲抽象端點(服務)。
SOAP即簡單對象訪問協議(Simple Object Access Protocol),它是用於交換XML編碼信息的輕量級協議。 
UDDI 的目的是爲電子商務創建標準;UDDI是一套基於Web的、分佈式的、爲Web Service提供的、信息註冊中心的實現標準規範,同時也包含一組使企業能將自身提供的Web Service註冊,以使別的企業可以發現的訪問協議的實現標準。mysql

 

JAVA代碼查錯
1.
abstract class Name {
private String name;
public abstract boolean isStupidName(String name) {}
}
大俠們,這有何錯誤?
答案: 錯。abstract method必須以分號結尾,且不帶花括號。
2.
public class Something {
void doSomething () {
private String s = "";
int l = s.length();
}
}
有錯嗎?
答案: 錯。局部變量前不能放置任何訪問修飾符 (private,public,和protected)。final能夠用來修飾局部變量
(final如同abstract和strictfp,都是非訪問修飾符,strictfp只能修飾class和method而非variable)。
3.
abstract class Something {
private abstract String doSomething ();
}
這好像沒什麼錯吧?
答案: 錯。abstract的methods不能以private修飾。abstract的methods就是讓子類implement(實現)具體細節的,怎麼能夠用private把abstract
method封鎖起來呢? (同理,abstract method前不能加final)。
4.
public class Something {
public int addOne(final int x) {
return ++x;
}
}
這個比較明顯。
答案: 錯。int x被修飾成final,意味着x不能在addOne method中被修改。
5.
public class Something {
public static void main(String[] args) {
Other o = new Other();
new Something().addOne(o);
}
public void addOne(final Other o) {
o.i++;
}
}
class Other {
public int i;
}
和上面的很類似,都是關於final的問題,這有錯嗎?
答案: 正確。在addOne method中,參數o被修飾成final。若是在addOne method裏咱們修改了o的reference
(好比: o = new Other();),那麼如同上例這題也是錯的。但這裏修改的是o的member vairable
(成員變量),而o的reference並無改變。
6.
class Something {
int i;
public void doSomething() {
System.out.println("i = " + i);
}

有什麼錯呢? 看不出來啊。
答案: 正確。輸出的是"i = 0"。int i屬於instant variable (實例變量,或叫成員變量)。instant variable有default value。int的default value是0。
7.
class Something {
final int i;
public void doSomething() {
System.out.println("i = " + i);
}
}
和上面一題只有一個地方不一樣,就是多了一個final。這難道就錯了嗎?
答案: 錯。final int i是個final的instant variable (實例變量,或叫成員變量)。final的instant variable沒有default value,必須在constructor (構造器)結束以前被賦予一個明確的值。能夠修改成"final int i = 0;"。
8.
public class Something {
public static void main(String[] args) {
Something s = new Something();
System.out.println("s.doSomething() returns " + doSomething());
}
public String doSomething() {
return "Do something ...";
}
}
看上去很完美。
答案: 錯。看上去在main裏call doSomething沒有什麼問題,畢竟兩個methods都在同一個class裏。但仔細看,main是static的。static method不能直接call non-static methods。可改爲"System.out.println("s.doSomething() returns " + s.doSomething());"。同理,static method不能訪問non-static instant variable。
9.
此處,Something類的文件名叫OtherThing.java
class Something {
private static void main(String[] something_to_do) { 
System.out.println("Do something ...");
}
}
這個好像很明顯。
答案: 正確。歷來沒有人說過Java的Class名字必須和其文件名相同。但public class的名字必須和文件名相同。
10.
interface A{
int x = 0;
}
class B{
int x =1;
}
class C extends B implements A {
public void pX(){
System.out.println(x);
}
public static void main(String[] args) {
new C().pX();
}
}
答案:錯誤。在編譯時會發生錯誤(錯誤描述不一樣的JVM有不一樣的信息,意思就是未明確的x調用,兩個x都匹配(就象在同時import java.util和java.sql兩個包時直接聲明Date同樣)。對於父類的變量,能夠用super.x來明確,而接口的屬性默認隱含爲 public static final.因此能夠經過A.x來明確。
11.
interface Playable {
void play();
}
interface Bounceable {
void play();
}
interface Rollable extends Playable, Bounceable {
Ball ball = new Ball("PingPang");
}
class Ball implements Rollable {
private String name;
public String getName() {
return name;
}
public Ball(String name) {
this.name = name; 
}
public void play() {
ball = new Ball("Football");
System.out.println(ball.getName());
}
}
這個錯誤不容易發現。
答案: 錯。"interface Rollable extends Playable, Bounceable"沒有問題。interface可繼承多個interfaces,因此這裏沒錯。問題出在interface Rollable裏的"Ball ball = new Ball("PingPang");"。任何在interface裏聲明的interface variable (接口變量,也可稱成員變量),默認爲public static final。也就是說"Ball ball = new Ball("PingPang");"其實是"public static final Ball ball = new Ball("PingPang");"。在Ball類的Play()方法中,"ball = new Ball("Football");"改變了ball的reference,而這裏的ball來自Rollable interface,Rollable interface裏的ball是public static final的,final的object是不能被改變reference的。所以編譯器將在"ball = new Ball("Football");"這裏顯示有錯。
JAVA編程題
1.如今輸入n個數字,以逗號,分開;而後可選擇升或者降序排序;按提交鍵就在另外一頁面顯示按什麼排序,結果爲,提供reset
import java.util.*;
public class bycomma{
public static String[] splitStringByComma(String source){
if(source==null||source.trim().equals(""))
return null;
StringTokenizer commaToker = new StringTokenizer(source,",");
String[] result = new String[commaToker.countTokens()];
int i=0;
while(commaToker.hasMoreTokens()){
result[i] = commaToker.nextToken();
i++;
}
return result;
}
public static void main(String args[]){
String[] s = splitStringByComma("5,8,7,4,3,9,1");
int[] ii = new int[s.length];
for(int i = 0;i<s.length;i++){
ii[i] =Integer.parseInt(s[i]);
}
Arrays.sort(ii);
//asc
for(int i=0;i<s.length;i++){
System.out.println(ii[i]);
}
//desc
for(int i=(s.length-1);i>=0;i--){
System.out.println(ii[i]);
}
}
}
2.金額轉換,阿拉伯數字的金額轉換成中國傳統的形式如:(¥1011)->(一千零一拾一元整)輸出。
package test.format;
import java.text.NumberFormat;
import java.util.HashMap;
public class SimpleMoneyFormat {
public static final String EMPTY = "";
public static final String ZERO = "零";
public static final String ONE = "壹";
public static final String TWO = "貳";
public static final String THREE = "叄";
public static final String FOUR = "肆";
public static final String FIVE = "伍";
public static final String SIX = "陸";
public static final String SEVEN = "柒";
public static final String EIGHT = "捌";
public static final String NINE = "玖";
public static final String TEN = "拾";
public static final String HUNDRED = "佰";
public static final String THOUSAND = "仟";
public static final String TEN_THOUSAND = "萬";
public static final String HUNDRED_MILLION = "億";
public static final String YUAN = "元";
public static final String JIAO = "角";
public static final String FEN = "分";
public static final String DOT = ".";c++

 

private static SimpleMoneyFormat formatter = null;
private HashMap chineseNumberMap = new HashMap();
private HashMap chineseMoneyPattern = new HashMap();
private NumberFormat numberFormat = NumberFormat.getInstance();git

 

private SimpleMoneyFormat() {
numberFormat.setMaximumFractionDigits(4);
numberFormat.setMinimumFractionDigits(2);
numberFormat.setGroupingUsed(false);程序員

 

chineseNumberMap.put("0", ZERO);
chineseNumberMap.put("1", ONE);
chineseNumberMap.put("2", TWO);
chineseNumberMap.put("3", THREE);
chineseNumberMap.put("4", FOUR);
chineseNumberMap.put("5", FIVE);
chineseNumberMap.put("6", SIX);
chineseNumberMap.put("7", SEVEN);
chineseNumberMap.put("8", EIGHT);
chineseNumberMap.put("9", NINE);
chineseNumberMap.put(DOT, DOT);

 

chineseMoneyPattern.put("1", TEN);
chineseMoneyPattern.put("2", HUNDRED);
chineseMoneyPattern.put("3", THOUSAND);
chineseMoneyPattern.put("4", TEN_THOUSAND);
chineseMoneyPattern.put("5", TEN);
chineseMoneyPattern.put("6", HUNDRED);
chineseMoneyPattern.put("7", THOUSAND);
chineseMoneyPattern.put("8", HUNDRED_MILLION);
}

 

public static SimpleMoneyFormat getInstance() {
if (formatter == null)
formatter = new SimpleMoneyFormat();
return formatter;
}

 

public String format(String moneyStr) {
checkPrecision(moneyStr);
String result;
result = convertToChineseNumber(moneyStr);
result = addUnitsToChineseMoneyString(result);
return result;
}

 

public String format(double moneyDouble) {
return format(numberFormat.format(moneyDouble));
}

 

public String format(int moneyInt) {
return format(numberFormat.format(moneyInt));
}

 

public String format(long moneyLong) {
return format(numberFormat.format(moneyLong));
}

 

public String format(Number moneyNum) {
return format(numberFormat.format(moneyNum));
}

 

private String convertToChineseNumber(String moneyStr) {
String result;
StringBuffer cMoneyStringBuffer = new StringBuffer();
for (int i = 0; i < moneyStr.length(); i++) {
cMoneyStringBuffer.append(chineseNumberMap.get(moneyStr.substring(i, i + 1)));
}
//拾佰仟萬億等都是漢字裏面纔有的單位,加上它們
int indexOfDot = cMoneyStringBuffer.indexOf(DOT);
int moneyPatternCursor = 1;
for (int i = indexOfDot - 1; i > 0; i--) {
cMoneyStringBuffer.insert(i, chineseMoneyPattern.get(EMPTY + moneyPatternCursor));
moneyPatternCursor = moneyPatternCursor == 8 ? 1 : moneyPatternCursor + 1;
}

 

String fractionPart = cMoneyStringBuffer.substring(cMoneyStringBuffer.indexOf("."));
cMoneyStringBuffer.delete(cMoneyStringBuffer.indexOf("."), cMoneyStringBuffer.length());
while (cMoneyStringBuffer.indexOf("零拾") != -1) {
cMoneyStringBuffer.replace(cMoneyStringBuffer.indexOf("零拾"), cMoneyStringBuffer.indexOf("零拾") + 2, ZERO);
}
while (cMoneyStringBuffer.indexOf("零佰") != -1) {
cMoneyStringBuffer.replace(cMoneyStringBuffer.indexOf("零佰"), cMoneyStringBuffer.indexOf("零佰") + 2, ZERO);
}
while (cMoneyStringBuffer.indexOf("零仟") != -1) {
cMoneyStringBuffer.replace(cMoneyStringBuffer.indexOf("零仟"), cMoneyStringBuffer.indexOf("零仟") + 2, ZERO);
}
while (cMoneyStringBuffer.indexOf("零萬") != -1) {
cMoneyStringBuffer.replace(cMoneyStringBuffer.indexOf("零萬"), cMoneyStringBuffer.indexOf("零萬") + 2, TEN_THOUSAND);
}
while (cMoneyStringBuffer.indexOf("零億") != -1) {
cMoneyStringBuffer.replace(cMoneyStringBuffer.indexOf("零億"), cMoneyStringBuffer.indexOf("零億") + 2, HUNDRED_MILLION);
}
while (cMoneyStringBuffer.indexOf("零零") != -1) {
cMoneyStringBuffer.replace(cMoneyStringBuffer.indexOf("零零"), cMoneyStringBuffer.indexOf("零零") + 2, ZERO);
}
if (cMoneyStringBuffer.lastIndexOf(ZERO) == cMoneyStringBuffer.length() - 1)
cMoneyStringBuffer.delete(cMoneyStringBuffer.length() - 1, cMoneyStringBuffer.length());
cMoneyStringBuffer.append(fractionPart);

 

result = cMoneyStringBuffer.toString();
return result;
}

 


private String addUnitsToChineseMoneyString(String moneyStr) {
String result;
StringBuffer cMoneyStringBuffer = new StringBuffer(moneyStr);
int indexOfDot = cMoneyStringBuffer.indexOf(DOT);
cMoneyStringBuffer.replace(indexOfDot, indexOfDot + 1, YUAN);
cMoneyStringBuffer.insert(cMoneyStringBuffer.length() - 1, JIAO);
cMoneyStringBuffer.insert(cMoneyStringBuffer.length(), FEN);
if (cMoneyStringBuffer.indexOf("零角零分") != -1)//沒有零頭,加整
cMoneyStringBuffer.replace(cMoneyStringBuffer.indexOf("零角零分"), cMoneyStringBuffer.length(), "整");
else
if (cMoneyStringBuffer.indexOf("零分") != -1)//沒有零分,加整
cMoneyStringBuffer.replace(cMoneyStringBuffer.indexOf("零分"), cMoneyStringBuffer.length(), "整");
else {
if(cMoneyStringBuffer.indexOf("零角")!=-1)
cMoneyStringBuffer.delete(cMoneyStringBuffer.indexOf("零角"),cMoneyStringBuffer.indexOf("零角")+2);
// tmpBuffer.append("整");
}
result = cMoneyStringBuffer.toString();
return result;
}

 

private void checkPrecision(String moneyStr) {
int fractionDigits = moneyStr.length() - moneyStr.indexOf(DOT) - 1;
if (fractionDigits > 2)
throw new RuntimeException("金額" + moneyStr + "的小數位多於兩位。"); //精度不能比分低
}

 

public static void main(String args[]) {
System.out.println(getInstance().format(new Double(10010001.01)));
}
}
三、繼承時候類的執行順序問題,通常都是選擇題,問你將會打印出什麼? 
答:父類: 
package test; 
public class FatherClass { 
public FatherClass() { 
System.out.println("FatherClass Create"); 


子類: 
package test; 
import test.FatherClass; 
public class ChildClass extends FatherClass { 
public ChildClass() { 
System.out.println("ChildClass Create"); 

public static void main(String[] args) { 
FatherClass fc = new FatherClass(); 
ChildClass cc = new ChildClass(); 


輸出結果: 
C:>java test.ChildClass 
FatherClass Create 
FatherClass Create 
ChildClass Create 
四、內部類的實現方式? 
答:示例代碼以下: 
package test; 
public class OuterClass { 
private class InterClass { 
public InterClass() { 
System.out.println("InterClass Create"); 


public OuterClass() { 
InterClass ic = new InterClass(); 
System.out.println("OuterClass Create"); 

public static void main(String[] args) { 
OuterClass oc = new OuterClass(); 


輸出結果: 
C:>java test/OuterClass 
InterClass Create 
OuterClass Create 
再一個例題: 
public class OuterClass { 
private double d1 = 1.0; 
//insert code here 

You need to insert an inner class declaration at line 3. Which two inner class declarations are 
valid?(Choose two.) 
A. class InnerOne{ 
public static double methoda() {return d1;} 

B. public class InnerOne{ 
static double methoda() {return d1;} 

C. private class InnerOne{ 
double methoda() {return d1;} 

D. static class InnerOne{ 
protected double methoda() {return d1;} 

E. abstract class InnerOne{ 
public abstract double methoda(); 

說明以下: 
一.靜態內部類能夠有靜態成員,而非靜態內部類則不能有靜態成員。 故 A、B 錯 
二.靜態內部類的非靜態成員能夠訪問外部類的靜態變量,而不可訪問外部類的非靜態變量;return d1 出錯。故 D 錯 
三.非靜態內部類的非靜態成員能夠訪問外部類的非靜態變量。 故 C 正確 
四.答案爲C、E 
五、Java 的通訊編程,編程題(或問答),用JAVA SOCKET編程,讀服務器幾個字符,再寫入本地顯示? 
答:Server端程序: 
package test; 
import java.net.*; 
import java.io.*; 
public class Server { 
private ServerSocket ss; 
private Socket socket; 
private BufferedReader in; 
private PrintWriter out; 
public Server() { 
try { 
ss=new ServerSocket(10000); 
while(true) { 
socket = ss.accept(); 
String RemoteIP = socket.getInetAddress().getHostAddress(); 
String RemotePort = ":"+socket.getLocalPort(); 
System.out.println("A client come in!IP:"+Remo

 

 

 

###############################################################################################
###【第二部分:難度比較大】###
###############################################################################################

 

某公司Java面試題及部分解答(難度較大)
1。請大概描述一下Vector和ArrayList的區別,Hashtable和HashMap的區別。(5) 

2。請問你在什麼狀況下會在你的JAVA代碼中使用可序列化?(5) 
爲何放到HttpSession中的對象必需要是可序列化的?(5) 

 

3。爲何在重寫了equals()方法以後也必須重寫hashCode()方法?(10) 

4。sleep()和wait()有什麼區別?(10) 

5。編程題:用最有效率的方法算出2乘以17等於多少?(5) 

6。JAVA是否是沒有內存泄漏問題?看下面的代碼片斷,並指出這些代碼隱藏的問題。(10) 
Object[] elements = new Object[10]; 
int size; 
...

 

public Object pop() { 
if (size == 0) 
return null; 
Object o = elements[--size]; 
return o; 


7。請闡述一下你對JAVA多線程中「鎖」的概念的理解。(10) 

8。全部的遞歸實現均可以用循環的方式實現,請描述一下這兩種實現方式各自的優劣。 
並舉例說明在什麼狀況下能夠使用遞歸,而在什麼狀況下只能使用循環而不能使用遞歸?(5) 

9。請簡要講一下你對測試驅動開發(TDD)的認識。(10) 

10。請闡述一下你對「面向接口編程」的理解。(10) 

11。在J2EE中有一個「容器(Container)」的概念,無論是EJB、PICO仍是Spring都有他們 
各自實現的容器,受容器管理的組件會具備有生命週期的特性,請問,爲何須要容器? 
它的好處在哪裏?它會帶來什麼樣的問題?(15) 

12。請闡述一下你對IOC(Inversion of Control)的理解。(能夠以PICO和Spring的IOC做爲例子說明他們在實現上各自的特色)(10) 

13。下面的代碼在絕大部分時間內都運行得很正常,請問在什麼狀況下會出現問題?問題的根源在哪裏?(10) 
import java.util.LinkedList; 

public class Stack { 

LinkedList list = new LinkedList(); 

public synchronized void push(Object x) { 
synchronized(list) { 
list.addLast( x ); 
notify(); 



public synchronized Object pop() 
throws Exception { 
synchronized(list) { 
if( list.size() <= 0 ) { 
wait(); 

return list.removeLast(); 





解答:
。請大概描述一下Vector和ArrayList的區別,Hashtable和HashMap的區別。(5)線程安全與否

2。請問你在什麼狀況下會在你的JAVA代碼中使用可序列化?(5)cluster中session複製,緩存persist與reload
爲何放到HttpSession中的對象必需要是可序列化的?(5)沒必須,不過session反序列化過程會致使對象不可用.

3。爲何在重寫了equals()方法以後也必須重寫hashCode()方法?(10)API規範

4。sleep()和wait()有什麼區別?(10)前者佔用CPU,後者空閒CPU

5。編程題:用最有效率的方法算出2乘以17等於多少?(5)17>>1

6。JAVA是否是沒有內存泄漏問題?看下面的代碼片斷,並指出這些代碼隱藏的問題。(10)不是
...
...沒發現內存泄漏的問題

7。請闡述一下你對JAVA多線程中「鎖」的概念的理解。(10)同步因子,在某段代碼上增長同步因子,那麼整個JVM內部只能最多有一個線程執行這段,其他的線程按FIFO方式等待執行.

8。全部的遞歸實現均可以用循環的方式實現,請描述一下這兩種實現方式各自的優劣。
並舉例說明在什麼狀況下能夠使用遞歸,而在什麼狀況下只能使用循環而不能使用遞歸?(5)沒發現全部的遞歸均可以用循環實現的,尤爲是那種不知道循環重數的遞歸算法.遞歸的優勢是簡煉,抽象性好;循環則更直觀.遞歸通常用於處理一級事務能轉化成更簡的二級事務的操做.概括不出二級事務或者二級事務更復雜的狀況不能用.

9。請簡要講一下你對測試驅動開發(TDD)的認識。(10)不認識

10。請闡述一下你對「面向接口編程」的理解。(10)1,利於擴展;2,暴露更少的方法;

11。在J2EE中有一個「容器(Container)」的概念,無論是EJB、PICO仍是Spring都有他們
各自實現的容器,受容器管理的組件會具備有生命週期的特性,請問,爲何須要容器?
它的好處在哪裏?它會帶來什麼樣的問題?(15)組件化,框架設計...

12。請闡述一下你對IOC(Inversion of Control)的理解。(能夠以PICO和Spring的IOC做爲例子說明他們在實現上各自的特色)(10)不理解

13。下面的代碼在絕大部分時間內都運行得很正常,請問在什麼狀況下會出現問題?問題的根源在哪裏?(10)wait和notify使用目的不能達到,wait()的obj,自身不能notify().出題人對wait和notify機制不夠理解.
import java.util.LinkedList;

public class Stack {

LinkedList list = new LinkedList();

public synchronized void push(Object x) {
synchronized(list) { 
list.addLast( x );
notify();
}
}

public synchronized Object pop()
throws Exception { 
synchronized(list) { 
if( list.size() <= 0 ) {
wait();
}
return list.removeLast();
}
}
}

你拿了多少分?



1。請大概描述一下Vector和ArrayList的區別,Hashtable和HashMap的區別。(5)

// thread-safe or unsafe, could contain null values or not

2。請問你在什麼狀況下會在你的JAVA代碼中使用可序列化?(5)
爲何放到HttpSession中的對象必需要是可序列化的?(5)
// save, communicate

3。爲何在重寫了equals()方法以後也必須重寫hashCode()方法?(10)

// implementations of dictionaries need hashCode() and equals()

4。sleep()和wait()有什麼區別?(10)

// threads communication: wait() and notifyAll()

5。編程題:用最有效率的方法算出2乘以17等於多少?(5)

// 2<<4+2

6。JAVA是否是沒有內存泄漏問題?看下面的代碼片斷,並指出這些代碼隱藏的問題。(10)
...
Object[] elements = new Object[10];
int size;
...
public Object pop() {
if (size == 0)
return null;
Object o = elements[--size];
return o;
}

// elements[size] = null;

7。請闡述一下你對JAVA多線程中「鎖」的概念的理解。(10)

// optimistic lock, pessimistic lock, signal, dead lock, starvation, synchronization

8。全部的遞歸實現均可以用循環的方式實現,請描述一下這兩種實現方式各自的優劣。
並舉例說明在什麼狀況下能夠使用遞歸,而在什麼狀況下只能使用循環而不能使用遞歸?(5)

// recursive: when you need a stack and stack memory is enough
// non-recursive: when you need a queue

9。請簡要講一下你對測試驅動開發(TDD)的認識。(10)

// write unit testing code first

10。請闡述一下你對「面向接口編程」的理解。(10)

// adapter, listener, bridge, decorator, proxy... patterns

11。在J2EE中有一個「容器(Container)」的概念,無論是EJB、PICO仍是Spring都有他們
各自實現的容器,受容器管理的組件會具備有生命週期的特性,請問,爲何須要容器?
它的好處在哪裏?它會帶來什麼樣的問題?(15)

// encapsulation

12。請闡述一下你對IOC(Inversion of Control)的理解。(能夠以PICO和Spring的IOC做爲例子說明他們在實現上各自的特色)(10)

// reduce classes' dependencies

13。下面的代碼在絕大部分時間內都運行得很正常,請問在什麼狀況下會出現問題?問題的根源在哪裏?(10)
import java.util.LinkedList;

public class Stack {

LinkedList list = new LinkedList();

public synchronized void push(Object x) {
synchronized(list) {
list.addLast( x );
notify();
}
}

public synchronized Object pop()
throws Exception {
synchronized(list) {
if( list.size() <= 0 ) {
wait();
}
return list.removeLast();
}
}
}

// dead lock, synchronized on both 'list' and 'this'

 

 

 

 

 

 

 

 

 

 

 

1transientvolatilejava關鍵字嗎?(瞬聯)

 

若是用transient聲明一個實例變量,當對象存儲時,它的值不須要維持。例如:

class T

{   

      transient int a;  //不須要維持

      int b;  //須要維持

}  

 

 

這裏,若是T類的一個對象寫入一個持久的存儲區域,a的內容不被保存,但b的將被保存。

volatile修飾符告訴編譯器被volatile修飾的變量能夠被程序的其餘部分改變。在多線程程序中,有時兩個或更多的線程共享一個相同的實例變量。考慮效率問題,每一個線程能夠本身保存該共享變量的私有拷貝。實際的變量副本在不一樣的時候更新,如當進入synchronized方法時。 strictfp修飾類或方法,能夠確保浮點運算(以及全部切斷)正如早期的Java版本那樣準確。切斷隻影響某些操做的指數。當一個類被strictfp修飾,全部的方法自動被strictfp修飾。

strictfp的意思是FP-strict,也就是說精確浮點的意思。在Java虛擬機進行浮點運算時,若是沒有指定strictfp關鍵字時,Java的編譯器以及運行環境在對浮點運算的表達式是採起一種近似於我行我素的行爲來完成這些操做,以至於獲得的結果每每沒法令你滿意。而一旦使用了strictfp來聲明一個類、接口或者方法時,那麼所聲明的範圍內Java的編譯器以及運行環境會徹底依照浮點規範IEEE-754來執行。所以若是你想讓你的浮點運算更加精確,並且不會由於不一樣的硬件平臺所執行的結果不一致的話,那就請用關鍵字strictfp

你能夠將一個類、接口以及方法聲明爲strictfp,可是不容許對接口中的方法以及構造函數聲明strictfp關鍵字,例以下面的代碼:

 

strictfp interface A {}

public strictfp class FpDemo1 {   

      strictfp void f() {}   

}  

 

 

2. 錯誤的使用方法

interface A {   

    strictfp void f();   

}   

public class FpDemo2 {   

    strictfp FpDemo2() {}   

}

 

 

一旦使用了關鍵字strictfp來聲明某個類、接口或者方法時,那麼在這個關鍵字所聲明的範圍內全部浮點運算都是精確的,符合IEEE-754規範

 

的。例如一個類被聲明爲strictfp,那麼該類中全部的方法都是strictfp的。

 

 

 

2)抽象類和接口有什麼區別?(瞬聯)

 

1.abstract class  Java 語言中表示的是一種繼承關係,一個類只能使用一次繼承關係。可是,一個類卻能夠實現多個interface

 

2.abstract class 中能夠有本身的數據成員,也能夠有非abstarct的成員方法,而在interface中,只可以有靜態的不能被修改的數據成員(也就是必須是static final的,不過在 interface中通常不定義數據成員),全部的成員方法都是abstract的。

 

3.abstract classinterface所反映出的設計理念不一樣。其實abstract class表示的是"is-a"關係,interface表示的是"like-a"關係。

 

4.實現抽象類和接口的類必須實現其中的全部方法。抽象類中能夠有非抽象方法。接口中則不能有實現方法。

 

5.接口中定義的變量默認是public static final 型,且必須給其初值,因此實現類中不能從新定義,也不能改變其值。

 

6.抽象類中的變量默認是 friendly 型,其值能夠在子類中從新定義,也能夠從新賦值。

 

7.接口中的方法默認都是 public,abstract 類型的。

 

 

3)能說一下java的反射(reflection)機制嗎?(瞬聯)

開放性和緣由鏈接(causally-connected)是反射系統的兩大基本要素

 

4)在java中怎樣實現多線程?(瞬聯)

extends Thread

implement Runnable

 

方法一:繼承 Thread 類,覆蓋方法 run(),咱們在建立的 Thread 類的子類中重寫 run() ,加入線程所要執行的代碼便可。下面是一個例子:

  public class MyThread extends Thread
  
{
   
int count= 1, number;
   
public MyThread(int num)
   
{
    
number = num;
    
System.out.println
    ("建立線程
 " + number);
   
}
   
public void run() {
    
while(true) {
     
System.out.println
      ("線程 " + number + ":計數
 " + count);
     
if(++count== 6) return;
    
}
  
}
  
public static void main(String args[])
  
{
   for(int i = 0;i 〈
 5; i++) new MyThread(i+1).start();
  
}
 
}
  

  這種方法簡單明瞭,符合你們的習慣,可是,它也有一個很大的缺點,那就是若是咱們的類已經從一個類繼承(如小程序必須繼承自 Applet 類),則沒法再繼承 Thread 類,這時若是咱們又不想創建一個新的類,應該怎麼辦呢?

  咱們不妨來探索一種新的方法:咱們不建立Thread類的子類,而是直接使用它,那麼咱們只能將咱們的方法做爲參數傳遞給 Thread 類的實例,有點相似回調函數。可是 Java 沒有指針,咱們只能傳遞一個包含這個方法的類的實例。

  那麼如何限制這個類必須包含這一方法呢?固然是使用接口!(雖然抽象類也可知足,可是須要繼承,而咱們之因此要採用這種新方法,不就是爲了不繼承帶來的限制嗎?)

  Java 提供了接口 java.lang.Runnable 來支持這種方法。

  方法二:實現 Runnable 接口

  Runnable接口只有一個方法run(),咱們聲明本身的類實現Runnable接口並提供這一方法,將咱們的線程代碼寫入其中,就完成了這一部分的任務。可是Runnable接口並無任何對線程的支持,咱們還必須建立Thread類的實例,這一點經過Thread類的構造函數 public Thread(Runnable target);來實現。下面是一個例子:

  public class MyThread implements Runnable
  
{
   
int count= 1, number;
   
public MyThread(int num)
   
{
    
number = num;
    System.out.println("建立線程
 " + number);
   
}
   
public void run()
   
{
    
while(true)
    
{
     
System.out.println
     ("線程 " + number + ":計數
 " + count);
     
if(++count== 6) return;
    
}
   
}
   
public static void main(String args[])
   
{
    for(int i = 0; i 〈
 5;i++) new Thread(new MyThread(i+1)).start();
   
}
  
}
  

  嚴格地說,建立Thread子類的實例也是可行的,可是必須注意的是,該子類必須沒有覆蓋 Thread 類的run 方法,不然該線程執行的將是子類的 run 方法,而不是咱們用以實現Runnable 接口的類的 run 方法,對此你們不妨試驗一下。

  使用 Runnable 接口來實現多線程使得咱們可以在一個類中包容全部的代碼,有利於封裝,它的缺點在於,咱們只能使用一套代碼,若想建立多個線程並使各個線程執行不一樣的代碼,則仍必須額外建立類,若是這樣的話,在大多數狀況下也許還不如直接用多個類分別繼承 Thread 來得緊湊。

  綜上所述,兩種方法各有千秋,你們能夠靈活運用。

  下面讓咱們一塊兒來研究一下多線程使用中的一些問題。

  3、線程的四種狀態

  1. 新狀態:線程已被建立但還沒有執行(start() 還沒有被調用)。

  2. 可執行狀態:線程能夠執行,雖然不必定正在執行。CPU 時間隨時可能被分配給該線程,從而使得它執行。

  3. 死亡狀態:正常狀況下 run() 返回使得線程死亡。調用 stop()或 destroy() 亦有一樣效果,可是不被推薦,前者會產生異常,後者是強制終止,不會釋放鎖。

  4. 阻塞狀態:線程不會被分配 CPU 時間,沒法執行。

  4、線程的優先級

  線程的優先級表明該線程的重要程度,當有多個線程同時處於可執行狀態並等待得到 CPU 時間時,線程調度系統根據各個線程的優先級來決定給誰分配 CPU 時間,優先級高的線程有更大的機會得到 CPU 時間,優先級低的線程也不是沒有機會,只是機會要小一些罷了。

  你能夠調用 Thread 類的方法 getPriority() 和 setPriority()來存取線程的優先級,線程的優先級界於1(MIN_PRIORITY)和10(MAX_PRIORITY)之間,缺省是5(NORM_PRIORITY)。

 

5)你用過哪一種設計模式?(瞬聯,IBMaspenTech

設計:design

模式:pattern

框架:framework

建立模式,結構模式和行爲模式

GoF設計模式

A.建立模式

設計模式之Factory(工廠模式)

使用工廠模式就象使用new同樣頻繁.2002/10/9更新

 

設計模式之Prototype(原型模式)

用原型實例指定建立對象的種類,而且經過拷貝這些原型建立新的對象。

設計模式之Builder

汽車由車輪 方向盤 發動機不少部件組成,同時,將這些部件組裝成汽車也是一件複雜的工做,Builder模式就是將這兩種狀況分開進行。

設計模式之Singleton(單態模式)

保證一個類只有一個實例,並提供一個訪問它的全局訪問點 2002/10/9更新

 

B.結構模式

設計模式之Facade

可擴展的使用JDBC針對不一樣的數據庫編程,Facade提供了一種靈活的實現.

設計模式之Proxy

Jive爲例,剖析代理模式在用戶級別受權機制上的應用

設計模式之Adapter

使用類再生的兩個方式:組合(new)和繼承(extends),這個已經在"thinking in java"中提到過.

設計模式之Composite

就是將類用樹形結構組合成一個單位.你向別人介紹你是某單位,你是單位中的一個元素,別人和你作買賣,至關於和單位作買賣。文章中還對Jive再進行了剖析。

設計模式之Decorator

Decorator是個油漆工,給你的東東的外表刷上美麗的顏色.

設計模式之Bridge

"牛郎織女"分開(本應在一塊兒,分開他們,造成兩個接口),在他們之間搭建一個橋(動態的結合)

設計模式之Flyweight

提供Java運行性能,下降小而大量重複的類的開銷.

 

C.行爲模式

設計模式之Template

實際上向你介紹了爲何要使用Java 抽象類,該模式原理簡單,使用很廣泛.

設計模式之Memento

很簡單一個模式,就是在內存中保留原來數據的拷貝.

設計模式之Observer

介紹如何使用Java API提供的現成Observer

 

設計模式之Chain of Responsibility

各司其職的類串成一串,好象擊鼓傳花,固然若是本身能完成,就不要推委給下一個.

設計模式之Command

什麼是將行爲封裝,Command是最好的說明.

設計模式之State

狀態是編程中常常碰到的實例,將狀態對象化,設立狀態變換器,即可在狀態中輕鬆切換.

 

設計模式之Strategy

不一樣算法各自封裝,用戶端可隨意挑選須要的算法.

設計模式之Mediator

Mediator很象十字路口的紅綠燈,每一個車輛只需和紅綠燈交互就能夠.

設計模式之Interpreter

主要用來對語言的分析,應用機會很少.

設計模式之Visitor

訪問者在進行訪問時,完成一系列實質性操做,並且還能夠擴展.

設計模式之Iterator

這個模式已經被整合入JavaCollection.在大多數場合下無需本身製造一個Iterator,只要將對象裝入Collection中,直接使用Iterator進行對象遍歷。

6)請說一下MVC架構(瞬聯,IBMaspenTech

Model:模型層

View:視圖層   

Controller:控制層

 

MVC (Modal View Controler)原本是存在於Desktop程序中的,M是指數據模型,V是指用戶界面,C則是控制器。使用MVC的目的是將M和V的實現代碼分離,從而使同一個程序能夠使用不一樣的表現形式。好比一批統計數據你能夠分別用柱狀圖、餅圖來表示。C存在的目的則是確保M和V的同步,一旦M改變,V應該同步更新。 

模型-視圖-控制器(MVC)是Xerox PARC在八十年代爲編程語言Smalltalk-80發明的一種軟件設計模式,至今已被普遍使用。最近幾年被推薦爲Sun公司J2EE平臺的設計模式,而且受到愈來愈多的使用ColdFusion 和 PHP 的開發者的歡迎。模型-視圖-控制器模式是一個有用的工具箱,它有不少好處,但也有一些缺點。
 


MVC如何工做
 

MVC是一個設計模式,它強制性的使應用程序的輸入、處理和輸出分開。使用MVC應用程序被分紅三個核心部件:模型、視圖、控制器。它們各自處理本身的任務。
 

視圖
 
視圖是用戶看到並與之交互的界面。對老式的Web應用程序來講,視圖就是由HTML元素組成的界面,在新式的Web應用程序中,HTML依舊在視圖中扮演着重要的角色,但一些新的技術已層出不窮,它們包括Macromedia Flash和象XHTML,XML/XSL,WML等一些標識語言和
Web services. 

如何處理應用程序的界面變得愈來愈有挑戰性。MVC一個大的好處是它能爲你的應用程序處理不少不一樣的視圖。在視圖中其實沒有真正的處理髮生,無論這些數據是聯機存儲的仍是一個僱員列表,做爲視圖來說,它只是做爲一種輸出數據並容許用戶操縱的方式。
 

模型
 
模型表示企業數據和業務規則。在MVC的三個部件中,模型擁有最多的處理任務。例如它可能用象EJBs和ColdFusion Components這樣的構件對象來處理數據庫。被模型返回的數據是中立的,就是說模型與數據格式無關,這樣一個模型能爲多個視圖提供數據。因爲應用於模型的代碼只需寫一次就能夠被多個視圖重用,因此減小了代碼的重複性。
 

控制器
 
控制器接受用戶的輸入並調用模型和視圖去完成用戶的需求。因此當單擊Web頁面中的超連接和發送HTML表單時,控制器自己不輸出任何東西和作任何處理。它只是接收請求並決定調用哪一個模型構件去處理請求,而後用肯定用哪一個視圖來顯示模型處理返回的數據。
 

如今咱們總結MVC的處理過程,首先控制器接收用戶的請求,並決定應該調用哪一個模型來進行處理,而後模型用業務邏輯來處理用戶的請求並返回數據,最後控制器用相應的視圖格式化模型返回的數據,並經過表示層呈現給用戶。 
爲何要使用
 MVC 

大部分Web應用程序都是用像ASP,PHP,或者CFML這樣的過程化語言來建立的。它們將像數據庫查詢語句這樣的數據層代碼和像HTML這樣的表示層代碼混在一塊兒。經驗比較豐富的開發者會將數據從表示層分離開來,但這一般不是很容易作到的,它須要精心的計劃和不斷的嘗試。MVC從根本上強制性的將它們分開。儘管構造MVC應用程序須要一些額外的工做,可是它給咱們帶來的好處是無庸質疑的。
 

首先,最重要的一點是多個視圖能共享一個模型,正如我所說起的,如今須要用愈來愈多的方式來訪問你的應用程序。對此,其中一個解決之道是使用MVC,不管你的用戶想要Flash界面或是 WAP 界面;用一個模型就能處理它們。因爲你已經將數據和業務規則從表示層分開,因此你能夠最大化的重用你的代碼了。
 

因爲模型返回的數據沒有進行格式化,因此一樣的構件能被不一樣界面使用。例如,不少數據可能用HTML來表示,可是它們也有可能要用Macromedia Flash和WAP來表示。模型也有狀態管理和數據持久性處理的功能,例如,基於會話的購物車和電子商務過程也能被Flash網站或者無線聯網的應用程序所重用。
 

由於模型是自包含的,而且與控制器和視圖相分離,因此很容易改變你的應用程序的數據層和業務規則。若是你想把你的數據庫從MySQL移植到Oracle,或者改變你的基於RDBMS數據源到LDAP,只需改變你的模型便可。一旦你正確的實現了模型,無論你的數據來自數據庫或是LDAP服務器,視圖將會正確的顯示它們。因爲運用MVC的應用程序的三個部件是相互對立,改變其中一個不會影響其它兩個,因此依據這種設計思想你能構造良好的鬆偶合的構件。
 

對我來講,控制器的也提供了一個好處,就是能夠使用控制器來聯接不一樣的模型和視圖去完成用戶的需求,這樣控制器能夠爲構造應用程序提供強有力的手段。給定一些可重用的模型和視圖,控制器能夠根據用戶的需求選擇模型進行處理,而後選擇視圖將處理結果顯示給用戶。
 

MVC的缺點
 
MVC的缺點是因爲它沒有明確的定義,因此徹底理解MVC並非很容易。使用MVC須要精心的計劃,因爲它的內部原理比較複雜,因此須要花費一些時間去思考。
 

你將不得不花費至關可觀的時間去考慮如何將MVC運用到你的應用程序,同時因爲模型和視圖要嚴格的分離,這樣也給調試應用程序到來了必定的困難。每一個構件在使用以前都須要通過完全的測試。一旦你的構件通過了測試,你就能夠毫無顧忌的重用它們了。
 

根據我我的經驗,因爲咱們將一個應用程序分紅了三個部件,因此使用MVC同時也意味着你將要管理比之前更多的文件,這一點是顯而易見的。這樣好像咱們的工做量增長了,可是請記住這比起它所能帶給咱們的好處是不值一提。
 

MVC並不適合小型甚至中等規模的應用程序,花費大量時間將MVC應用到規模並非很大的應用程序一般會得不償失。
 

MVC是一條建立軟件的好途徑
 
MVC設計模式是一個很好建立軟件的途徑,它所提倡的一些原則,像內容和顯示互相分離可能比較好理解。可是若是你要隔離模型、視圖和控制器的構件,你可能須要從新思考你的應用程序,尤爲是應用程序的構架方面。若是你肯接受MVC,而且有能力應付它所帶來的額外的工做和複雜性,MVC將會使你的軟件在健壯性,代碼重用和結構方面上一個新的臺階。

 

7)若是類a繼承類b,實現接口c,而類b和接口c中定義了同名變量,請問會出現什麼問題?(瞬聯)


interface      A

{
       int x = 0;
}
class B

{
       int x =1;
}
class C extends B implements A

{
       public void pX()

{
        System.out.println(x);
     }
       public static void main(String[] args) {
          new C().pX();
       }
}
答案:錯誤。在編譯時會發生錯誤(錯誤描述不一樣的JVM有不一樣的信息,意思就是未明確的x調用,兩個x都匹配(就象在同時import java.util和java.sql兩個包時直接聲明Date同樣)。對於父類的變量,能夠用super.x來明確(輸出的是1),而接口的屬性默認隱含爲 public static final.因此能夠經過A.x來明確(輸出的是0)。

 

下面的代碼運行時會不會報錯
interface Playable

{
        void play();
}
interface Bounceable

{
        void play();
}
interface Rollable extends Playable, Bounceable

{
        Ball ball = new Ball("PingPang");
}
class Ball implements Rollable

{
        private String name;
        public String getName()

{
            return name;
        }
        public Ball(String name)

{
            this.name = name;        
        }
       public void play()

{
            ball = new Ball("Football");
            System.out.println(ball.getName());
        }
}

答案: 錯。"interface Rollable extends Playable, Bounceable"沒有問題。interface可繼承多個interfaces,因此這裏沒錯。問題出在interface Rollable裏的"Ball ball = new Ball("PingPang");"。任何在interface裏聲明的interface variable (接口變量,也可稱成員變量),默認爲public static final。也就是說"Ball ball = new Ball("PingPang");"其實是"public static final Ball ball = new Ball("PingPang");"。在Ball類的Play()方法中,"ball = new Ball("Football");"改變了ball的reference,而這裏的ball來自Rollable interface,Rollable interface裏的ball是public static final的,final的object是不能被改變reference的。所以編譯器將在"ball = new Ball("Football");"這裏顯示有錯。

 

 

8)請說一下java中爲何要引入內部類?還有匿名內部類?(瞬聯,IBM

9)請說一下finalfinallyfinalize的區別?(瞬聯)

final 用於聲明屬性,方法和類,分別表示屬性不可變,方法不可覆蓋,類不可繼承。

finally是異常處理語句結構的一部分,表示老是執行。

finalizeObject類的一個方法,在垃圾收集器執行的時候會調用被回收對象的此方法,能夠覆蓋此方法提供垃圾收集時的其餘資源回收,例如關閉文件等。

10)請說一下HTTP請求的基本過程(IBM

 

11java中存在內存泄漏問題嗎?請舉例說明?(IBM

  

int i,i2;     return (i-i2);      //when i爲足夠大的正數,i2爲足夠大的負數。結果會形成溢位,致使錯誤。

12)請說一下java中的內存回收機制所採用的算法(IBM,瞬聯)

雖然垃圾回收關心着大部分的問題,包括內存管理,使得程序員的任務顯得更加輕鬆,可是程序員仍是可能犯些錯誤致使內存泄漏問題。GC(垃圾回收)經過遞歸對全部從對象(堆棧中的對象,靜態數據成員,JNI句柄等等)繼承下來的引用進行工做,而後標記全部能夠訪問的活動着的對象。而這些對象變成了程序惟一可以操縱的對象,其餘的對象都被釋放了。由於GC使得程序不可以訪問那些被釋放的對象,因此這樣作是安全的。

13)請說一下System.gc()函數的做用。何時能夠調用垃圾回收器?(瞬聯)

垃圾回收函數,手動調用的.

當一個對象中止被活動聲明所引用,它就變成了垃圾(garbage)能夠被回收從新使用

14)你作過的項目中採用了什麼安全認證機制?(IBM

15Math.round()什麼做用?

 

     Math.Round(3.44, 1) = 3.4
       Math.Round(3.45, 1) = 3.4
       Math.Round(3.46, 1) = 3.5
       -----------------------------------------------
       Math.Round(3.54, 1) = 3.5
       Math.Round(3.55, 1) = 3.6
       Math.Round(3.56, 1) = 3.6
       -----------------------------------------------
       Math.Round(3.64, 1) = 3.6
       Math.Round(3.65, 1) = 3.6
       Math.Round(3.66, 1) = 3.7
       -----------------------------------------------
       Math.Round(3.74, 1) = 3.7
       Math.Round(3.75, 1) = 3.8
       Math.Round(3.76, 1) = 3.8

這種舍入方法叫作銀行家舍入(Banker'sRound),這就是已經規定下來的標準、Round的標準、世界的標準。

Round <> 四捨五入

 

16、設計4個線程,其中兩個線程每次對j增長1,另外兩個線程對j每次減小1。寫出程序。
如下程序使用內部類實現線程,對j增減的時候沒有考慮順序問題。
package java_example150;

public class TestThread3{
 private int j;
 public static void main(String[] args){
  TestThread3 t = new TestThread3();
     Inc inc = t.new Inc();
     Dec dec = t.new Dec();

     for(int i=0;i<2;i++){
      Thread ts = new Thread(inc);
      ts.start();
      ts= new Thread(dec);
      ts.start();
     }
 }
 private synchronized void inc(){
     j++;
     System.out.println(Thread.currentThread().getName()+"-inc:"+j);
 }
 private synchronized void dec(){
     j--;
     System.out.println(Thread.currentThread().getName()+"-dec:"+j);
 }
 class Inc implements Runnable{
    public void run(){
     for(int i=0;i<10;i++){
      inc();
     }
    }
 }

 class Dec implements Runnable{
  public void run(){
   for(int i=0;i<10;i++){
    dec();
   }
     }
 }
}

 

 

 

17.CORBA是什麼?用途是什麼
答:CORBA 標準是公共對象請求代理結構(Common Object Request Broker Architecture),由對象管理組織 (Object Management Group,縮寫爲 OMG)標準化。它的組成是接口定義語言(IDL), 語言綁定(binding:也譯爲聯編)和容許應用程序間互操做的協議。 其目的爲:
1. 用不一樣的程序設計語言書寫 
2. 在不一樣的進程中運行 
3. 爲不一樣的操做系統開發

18.JAVA代碼查錯

 

1.

abstract class Name

{

    private String name;

    public abstract boolean isStupidName(String name) {}

}

 

答案錯。abstract method必須以分號結尾,且不帶花括號。

 

2.

public class Something

{

    void doSomething ()

   {

        private String s = "";

        int l = s.length();

    }

}

 

答案錯。局部變量前不能放置任何訪問修飾符 (privatepublic,和protected)final能夠用來修飾局部變量

(final如同abstractstrictfp,都是非訪問修飾符,strictfp只能修飾classmethod而非variable)

 

 

3.

abstract class Something

{

    private abstract String doSomething ();

}

 

答案錯。abstractmethods不能以private修飾。abstractmethods就是讓子類implement(實現)具體細節的,怎麼能夠用privateabstractmethod封鎖起來呢? (同理,abstract method前不能加final)

4.

public class Something

{

    public int addOne(final int x)

    {

        return ++x;

    }

}

 

答案錯。int x被修飾成final,意味着x不能在addOne method中被修改。

 

 

5.

public class Something

{

    public static void main(String[] args)

    {

        Other o = new Other();

        new Something().addOne(o);

    }

    public void addOne(final Other o)

    {

        o.i++;

    }

}

class Other

{

    public int i;

}

答案正確。在addOne method中,參數o被修飾成final。若是在addOne method裏咱們修改了oreference

(好比: o = new Other();),那麼如同上例這題也是錯的。但這裏修改的是omember vairable

(成員變量),而oreference並無改變。

 

 

6.

class Something

{

     int i;

     public void doSomething()

     {

         System.out.println("i = " + i);

     }

}

 

答案正確。輸出的是"i = 0"int i屬於instant variable (實例變量,或叫成員變量)instant variabledefault valueintdefault value0

 

 

7.

class Something

{

     final int i;

     public void doSomething()

     {

         System.out.println("i = " + i);

     }

}

 

答案錯。final int i 是個final的 instant variable (實例變量,或叫成員變量)finalinstant variable沒有default value,必須在constructor (構造器)結束以前被賦予一個明確的值。能夠修改成"final int i = 0;"

 

8.

public class Something

{

      public static void main(String[] args)

     {

         Something s = new Something();

         System.out.println("s.doSomething() returns " + doSomething());

     }

     public String doSomething()

    {

         return "Do something ...";

     }

}

 

答案錯。看上去在maincall doSomething沒有什麼問題,畢竟兩個methods都在同一個class裏。但仔細看,mainstatic的。static method不能直接call non-static methods可改爲"System.out.println("s.doSomething() returns " + s.doSomething());"。同理,static method不能訪問non-static instant variable

 

 

一、面向對象的特徵有哪些方面? 
答:面向對象的特徵主要有如下幾個方面: 
- 抽象:抽象是將一類對象的共同特徵總結出來構造類的過程,包括數據抽象和行爲抽象兩方面。抽象只關注對象有哪些屬性和行爲,並不關注這些行爲的細節是什麼。 
- 繼承:繼承是從已有類獲得繼承信息建立新類的過程。提供繼承信息的類被稱爲父類(超類、基類);獲得繼承信息的類被稱爲子類(派生類)。繼承讓變化中的軟件系統有了必定的延續性,同時繼承也是封裝程序中可變因素的重要手段(若是不能理解請閱讀閻宏博士的《Java與模式》或《設計模式精解》中關於橋樑模式的部分)。 
- 封裝:一般認爲封裝是把數據和操做數據的方法綁定起來,對數據的訪問只能經過已定義的接口。面向對象的本質就是將現實世界描繪成一系列徹底自治、封閉的對象。咱們在類中編寫的方法就是對實現細節的一種封裝;咱們編寫一個類就是對數據和數據操做的封裝。能夠說,封裝就是隱藏一切可隱藏的東西,只向外界提供最簡單的編程接口(能夠想一想普通洗衣機和全自動洗衣機的差異,明顯全自動洗衣機封裝更好所以操做起來更簡單;咱們如今使用的智能手機也是封裝得足夠好的,由於幾個按鍵就搞定了全部的事情)。 
- 多態性:多態性是指容許不一樣子類型的對象對同一消息做出不一樣的響應。簡單的說就是用一樣的對象引用調用一樣的方法可是作了不一樣的事情。多態性分爲編譯時的多態性和運行時的多態性。若是將對象的方法視爲對象向外界提供的服務,那麼運行時的多態性能夠解釋爲:當A系統訪問B系統提供的服務時,B系統有多種提供服務的方式,但一切對A系統來講都是透明的(就像電動剃鬚刀是A系統,它的供電系統是B系統,B系統能夠使用電池供電或者用交流電,甚至還有多是太陽能,A系統只會經過B類對象調用供電的方法,但並不知道供電系統的底層實現是什麼,究竟經過何種方式得到了動力)。方法重載(overload)實現的是編譯時的多態性(也稱爲前綁定),而方法重寫(override)實現的是運行時的多態性(也稱爲後綁定)。運行時的多態是面向對象最精髓的東西,要實現多態須要作兩件事:1). 方法重寫(子類繼承父類並重寫父類中已有的或抽象的方法);2). 對象造型(用父類型引用引用子類型對象,這樣一樣的引用調用一樣的方法就會根據子類對象的不一樣而表現出不一樣的行爲)。

 

二、訪問修飾符public,private,protected,以及不寫(默認)時的區別? 
答:

 

修飾符 當前類 同 包 子 類 其餘包
public
protected ×
default × ×
private × × ×

 

類的成員不寫訪問修飾時默認爲default。默認對於同一個包中的其餘類至關於公開(public),對於不是同一個包中的其餘類至關於私有(private)。受保護(protected)對子類至關於公開,對不是同一包中的沒有父子關係的類至關於私有。Java中,外部類的修飾符只能是public或默認,類的成員(包括內部類)的修飾符能夠是以上四種。

 

三、String 是最基本的數據類型嗎? 
答:不是。Java中的基本數據類型只有8個:byte、short、int、long、float、double、char、boolean;除了基本類型(primitive type)和枚舉類型(enumeration type),剩下的都是引用類型(reference type)。

 

四、float f=3.4;是否正確? 
答:不正確。3.4是雙精度數,將雙精度型(double)賦值給浮點型(float)屬於下轉型(down-casting,也稱爲窄化)會形成精度損失,所以須要強制類型轉換float f =(float)3.4; 或者寫成float f =3.4F;。

 

五、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);其中有隱含的強制類型轉換。

 

六、Java有沒有goto? 
答:goto 是Java中的保留字,在目前版本的Java中沒有使用。(根據James Gosling(Java之父)編寫的《The Java Programming Language》一書的附錄中給出了一個Java關鍵字列表,其中有goto和const,可是這兩個是目前沒法使用的關鍵字,所以有些地方將其稱之爲保留字,其實保留字這個詞應該有更普遍的意義,由於熟悉C語言的程序員都知道,在系統類庫中使用過的有特殊意義的單詞或單詞的組合都被視爲保留字)

 

七、int和Integer有什麼區別? 
答:Java是一個近乎純潔的面向對象編程語言,可是爲了編程的方便仍是引入了基本數據類型,可是爲了可以將這些基本數據類型當成對象操做,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); System.out.println(f3 == f4); } }

 

若是不明就裏很容易認爲兩個輸出要麼都是true要麼都是false。首先須要注意的是f一、f二、f三、f4四個變量都是Integer對象引用,因此下面的==運算比較的不是值而是引用。裝箱的本質是什麼呢?當咱們給一個Integer對象賦一個int值的時候,會調用Integer類的靜態方法valueOf,若是看看valueOf的源代碼就知道發生了什麼。

 

public static Integer valueOf(int i) { if (i >= IntegerCache.low && i <= IntegerCache.high) return IntegerCache.cache[i + (-IntegerCache.low)]; return new Integer(i); }

 

 

 

IntegerCache是Integer的內部類,其代碼以下所示:

 

/** * Cache to support the object identity semantics of autoboxing for values between * -128 and 127 (inclusive) as required by JLS. * * The cache is initialized on first usage. The size of the cache * may be controlled by the {@code -XX:AutoBoxCacheMax=<size>} option. * During VM initialization, java.lang.Integer.IntegerCache.high property * may be set and saved in the private system properties in the * sun.misc.VM class. */ private static class IntegerCache { static final int low = -128; static final int high; static final Integer cache[]; static { // high value may be configured by property int h = 127; String integerCacheHighPropValue = sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high"); if (integerCacheHighPropValue != null) { try { int i = parseInt(integerCacheHighPropValue); i = Math.max(i, 127); // Maximum array size is Integer.MAX_VALUE h = Math.min(i, Integer.MAX_VALUE - (-low) -1); } catch( NumberFormatException nfe) { // If the property cannot be parsed into an int, ignore it. } } high = h; cache = new Integer[(high - low) + 1]; int j = low; for(int k = 0; k < cache.length; k++) cache[k] = new Integer(j++); // range [-128, 127] must be interned (JLS7 5.1.7) assert IntegerCache.high >= 127; } private IntegerCache() {} }

 

 

簡單的說,若是整型字面量的值在-128到127之間,那麼不會new新的Integer對象,而是直接引用常量池中的Integer對象,因此上面的面試題中f1==f2的結果是true,而f3==f4的結果是false。

 提醒:越是貌似簡單的面試題其中的玄機就越多,須要面試者有至關深厚的功力。

 

八、&和&&的區別? 
答:&運算符有兩種用法:(1)按位與;(2)邏輯與。&&運算符是短路與運算。邏輯與跟短路與的差異是很是巨大的,雖然兩者都要求運算符左右兩端的布爾值都是true整個表達式的值纔是true。&&之因此稱爲短路運算是由於,若是&&左邊的表達式的值是false,右邊的表達式會被直接短路掉,不會進行運算。不少時候咱們可能都須要用&&而不是&,例如在驗證用戶登陸時斷定用戶名不是null並且不是空字符串,應當寫爲:username != null &&!username.equals(""),兩者的順序不能交換,更不能用&運算符,由於第一個條件若是不成立,根本不能進行字符串的equals比較,不然會產生NullPointerException異常。注意:邏輯或運算符(|)和短路或運算符(||)的差異也是如此。

 

補充:若是你熟悉JavaScript,那你可能更能感覺到短路運算的強大,想成爲JavaScript的高手就先從玩轉短路運算開始吧。

 

九、解釋內存中的棧(stack)、堆(heap)和靜態區(static area)的用法。 
答:一般咱們定義一個基本數據類型的變量,一個對象的引用,還有就是函數調用的現場保存都使用內存中的棧空間;而經過new關鍵字和構造器建立的對象放在堆空間;程序中的字面量(literal)如直接書寫的100、"hello"和常量都是放在靜態區中。棧空間操做起來最快可是棧很小,一般大量的對象都是放在堆空間,理論上整個內存沒有被其餘進程使用的空間甚至硬盤上的虛擬內存均可以被當成堆空間來使用。

 

String str = new String("hello");

 

上面的語句中變量str放在棧上,用new建立出來的字符串對象放在堆上,而"hello"這個字面量放在靜態區。

 

補充:較新版本的Java(從Java 6的某個更新開始)中使用了一項叫"逃逸分析"的技術,能夠將一些局部對象放在棧上以提高對象的操做性能。

 

十、Math.round(11.5) 等於多少?Math.round(-11.5)等於多少? 
答:Math.round(11.5)的返回值是12,Math.round(-11.5)的返回值是-11。四捨五入的原理是在參數上加0.5而後進行下取整。

 

十一、switch 是否能做用在byte 上,是否能做用在long 上,是否能做用在String上? 
答:在Java 5之前,switch(expr)中,expr只能是byte、short、char、int。從Java 5開始,Java中引入了枚舉類型,expr也能夠是enum類型,從Java 7開始,expr還能夠是字符串(String),可是長整型(long)在目前全部的版本中都是不能夠的。

 

十二、用最有效率的方法計算2乘以8? 
答: 2 << 3(左移3位至關於乘以2的3次方,右移3位至關於除以2的3次方)。

 

補充:咱們爲編寫的類重寫hashCode方法時,可能會看到以下所示的代碼,其實咱們不太理解爲何要使用這樣的乘法運算來產生哈希碼(散列碼),並且爲何這個數是個素數,爲何一般選擇31這個數?前兩個問題的答案你能夠本身百度一下,選擇31是由於能夠用移位和減法運算來代替乘法,從而獲得更好的性能。說到這裏你可能已經想到了:31 * num 等價於(num << 5) - num,左移5位至關於乘以2的5次方再減去自身就至關於乘以31,如今的VM都能自動完成這個優化。

 

public class PhoneNumber { private int areaCode; private String prefix; private String lineNumber; @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + areaCode; result = prime * result + ((lineNumber == null) ? 0 : lineNumber.hashCode()); result = prime * result + ((prefix == null) ? 0 : prefix.hashCode()); return result; } @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; PhoneNumber other = (PhoneNumber) obj; if (areaCode != other.areaCode) return false; if (lineNumber == null) { if (other.lineNumber != null) return false; } else if (!lineNumber.equals(other.lineNumber)) return false; if (prefix == null) { if (other.prefix != null) return false; } else if (!prefix.equals(other.prefix)) return false; return true; } }

 

 

 

1三、數組有沒有length()方法?String有沒有length()方法? 
答:數組沒有length()方法,有length 的屬性。String 有length()方法。JavaScript中,得到字符串的長度是經過length屬性獲得的,這一點容易和Java混淆。

 

1四、在Java中,如何跳出當前的多重嵌套循環? 
答:在最外層循環前加一個標記如A,而後用break A;能夠跳出多重循環。(Java中支持帶標籤的break和continue語句,做用有點相似於C和C++中的goto語句,可是就像要避免使用goto同樣,應該避免使用帶標籤的break和continue,由於它不會讓你的程序變得更優雅,不少時候甚至有相反的做用,因此這種語法其實不知道更好)

 

1五、構造器(constructor)是否可被重寫(override)? 
答:構造器不能被繼承,所以不能被重寫,但能夠被重載。

 

1六、兩個對象值相同(x.equals(y) == true),但卻可有不一樣的hash code,這句話對不對? 
答:不對,若是兩個對象x和y知足x.equals(y) == true,它們的哈希碼(hash code)應當相同。Java對於eqauls方法和hashCode方法是這樣規定的:(1)若是兩個對象相同(equals方法返回true),那麼它們的hashCode值必定要相同;(2)若是兩個對象的hashCode相同,它們並不必定相同。固然,你未必要按照要求去作,可是若是你違背了上述原則就會發如今使用容器時,相同的對象能夠出如今Set集合中,同時增長新元素的效率會大大降低(對於使用哈希存儲的系統,若是哈希碼頻繁的衝突將會形成存取性能急劇降低)。

 

補充:關於equals和hashCode方法,不少Java程序都知道,但不少人也就是僅僅知道而已,在Joshua Bloch的大做《Effective Java》(不少軟件公司,《Effective Java》、《Java編程思想》以及《重構:改善既有代碼質量》是Java程序員必看書籍,若是你還沒看過,那就趕忙去亞馬遜買一本吧)中是這樣介紹equals方法的:首先equals方法必須知足自反性(x.equals(x)必須返回true)、對稱性(x.equals(y)返回true時,y.equals(x)也必須返回true)、傳遞性(x.equals(y)和y.equals(z)都返回true時,x.equals(z)也必須返回true)和一致性(當x和y引用的對象信息沒有被修改時,屢次調用x.equals(y)應該獲得一樣的返回值),並且對於任何非null值的引用x,x.equals(null)必須返回false。實現高質量的equals方法的訣竅包括:1. 使用==操做符檢查"參數是否爲這個對象的引用";2. 使用instanceof操做符檢查"參數是否爲正確的類型";3. 對於類中的關鍵屬性,檢查參數傳入對象的屬性是否與之相匹配;4. 編寫完equals方法後,問本身它是否知足對稱性、傳遞性、一致性;5. 重寫equals時老是要重寫hashCode;6. 不要將equals方法參數中的Object對象替換爲其餘的類型,在重寫時不要忘掉@Override註解。

 

1七、是否能夠繼承String類? 
答:String 類是final類,不能夠被繼承。

 

補充:繼承String自己就是一個錯誤的行爲,對String類型最好的重用方式是關聯關係(Has-A)和依賴關係(Use-A)而不是繼承關係(Is-A)。

 

1八、當一個對象被看成參數傳遞到一個方法後,此方法可改變這個對象的屬性,並可返回變化後的結果,那麼這裏究竟是值傳遞仍是引用傳遞? 
答:是值傳遞。Java語言的方法調用只支持參數的值傳遞。當一個對象實例做爲一個參數被傳遞到方法中時,參數的值就是對該對象的引用。對象的屬性能夠在被調用過程當中被改變,但對對象引用的改變是不會影響到調用者的。C++和C#中能夠經過傳引用或傳輸出參數來改變傳入的參數的值。在C#中能夠編寫以下所示的代碼,可是在Java中卻作不到。

 

using System; namespace CS01 { class Program { public static void swap(ref int x, ref int y) { int temp = x; x = y; y = temp; } public static void Main (string[] args) { int a = 5, b = 10; swap (ref a, ref b); // a = 10, b = 5; Console.WriteLine ("a = {0}, b = {1}", a, b); } } }

 

 

 

說明:Java中沒有傳引用實在是很是的不方便,這一點在Java 8中仍然沒有獲得改進,正是如此在Java編寫的代碼中才會出現大量的Wrapper類(將須要經過方法調用修改的引用置於一個Wrapper類中,再將Wrapper對象傳入方法),這樣的作法只會讓代碼變得臃腫,尤爲是讓從C和C++轉型爲Java程序員的開發者沒法容忍。

 

1九、String和StringBuilder、StringBuffer的區別? 
答:Java平臺提供了兩種類型的字符串:String和StringBuffer/StringBuilder,它們能夠儲存和操做字符串。其中String是隻讀字符串,也就意味着String引用的字符串內容是不能被改變的。而StringBuffer/StringBuilder類表示的字符串對象能夠直接進行修改。StringBuilder是Java 5中引入的,它和StringBuffer的方法徹底相同,區別在於它是在單線程環境下使用的,由於它的全部方面都沒有被synchronized修飾,所以它的效率也比StringBuffer要高。

 

面試題1 - 什麼狀況下用+運算符進行字符串鏈接比調用StringBuffer/StringBuilder對象的append方法鏈接字符串性能更好?

面試題2 - 請說出下面程序的輸出。

 

class StringEqualTest {

    public static void main(String[] args) { String s1 = "Programming"; String s2 = new String("Programming"); String s3 = "Program" + "ming"; System.out.println(s1 == s2); System.out.println(s1 == s3); System.out.println(s1 == s1.intern()); } }

 

 

 

補充:String對象的intern方法會獲得字符串對象在常量池中對應的版本的引用(若是常量池中有一個字符串與String對象的equals結果是true),若是常量池中沒有對應的字符串,則該字符串將被添加到常量池中,而後返回常量池中字符串的引用。

 

20、重載(Overload)和重寫(Override)的區別。重載的方法可否根據返回類型進行區分? 
答:方法的重載和重寫都是實現多態的方式,區別在於前者實現的是編譯時的多態性,然後者實現的是運行時的多態性。重載發生在一個類中,同名的方法若是有不一樣的參數列表(參數類型不一樣、參數個數不一樣或者兩者都不一樣)則視爲重載;重寫發生在子類與父類之間,重寫要求子類被重寫方法與父類被重寫方法有相同的返回類型,比父類被重寫方法更好訪問,不能比父類被重寫方法聲明更多的異常(里氏代換原則)。重載對返回類型沒有特殊的要求。

 

面試題:華爲的面試題中曾經問過這樣一個問題 - "爲何不能根據返回類型來區分重載",快說出你的答案吧!

 

2一、描述一下JVM加載class文件的原理機制? 
答:JVM中類的裝載是由類加載器(ClassLoader)和它的子類來實現的,Java中的類加載器是一個重要的Java運行時系統組件,它負責在運行時查找和裝入類文件中的類。 
因爲Java的跨平臺性,通過編譯的Java源程序並非一個可執行程序,而是一個或多個類文件。當Java程序須要使用某個類時,JVM會確保這個類已經被加載、鏈接(驗證、準備和解析)和初始化。類的加載是指把類的.class文件中的數據讀入到內存中,一般是建立一個字節數組讀入.class文件,而後產生與所加載類對應的Class對象。加載完成後,Class對象還不完整,因此此時的類還不可用。當類被加載後就進入鏈接階段,這一階段包括驗證、準備(爲靜態變量分配內存並設置默認的初始值)和解析(將符號引用替換爲直接引用)三個步驟。最後JVM對類進行初始化,包括:1)若是類存在直接的父類而且這個類尚未被初始化,那麼就先初始化父類;2)若是類中存在初始化語句,就依次執行這些初始化語句。 
類的加載是由類加載器完成的,類加載器包括:根加載器(BootStrap)、擴展加載器(Extension)、系統加載器(System)和用戶自定義類加載器(java.lang.ClassLoader的子類)。從Java 2(JDK 1.2)開始,類加載過程採起了父親委託機制(PDM)。PDM更好的保證了Java平臺的安全性,在該機制中,JVM自帶的Bootstrap是根加載器,其餘的加載器都有且僅有一個父類加載器。類的加載首先請求父類加載器加載,父類加載器無能爲力時才由其子類加載器自行加載。JVM不會向Java程序提供對Bootstrap的引用。下面是關於幾個類加載器的說明:

 

  • Bootstrap:通常用本地代碼實現,負責加載JVM基礎核心類庫(rt.jar);
  • Extension:從java.ext.dirs系統屬性所指定的目錄中加載類庫,它的父加載器是Bootstrap;
  • System:又叫應用類加載器,其父類是Extension。它是應用最普遍的類加載器。它從環境變量classpath或者系統屬性java.class.path所指定的目錄中記載類,是用戶自定義加載器的默認父加載器。

 

2二、char 型變量中能不能存貯一箇中文漢字,爲何? 
答:char類型能夠存儲一箇中文漢字,由於Java中使用的編碼是Unicode(不選擇任何特定的編碼,直接使用字符在字符集中的編號,這是統一的惟一方法),一個char類型佔2個字節(16比特),因此放一箇中文是沒問題的。

 

補充:使用Unicode意味着字符在JVM內部和外部有不一樣的表現形式,在JVM內部都是Unicode,當這個字符被從JVM內部轉移到外部時(例如存入文件系統中),須要進行編碼轉換。因此Java中有字節流和字符流,以及在字符流和字節流之間進行轉換的轉換流,如InputStreamReader和OutputStreamReader,這兩個類是字節流和字符流之間的適配器類,承擔了編碼轉換的任務;對於C程序員來講,要完成這樣的編碼轉換恐怕要依賴於union(聯合體/共用體)共享內存的特徵來實現了。

 

2三、抽象類(abstract class)和接口(interface)有什麼異同? 
答:抽象類和接口都不可以實例化,但能夠定義抽象類和接口類型的引用。一個類若是繼承了某個抽象類或者實現了某個接口都須要對其中的抽象方法所有進行實現,不然該類仍然須要被聲明爲抽象類。接口比抽象類更加抽象,由於抽象類中能夠定義構造器,能夠有抽象方法和具體方法,而接口中不能定義構造器並且其中的方法所有都是抽象方法。抽象類中的成員能夠是private、默認、protected、public的,而接口中的成員全都是public的。抽象類中能夠定義成員變量,而接口中定義的成員變量實際上都是常量。有抽象方法的類必須被聲明爲抽象類,而抽象類未必要有抽象方法。

 

2四、靜態嵌套類(Static Nested Class)和內部類(Inner Class)的不一樣? 
答:Static Nested Class是被聲明爲靜態(static)的內部類,它能夠不依賴於外部類實例被實例化。而一般的內部類須要在外部類實例化後才能實例化,其語法看起來挺詭異的,以下所示。

 

/** * 撲克類(一副撲克) * @author 駱昊 * */ public class Poker { private static String[] suites = {"黑桃", "紅桃", "草花", "方塊"}; private static int[] faces = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13}; private Card[] cards; /** * 構造器 * */ public Poker() { cards = new Card[52]; for(int i = 0; i < suites.length; i++) { for(int j = 0; j < faces.length; j++) { cards[i * 13 + j] = new Card(suites[i], faces[j]); } } } /** * 洗牌 (隨機亂序) * */ public void shuffle() { for(int i = 0, len = cards.length; i < len; i++) { int index = (int) (Math.random() * len); Card temp = cards[index]; cards[index] = cards[i]; cards[i] = temp; } } /** * 發牌 * @param index 發牌的位置 * */ public Card deal(int index) { return cards[index]; } /** * 卡片類(一張撲克) * [內部類] * @author 駱昊 * */ public class Card { private String suite; // 花色 private int face; // 點數 public Card(String suite, int face) { this.suite = suite; this.face = face; } @Override public String toString() { String faceStr = ""; switch(face) { case 1: faceStr = "A"; break; case 11: faceStr = "J"; break; case 12: faceStr = "Q"; break; case 13: faceStr = "K"; break; default: faceStr = String.valueOf(face); } return suite + faceStr; } } }

 

 

測試代碼:

 

class PokerTest {

    public static void main(String[] args) { Poker poker = new Poker(); poker.shuffle(); // 洗牌 Poker.Card c1 = poker.deal(0); // 發第一張牌 // 對於非靜態內部類Card // 只有經過其外部類Poker對象才能建立Card對象 Poker.Card c2 = poker.new Card("紅心", 1); // 本身建立一張牌 System.out.println(c1); // 洗牌後的第一張 System.out.println(c2); // 打印: 紅心A } }

 

 

面試題 - 下面的代碼哪些地方會產生編譯錯誤?

 

class Outer {

    class Inner {}

    public static void foo() { new Inner(); } public void bar() { new Inner(); } public static void main(String[] args) { new Inner(); } }

 

注意:Java中非靜態內部類對象的建立要依賴其外部類對象,上面的面試題中foo和main方法都是靜態方法,靜態方法中沒有this,也就是說沒有所謂的外部類對象,所以沒法建立內部類對象,若是要在靜態方法中建立內部類對象,能夠這樣作:

 

new Outer().new Inner();

 

  • 1

 

2五、Java 中會存在內存泄漏嗎,請簡單描述。 
答:理論上Java由於有垃圾回收機制(GC)不會存在內存泄露問題(這也是Java被普遍使用於服務器端編程的一個重要緣由);然而在實際開發中,可能會存在無用但可達的對象,這些對象不能被GC回收,所以也會致使內存泄露的發生。例如Hibernate的Session(一級緩存)中的對象屬於持久態,垃圾回收器是不會回收這些對象的,然而這些對象中可能存在無用的垃圾對象,若是不及時關閉(close)或清空(flush)一級緩存就可能致使內存泄露。下面例子中的代碼也會致使內存泄露。

 

import java.util.Arrays;
import java.util.EmptyStackException;

public class MyStack<T> { private T[] elements; private int size = 0; private static final int INIT_CAPACITY = 16; public MyStack() { elements = (T[]) new Object[INIT_CAPACITY]; } public void push(T elem) { ensureCapacity(); elements[size++] = elem; } public T pop() { if(size == 0) throw new EmptyStackException(); return elements[--size]; } private void ensureCapacity() { if(elements.length == size) { elements = Arrays.copyOf(elements, 2 * size + 1); } } }

 

 

上面的代碼實現了一個棧(先進後出(FILO))結構,乍看之下彷佛沒有什麼明顯的問題,它甚至能夠經過你編寫的各類單元測試。然而其中的pop方法卻存在內存泄露的問題,當咱們用pop方法彈出棧中的對象時,該對象不會被看成垃圾回收,即便使用棧的程序再也不引用這些對象,由於棧內部維護着對這些對象的過時引用(obsolete reference)。在支持垃圾回收的語言中,內存泄露是很隱蔽的,這種內存泄露其實就是無心識的對象保持。若是一個對象引用被無心識的保留起來了,那麼垃圾回收器不會處理這個對象,也不會處理該對象引用的其餘對象,即便這樣的對象只有少數幾個,也可能會致使不少的對象被排除在垃圾回收以外,從而對性能形成重大影響,極端狀況下會引起Disk Paging(物理內存與硬盤的虛擬內存交換數據),甚至形成OutOfMemoryError。

 

2六、抽象的(abstract)方法是否可同時是靜態的(static),是否可同時是本地方法(native),是否可同時被synchronized修飾? 
答:都不能。抽象方法須要子類重寫,而靜態的方法是沒法被重寫的,所以兩者是矛盾的。本地方法是由本地代碼(如C代碼)實現的方法,而抽象方法是沒有實現的,也是矛盾的。synchronized和方法的實現細節有關,抽象方法不涉及實現細節,所以也是相互矛盾的。

 

2七、闡述靜態變量和實例變量的區別。 
答:靜態變量是被static修飾符修飾的變量,也稱爲類變量,它屬於類,不屬於類的任何一個對象,一個類無論建立多少個對象,靜態變量在內存中有且僅有一個拷貝;實例變量必須依存於某一實例,須要先建立對象而後經過對象才能訪問到它。靜態變量能夠實現讓多個對象共享內存。

 

補充:在Java開發中,上下文類和工具類中一般會有大量的靜態成員。

 

2八、是否能夠從一個靜態(static)方法內部發出對非靜態(non-static)方法的調用? 
答:不能夠,靜態方法只能訪問靜態成員,由於非靜態方法的調用要先建立對象,在調用靜態方法時可能對象並無被初始化。

 

2九、如何實現對象克隆? 
答:有兩種方式: 
  1). 實現Cloneable接口並重寫Object類中的clone()方法; 
  2). 實現Serializable接口,經過對象的序列化和反序列化實現克隆,能夠實現真正的深度克隆,代碼以下。

 

import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; public class MyUtil { private MyUtil() { throw new AssertionError(); } public static <T> T clone(T obj) throws Exception { ByteArrayOutputStream bout = new ByteArrayOutputStream(); ObjectOutputStream oos = new ObjectOutputStream(bout); oos.writeObject(obj); ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray()); ObjectInputStream ois = new ObjectInputStream(bin); return (T) ois.readObject(); // 說明:調用ByteArrayInputStream或ByteArrayOutputStream對象的close方法沒有任何意義 // 這兩個基於內存的流只要垃圾回收器清理對象就可以釋放資源,這一點不一樣於對外部資源(如文件流)的釋放 } }

 

 

下面是測試代碼:

 

import java.io.Serializable; /** * 人類 * @author 駱昊 * */ class Person implements Serializable { private static final long serialVersionUID = -9102017020286042305L; private String name; // 姓名 private int age; // 年齡 private Car car; // 座駕 public Person(String name, int age, Car car) { this.name = name; this.age = age; this.car = car; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public Car getCar() { return car; } public void setCar(Car car) { this.car = car; } @Override public String toString() { return "Person [name=" + name + ", age=" + age + ", car=" + car + "]"; } }

 

/** * 小汽車類 * @author 駱昊 * */ class Car implements Serializable { private static final long serialVersionUID = -5713945027627603702L; private String brand; // 品牌 private int maxSpeed; // 最高時速 public Car(String brand, int maxSpeed) { this.brand = brand; this.maxSpeed = maxSpeed; } public String getBrand() { return brand; } public void setBrand(String brand) { this.brand = brand; } public int getMaxSpeed() { return maxSpeed; } public void setMaxSpeed(int maxSpeed) { this.maxSpeed = maxSpeed; } @Override public String toString() { return "Car [brand=" + brand + ", maxSpeed=" + maxSpeed + "]"; } }

 

class CloneTest {

    public static void main(String[] args) { try { Person p1 = new Person("Hao LUO", 33, new Car("Benz", 300)); Person p2 = MyUtil.clone(p1); // 深度克隆 p2.getCar().setBrand("BYD"); // 修改克隆的Person對象p2關聯的汽車對象的品牌屬性 // 原來的Person對象p1關聯的汽車不會受到任何影響 // 由於在克隆Person對象時其關聯的汽車對象也被克隆了 System.out.println(p1); } catch (Exception e) { e.printStackTrace(); } 

 

注意:基於序列化和反序列化實現的克隆不只僅是深度克隆,更重要的是經過泛型限定,能夠檢查出要克隆的對象是否支持序列化,這項檢查是編譯器完成的,不是在運行時拋出異常,這種是方案明顯優於使用Object類的clone方法克隆對象。讓問題在編譯的時候暴露出來老是優於把問題留到運行時。

 

30、GC是什麼?爲何要有GC? 
答:GC是垃圾收集的意思,內存處理是編程人員容易出現問題的地方,忘記或者錯誤的內存回收會致使程序或系統的不穩定甚至崩潰,Java提供的GC功能能夠自動監測對象是否超過做用域從而達到自動回收內存的目的,Java語言沒有提供釋放已分配內存的顯示操做方法。Java程序員不用擔憂內存管理,由於垃圾收集器會自動進行管理。要請求垃圾收集,能夠調用下面的方法之一:System.gc() 或Runtime.getRuntime().gc() ,但JVM能夠屏蔽掉顯示的垃圾回收調用。 
垃圾回收能夠有效的防止內存泄露,有效的使用能夠使用的內存。垃圾回收器一般是做爲一個單獨的低優先級的線程運行,不可預知的狀況下對內存堆中已經死亡的或者長時間沒有使用的對象進行清除和回收,程序員不能實時的調用垃圾回收器對某個對象或全部對象進行垃圾回收。在Java誕生初期,垃圾回收是Java最大的亮點之一,由於服務器端的編程須要有效的防止內存泄露問題,然而時過境遷,現在Java的垃圾回收機制已經成爲被詬病的東西。移動智能終端用戶一般以爲iOS的系統比Android系統有更好的用戶體驗,其中一個深層次的緣由就在於Android系統中垃圾回收的不可預知性。

 

補充:垃圾回收機制有不少種,包括:分代複製垃圾回收、標記垃圾回收、增量垃圾回收等方式。標準的Java進程既有棧又有堆。棧保存了原始型局部變量,堆保存了要建立的對象。Java平臺對堆內存回收和再利用的基本算法被稱爲標記和清除,可是Java對其進行了改進,採用「分代式垃圾收集」。這種方法會跟Java對象的生命週期將堆內存劃分爲不一樣的區域,在垃圾收集過程當中,可能會將對象移動到不一樣區域: 
- 伊甸園(Eden):這是對象最初誕生的區域,而且對大多數對象來講,這裏是它們惟一存在過的區域。 
- 倖存者樂園(Survivor):從伊甸園倖存下來的對象會被挪到這裏。 
- 終身頤養園(Tenured):這是足夠老的倖存對象的歸宿。年輕代收集(Minor-GC)過程是不會觸及這個地方的。當年輕代收集不能把對象放進終身頤養園時,就會觸發一次徹底收集(Major-GC),這裏可能還會牽扯到壓縮,以便爲大對象騰出足夠的空間。

 

與垃圾回收相關的JVM參數:

 

  • -Xms / -Xmx — 堆的初始大小 / 堆的最大大小
  • -Xmn — 堆中年輕代的大小
  • -XX:-DisableExplicitGC — 讓System.gc()不產生任何做用
  • -XX:+PrintGCDetails — 打印GC的細節
  • -XX:+PrintGCDateStamps — 打印GC操做的時間戳
  • -XX:NewSize / XX:MaxNewSize — 設置新生代大小/新生代最大大小
  • -XX:NewRatio — 能夠設置老生代和新生代的比例
  • -XX:PrintTenuringDistribution — 設置每次新生代GC後輸出倖存者樂園中對象年齡的分佈
  • -XX:InitialTenuringThreshold / -XX:MaxTenuringThreshold:設置老年代閥值的初始值和最大值
  • -XX:TargetSurvivorRatio:設置倖存區的目標使用率

 

3一、String s = new String("xyz");建立了幾個字符串對象? 
答:兩個對象,一個是靜態區的"xyz",一個是用new建立在堆上的對象。

 

3二、接口是否可繼承(extends)接口?抽象類是否可實現(implements)接口?抽象類是否可繼承具體類(concrete class)? 
答:接口能夠繼承接口,並且支持多重繼承。抽象類能夠實現(implements)接口,抽象類可繼承具體類也能夠繼承抽象類。

 

3三、一個".java"源文件中是否能夠包含多個類(不是內部類)?有什麼限制? 
答:能夠,但一個源文件中最多隻能有一個公開類(public class)並且文件名必須和公開類的類名徹底保持一致。

 

3四、Anonymous Inner Class(匿名內部類)是否能夠繼承其它類?是否能夠實現接口? 
答:能夠繼承其餘類或實現其餘接口,在Swing編程和Android開發中經常使用此方式來實現事件監聽和回調。

 

3五、內部類能夠引用它的包含類(外部類)的成員嗎?有沒有什麼限制? 
答:一個內部類對象能夠訪問建立它的外部類對象的成員,包括私有成員。

 

3六、Java 中的final關鍵字有哪些用法? 
答:(1)修飾類:表示該類不能被繼承;(2)修飾方法:表示方法不能被重寫;(3)修飾變量:表示變量只能一次賦值之後值不能被修改(常量)。

 

3七、指出下面程序的運行結果。

 

class A { static { System.out.print("1"); } public A() { System.out.print("2"); } } class B extends A{ static { System.out.print("a"); } public B() { System.out.print("b"); } } public class Hello { public static void main(String[] args) { A ab = new B(); ab = new B(); } }

 

 

 

 

答:執行結果:1a2b2b。建立對象時構造器的調用順序是:先初始化靜態成員,而後調用父類構造器,再初始化非靜態成員,最後調用自身構造器。

 

提示:若是不能給出此題的正確答案,說明以前第21題Java類加載機制尚未徹底理解,趕忙再看看吧。

 

3八、數據類型之間的轉換: 
- 如何將字符串轉換爲基本數據類型? 
- 如何將基本數據類型轉換爲字符串? 
答: 
- 調用基本數據類型對應的包裝類中的方法parseXXX(String)或valueOf(String)便可返回相應基本類型; 
- 一種方法是將基本數據類型與空字符串("")鏈接(+)便可得到其所對應的字符串;另外一種方法是調用String 類中的valueOf()方法返回相應字符串

 

3九、如何實現字符串的反轉及替換? 
答:方法不少,能夠本身寫實現也能夠使用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); }

 

 

40、怎樣將GB2312編碼的字符串轉換爲ISO-8859-1編碼的字符串? 
答:代碼以下所示:

 

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

 

  • 1
  • 2

 

4一、日期和時間: 
- 如何取得年月日、小時分鐘秒? 
- 如何取得從1970年1月1日0時0分0秒到如今的毫秒數? 
- 如何取得某月的最後一天? 
- 如何格式化日期? 
答: 
問題1:建立java.util.Calendar 實例,調用其get()方法傳入不一樣的參數便可得到參數所對應的值。Java 8中能夠使用java.time.LocalDateTimel來獲取,代碼以下所示。

 

public class DateTimeTest {
    public static void main(String[] args) {
        Calendar cal = Calendar.getInstance(); System.out.println(cal.get(Calendar.YEAR)); System.out.println(cal.get(Calendar.MONTH)); // 0 - 11 System.out.println(cal.get(Calendar.DATE)); System.out.println(cal.get(Calendar.HOUR_OF_DAY)); System.out.println(cal.get(Calendar.MINUTE)); System.out.println(cal.get(Calendar.SECOND)); // Java 8 LocalDateTime dt = LocalDateTime.now(); System.out.println(dt.getYear()); System.out.println(dt.getMonthValue()); // 1 - 12 System.out.println(dt.getDayOfMonth()); System.out.println(dt.getHour()); System.out.println(dt.getMinute()); System.out.println(dt.getSecond()); } }

 

 

問題2:如下方法都可得到該毫秒數。

 

Calendar.getInstance().getTimeInMillis(); System.currentTimeMillis(); Clock.systemDefaultZone().millis(); // Java 8

 

 

問題3:代碼以下所示。

 

Calendar time = Calendar.getInstance(); time.getActualMaximum(Calendar.DAY_OF_MONTH);

 

 

問題4:利用java.text.DataFormat 的子類(如SimpleDateFormat類)中的format(Date)方法可將日期格式化。Java 8中能夠用java.time.format.DateTimeFormatter來格式化時間日期,代碼以下所示。

 

import java.text.SimpleDateFormat; import java.time.LocalDate; import java.time.format.DateTimeFormatter; import java.util.Date; class DateFormatTest { public static void main(String[] args) { SimpleDateFormat oldFormatter = new SimpleDateFormat("yyyy/MM/dd"); Date date1 = new Date(); System.out.println(oldFormatter.format(date1)); // Java 8 DateTimeFormatter newFormatter = DateTimeFormatter.ofPattern("yyyy/MM/dd"); LocalDate date2 = LocalDate.now(); System.out.println(date2.format(newFormatter)); } }

 

補充:Java的時間日期API一直以來都是被詬病的東西,爲了解決這一問題,Java 8中引入了新的時間日期API,其中包括LocalDate、LocalTime、LocalDateTime、Clock、Instant等類,這些的類的設計都使用了不變模式,所以是線程安全的設計。若是不理解這些內容,能夠參考個人另外一篇文章《關於Java併發編程的總結和思考》

 

4二、打印昨天的當前時刻。 
答:

 

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); } }

 

 

 

4三、比較一下Java和JavaSciprt。 
答:JavaScript 與Java是兩個公司開發的不一樣的兩個產品。Java 是原Sun Microsystems公司推出的面向對象的程序設計語言,特別適合於互聯網應用程序開發;而JavaScript是Netscape公司的產品,爲了擴展Netscape瀏覽器的功能而開發的一種能夠嵌入Web頁面中運行的基於對象和事件驅動的解釋性語言。JavaScript的前身是LiveScript;而Java的前身是Oak語言。 
下面對兩種語言間的異同做以下比較: 
- 基於對象和麪向對象:Java是一種真正的面向對象的語言,即便是開發簡單的程序,必須設計對象;JavaScript是種腳本語言,它能夠用來製做與網絡無關的,與用戶交互做用的複雜軟件。它是一種基於對象(Object-Based)和事件驅動(Event-Driven)的編程語言,於是它自己提供了很是豐富的內部對象供設計人員使用。 
- 解釋和編譯:Java的源代碼在執行以前,必須通過編譯。JavaScript是一種解釋性編程語言,其源代碼不需通過編譯,由瀏覽器解釋執行。(目前的瀏覽器幾乎都使用了JIT(即時編譯)技術來提高JavaScript的運行效率) 
- 強類型變量和類型弱變量:Java採用強類型變量檢查,即全部變量在編譯以前必須做聲明;JavaScript中變量是弱類型的,甚至在使用變量前能夠不做聲明,JavaScript的解釋器在運行時檢查推斷其數據類型。 
- 代碼格式不同。

 

補充:上面列出的四點是網上流傳的所謂的標準答案。其實Java和JavaScript最重要的區別是一個是靜態語言,一個是動態語言。目前的編程語言的發展趨勢是函數式語言和動態語言。在Java中類(class)是一等公民,而JavaScript中函數(function)是一等公民,所以JavaScript支持函數式編程,能夠使用Lambda函數和閉包(closure),固然Java 8也開始支持函數式編程,提供了對Lambda表達式以及函數式接口的支持。對於這類問題,在面試的時候最好仍是用本身的語言回答會更加靠譜,不要背網上所謂的標準答案。

 

4四、何時用斷言(assert)? 
答:斷言在軟件開發中是一種經常使用的調試方式,不少開發語言中都支持這種機制。通常來講,斷言用於保證程序最基本、關鍵的正確性。斷言檢查一般在開發和測試時開啓。爲了保證程序的執行效率,在軟件發佈後斷言檢查一般是關閉的。斷言是一個包含布爾表達式的語句,在執行這個語句時假定該表達式爲true;若是表達式的值爲false,那麼系統會報告一個AssertionError。斷言的使用以下面的代碼所示:

 

assert(a > 0); // throws an AssertionError if a <= 0

 

  • 1

 

斷言能夠有兩種形式: 
assert Expression1; 
assert Expression1 : Expression2 ; 
Expression1 應該老是產生一個布爾值。 
Expression2 能夠是得出一個值的任意表達式;這個值用於生成顯示更多調試信息的字符串消息。

 

要在運行時啓用斷言,能夠在啓動JVM時使用-enableassertions或者-ea標記。要在運行時選擇禁用斷言,能夠在啓動JVM時使用-da或者-disableassertions標記。要在系統類中啓用或禁用斷言,可以使用-esa或-dsa標記。還能夠在包的基礎上啓用或者禁用斷言。

 

注意:斷言不該該以任何方式改變程序的狀態。簡單的說,若是但願在不知足某些條件時阻止代碼的執行,就能夠考慮用斷言來阻止它。

 

4五、Error和Exception有什麼區別? 
答:Error表示系統級的錯誤和程序沒必要處理的異常,是恢復不是不可能但很困難的狀況下的一種嚴重問題;好比內存溢出,不可能期望程序能處理這樣的狀況;Exception表示須要捕捉或者須要程序進行處理的異常,是一種設計或實現問題;也就是說,它表示若是程序運行正常,從不會發生的狀況。

 

面試題:2005年摩托羅拉的面試中曾經問過這麼一個問題「If a process reports a stack overflow run-time error, what’s the most possible cause?」,給了四個選項a. lack of memory; b. write on an invalid memory space; c. recursive function calling; d. array index out of boundary. Java程序在運行時也可能會遭遇StackOverflowError,這是一個沒法恢復的錯誤,只能從新修改代碼了,這個面試題的答案是c。若是寫了不能迅速收斂的遞歸,則頗有可能引起棧溢出的錯誤,以下所示:

 

class StackOverflowErrorTest {

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

 

提示:用遞歸編寫程序時必定要牢記兩點:1. 遞歸公式;2. 收斂條件(何時就再也不繼續遞歸)。

 

4六、try{}裏有一個return語句,那麼緊跟在這個try後的finally{}裏的代碼會不會被執行,何時被執行,在return前仍是後? 
答:會執行,在方法返回調用者前執行。

 

注意:在finally中改變返回值的作法是很差的,由於若是存在finally代碼塊,try中的return語句不會立馬返回調用者,而是記錄下返回值待finally代碼塊執行完畢以後再向調用者返回其值,而後若是在finally中修改了返回值,就會返回修改後的值。顯然,在finally中返回或者修改返回值會對程序形成很大的困擾,C#中直接用編譯錯誤的方式來阻止程序員幹這種齷齪的事情,Java中也能夠經過提高編譯器的語法檢查級別來產生警告或錯誤,Eclipse中能夠在如圖所示的地方進行設置,強烈建議將此項設置爲編譯錯誤。

 

這裏寫圖片描述

 

4七、Java語言如何進行異常處理,關鍵字:throws、throw、try、catch、finally分別如何使用? 
答:Java經過面向對象的方法進行異常處理,把各類不一樣的異常進行分類,並提供了良好的接口。在Java中,每一個異常都是一個對象,它是Throwable類或其子類的實例。當一個方法出現異常後便拋出一個異常對象,該對象中包含有異常信息,調用這個對象的方法能夠捕獲到這個異常並能夠對其進行處理。Java的異常處理是經過5個關鍵詞來實現的:try、catch、throw、throws和finally。通常狀況下是用try來執行一段程序,若是系統會拋出(throw)一個異常對象,能夠經過它的類型來捕獲(catch)它,或經過老是執行代碼塊(finally)來處理;try用來指定一塊預防全部異常的程序;catch子句緊跟在try塊後面,用來指定你想要捕獲的異常的類型;throw語句用來明確地拋出一個異常;throws用來聲明一個方法可能拋出的各類異常(固然聲明異常時容許無病呻吟);finally爲確保一段代碼無論發生什麼異常情況都要被執行;try語句能夠嵌套,每當遇到一個try語句,異常的結構就會被放入異常棧中,直到全部的try語句都完成。若是下一級的try語句沒有對某種異常進行處理,異常棧就會執行出棧操做,直到遇到有處理這種異常的try語句或者最終將異常拋給JVM。

 

4八、運行時異常與受檢異常有何異同? 
答:異常表示程序運行過程當中可能出現的非正常狀態,運行時異常表示虛擬機的一般操做中可能遇到的異常,是一種常見運行錯誤,只要程序設計得沒有問題一般就不會發生。受檢異常跟程序運行的上下文環境有關,即便程序設計無誤,仍然可能因使用的問題而引起。Java編譯器要求方法必須聲明拋出可能發生的受檢異常,可是並不要求必須聲明拋出未被捕獲的運行時異常。異常和繼承同樣,是面向對象程序設計中常常被濫用的東西,在Effective Java中對異常的使用給出瞭如下指導原則: 
- 不要將異常處理用於正常的控制流(設計良好的API不該該強迫它的調用者爲了正常的控制流而使用異常) 
- 對能夠恢復的狀況使用受檢異常,對編程錯誤使用運行時異常 
- 避免沒必要要的使用受檢異常(能夠經過一些狀態檢測手段來避免異常的發生) 
- 優先使用標準的異常 
- 每一個方法拋出的異常都要有文檔 
- 保持異常的原子性 
- 不要在catch中忽略掉捕獲到的異常

 

4九、列出一些你常見的運行時異常? 
答: 
- ArithmeticException(算術異常) 
- ClassCastException (類轉換異常) 
- IllegalArgumentException (非法參數異常) 
- IndexOutOfBoundsException (下標越界異常) 
- NullPointerException (空指針異常) 
- SecurityException (安全異常)

 

50、闡述final、finally、finalize的區別。 
答: 
- final:修飾符(關鍵字)有三種用法:若是一個類被聲明爲final,意味着它不能再派生出新的子類,即不能被繼承,所以它和abstract是反義詞。將變量聲明爲final,能夠保證它們在使用中不被改變,被聲明爲final的變量必須在聲明時給定初值,而在之後的引用中只能讀取不可修改。被聲明爲final的方法也一樣只能使用,不能在子類中被重寫。 
- finally:一般放在try…catch…的後面構造老是執行代碼塊,這就意味着程序不管正常執行仍是發生異常,這裏的代碼只要JVM不關閉都能執行,能夠將釋放外部資源的代碼寫在finally塊中。 
- finalize:Object類中定義的方法,Java中容許使用finalize()方法在垃圾收集器將對象從內存中清除出去以前作必要的清理工做。這個方法是由垃圾收集器在銷燬對象時調用的,經過重寫finalize()方法能夠整理系統資源或者執行其餘清理工做。

 

5一、類ExampleA繼承Exception,類ExampleB繼承ExampleA。 
有以下代碼片段:

 

try { throw new ExampleB("b") } catch(ExampleA e){ System.out.println("ExampleA"); } catch(Exception e){ System.out.println("Exception"); }

 

請問執行此段代碼的輸出是什麼? 
答:輸出:ExampleA。(根據里氏代換原則[能使用父類型的地方必定能使用子類型],抓取ExampleA類型異常的catch塊可以抓住try塊中拋出的ExampleB類型的異常)

 

面試題 - 說出下面代碼的運行結果。(此題的出處是《Java編程思想》一書)

 

class Annoyance extends Exception {} class Sneeze extends Annoyance {} class Human { public static void main(String[] args) throws Exception { try { try { throw new Sneeze(); } catch ( Annoyance a ) { System.out.println("Caught Annoyance"); throw a; } } catch ( Sneeze s ) { System.out.println("Caught Sneeze"); return ; } finally { System.out.println("Hello World!"); } } }

 

5二、List、Set、Map是否繼承自Collection接口? 
答:List、Set 是,Map 不是。Map是鍵值對映射容器,與List和Set有明顯的區別,而Set存儲的零散的元素且不容許有重複元素(數學中的集合也是如此),List是線性結構的容器,適用於按數值索引訪問元素的情形。

 

5三、闡述ArrayList、Vector、LinkedList的存儲性能和特性。 
答:ArrayList 和Vector都是使用數組方式存儲數據,此數組元素數大於實際存儲的數據以便增長和插入元素,它們都容許直接按序號索引元素,可是插入元素要涉及數組元素移動等內存操做,因此索引數據快而插入數據慢,Vector中的方法因爲添加了synchronized修飾,所以Vector是線程安全的容器,但性能上較ArrayList差,所以已是Java中的遺留容器。LinkedList使用雙向鏈表實現存儲(將內存中零散的內存單元經過附加的引用關聯起來,造成一個能夠按序號索引的線性結構,這種鏈式存儲方式與數組的連續存儲方式相比,內存的利用率更高),按序號索引數據須要進行前向或後向遍歷,可是插入數據時只須要記錄本項的先後項便可,因此插入速度較快。Vector屬於遺留容器(Java早期的版本中提供的容器,除此以外,Hashtable、Dictionary、BitSet、Stack、Properties都是遺留容器),已經不推薦使用,可是因爲ArrayList和LinkedListed都是非線程安全的,若是遇到多個線程操做同一個容器的場景,則能夠經過工具類Collections中的synchronizedList方法將其轉換成線程安全的容器後再使用(這是對裝潢模式的應用,將已有對象傳入另外一個類的構造器中建立新的對象來加強實現)。

 

補充:遺留容器中的Properties類和Stack類在設計上有嚴重的問題,Properties是一個鍵和值都是字符串的特殊的鍵值對映射,在設計上應該是關聯一個Hashtable並將其兩個泛型參數設置爲String類型,可是Java API中的Properties直接繼承了Hashtable,這很明顯是對繼承的濫用。這裏複用代碼的方式應該是Has-A關係而不是Is-A關係,另外一方面容器都屬於工具類,繼承工具類自己就是一個錯誤的作法,使用工具類最好的方式是Has-A關係(關聯)或Use-A關係(依賴)。同理,Stack類繼承Vector也是不正確的。Sun公司的工程師們也會犯這種低級錯誤,讓人唏噓不已。

 

5四、Collection和Collections的區別? 
答:Collection是一個接口,它是Set、List等容器的父接口;Collections是個一個工具類,提供了一系列的靜態方法來輔助容器操做,這些方法包括對容器的搜索、排序、線程安全化等等。

 

5五、List、Map、Set三個接口存取元素時,各有什麼特色? 
答:List以特定索引來存取元素,能夠有重複元素。Set不能存放重複元素(用對象的equals()方法來區分元素是否重複)。Map保存鍵值對(key-value pair)映射,映射關係能夠是一對一或多對一。Set和Map容器都有基於哈希存儲和排序樹的兩種實現版本,基於哈希存儲的版本理論存取時間複雜度爲O(1),而基於排序樹版本的實如今插入或刪除元素時會按照元素或元素的鍵(key)構成排序樹從而達到排序和去重的效果。

 

5六、TreeMap和TreeSet在排序時如何比較元素?Collections工具類中的sort()方法如何比較元素? 
答:TreeSet要求存放的對象所屬的類必須實現Comparable接口,該接口提供了比較元素的compareTo()方法,當插入元素時會回調該方法比較元素的大小。TreeMap要求存放的鍵值對映射的鍵必須實現Comparable接口從而根據鍵對元素進行排序。Collections工具類的sort方法有兩種重載的形式,第一種要求傳入的待排序容器中存放的對象比較實現Comparable接口以實現元素的比較;第二種不強制性的要求容器中的元素必須可比較,可是要求傳入第二個參數,參數是Comparator接口的子類型(須要重寫compare方法實現元素的比較),至關於一個臨時定義的排序規則,其實就是經過接口注入比較元素大小的算法,也是對回調模式的應用(Java中對函數式編程的支持)。 
例子1:

 

public class Student implements Comparable<Student> { private String name; // 姓名 private int age; // 年齡 public Student(String name, int age) { this.name = name; this.age = age; } @Override public String toString() { return "Student [name=" + name + ", age=" + age + "]"; } @Override public int compareTo(Student o) { return this.age - o.age; // 比較年齡(年齡的升序) } }

 

import java.util.Set; import java.util.TreeSet; class Test01 { public static void main(String[] args) { Set<Student> set = new TreeSet<>(); // Java 7的鑽石語法(構造器後面的尖括號中不須要寫類型) set.add(new Student("Hao LUO", 33)); set.add(new Student("XJ WANG", 32)); set.add(new Student("Bruce LEE", 60)); set.add(new Student("Bob YANG", 22)); for(Student stu : set) { System.out.println(stu); } // 輸出結果: // Student [name=Bob YANG, age=22] // Student [name=XJ WANG, age=32] // Student [name=Hao LUO, age=33] // Student [name=Bruce LEE, age=60] } }

 

 

例子2:

 

public class Student { private String name; // 姓名 private int age; // 年齡 public Student(String name, int age) { this.name = name; this.age = age; } /** * 獲取學生姓名 */ public String getName() { return name; } /** * 獲取學生年齡 */ public int getAge() { return age; } @Override public String toString() { return "Student [name=" + name + ", age=" + age + "]"; } }

 

 

import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; import java.util.List; class Test02 { public static void main(String[] args) { List<Student> list = new ArrayList<>(); // Java 7的鑽石語法(構造器後面的尖括號中不須要寫類型) list.add(new Student("Hao LUO", 33)); list.add(new Student("XJ WANG", 32)); list.add(new Student("Bruce LEE", 60)); list.add(new Student("Bob YANG", 22)); // 經過sort方法的第二個參數傳入一個Comparator接口對象 // 至關因而傳入一個比較對象大小的算法到sort方法中 // 因爲Java中沒有函數指針、仿函數、委託這樣的概念 // 所以要將一個算法傳入一個方法中惟一的選擇就是經過接口回調 Collections.sort(list, new Comparator<Student> () { @Override public int compare(Student o1, Student o2) { return o1.getName().compareTo(o2.getName()); // 比較學生姓名 } }); for(Student stu : list) { System.out.println(stu); } // 輸出結果: // Student [name=Bob YANG, age=22] // Student [name=Bruce LEE, age=60] // Student [name=Hao LUO, age=33] // Student [name=XJ WANG, age=32] } }

 

 

5七、Thread類的sleep()方法和對象的wait()方法均可以讓線程暫停執行,它們有什麼區別? 
答:sleep()方法(休眠)是線程類(Thread)的靜態方法,調用此方法會讓當前線程暫停執行指定的時間,將執行機會(CPU)讓給其餘線程,可是對象的鎖依然保持,所以休眠時間結束後會自動恢復(線程回到就緒狀態,請參考第66題中的線程狀態轉換圖)。wait()是Object類的方法,調用對象的wait()方法致使當前線程放棄對象的鎖(線程暫停執行),進入對象的等待池(wait pool),只有調用對象的notify()方法(或notifyAll()方法)時才能喚醒等待池中的線程進入等鎖池(lock pool),若是線程從新得到對象的鎖就能夠進入就緒狀態。

 

補充:可能很多人對什麼是進程,什麼是線程還比較模糊,對於爲何須要多線程編程也不是特別理解。簡單的說:進程是具備必定獨立功能的程序關於某個數據集合上的一次運行活動,是操做系統進行資源分配和調度的一個獨立單位;線程是進程的一個實體,是CPU調度和分派的基本單位,是比進程更小的能獨立運行的基本單位。線程的劃分尺度小於進程,這使得多線程程序的併發性高;進程在執行時一般擁有獨立的內存單元,而線程之間能夠共享內存。使用多線程的編程一般可以帶來更好的性能和用戶體驗,可是多線程的程序對於其餘程序是不友好的,由於它可能佔用了更多的CPU資源。固然,也不是線程越多,程序的性能就越好,由於線程之間的調度和切換也會浪費CPU時間。時下很時髦的Node.js就採用了單線程異步I/O的工做模式。

 

5八、線程的sleep()方法和yield()方法有什麼區別? 
答: 
① sleep()方法給其餘線程運行機會時不考慮線程的優先級,所以會給低優先級的線程以運行的機會;yield()方法只會給相同優先級或更高優先級的線程以運行的機會; 
② 線程執行sleep()方法後轉入阻塞(blocked)狀態,而執行yield()方法後轉入就緒(ready)狀態; 
③ sleep()方法聲明拋出InterruptedException,而yield()方法沒有聲明任何異常; 
④ sleep()方法比yield()方法(跟操做系統CPU調度相關)具備更好的可移植性。

 

5九、當一個線程進入一個對象的synchronized方法A以後,其它線程是否可進入此對象的synchronized方法B? 
答:不能。其它線程只能訪問該對象的非同步方法,同步方法則不能進入。由於非靜態方法上的synchronized修飾符要求執行方法時要得到對象的鎖,若是已經進入A方法說明對象鎖已經被取走,那麼試圖進入B方法的線程就只能在等鎖池(注意不是等待池哦)中等待對象的鎖。

 

60、請說出與線程同步以及線程調度相關的方法。 
答: 
- wait():使一個線程處於等待(阻塞)狀態,而且釋放所持有的對象的鎖; 
- sleep():使一個正在運行的線程處於睡眠狀態,是一個靜態方法,調用此方法要處理InterruptedException異常; 
- notify():喚醒一個處於等待狀態的線程,固然在調用此方法的時候,並不能確切的喚醒某一個等待狀態的線程,而是由JVM肯定喚醒哪一個線程,並且與優先級無關; 
- notityAll():喚醒全部處於等待狀態的線程,該方法並非將對象的鎖給全部線程,而是讓它們競爭,只有得到鎖的線程才能進入就緒狀態;

 

提示:關於Java多線程和併發編程的問題,建議你們看個人另外一篇文章《關於Java併發編程的總結和思考》

補充:Java 5經過Lock接口提供了顯式的鎖機制(explicit lock),加強了靈活性以及對線程的協調。Lock接口中定義了加鎖(lock())和解鎖(unlock())的方法,同時還提供了newCondition()方法來產生用於線程之間通訊的Condition對象;此外,Java 5還提供了信號量機制(semaphore),信號量能夠用來限制對某個共享資源進行訪問的線程的數量。在對資源進行訪問以前,線程必須獲得信號量的許可(調用Semaphore對象的acquire()方法);在完成對資源的訪問後,線程必須向信號量歸還許可(調用Semaphore對象的release()方法)。

 

下面的例子演示了100個線程同時向一個銀行帳戶中存入1元錢,在沒有使用同步機制和使用同步機制狀況下的執行狀況。

 

  • 銀行帳戶類:

 

/** * 銀行帳戶 * @author 駱昊 * */ public class Account { private double balance; // 帳戶餘額 /** * 存款 * @param money 存入金額 */ public void deposit(double money) { double newBalance = balance + money; try { Thread.sleep(10); // 模擬此業務須要一段處理時間 } catch(InterruptedException ex) { ex.printStackTrace(); } balance = newBalance; } /** * 得到帳戶餘額 */ public double getBalance() { return balance; } }

 

  • 存錢線程類:

 

/** * 存錢線程 * @author 駱昊 * */ public class AddMoneyThread implements Runnable { private Account account; // 存入帳戶 private double money; // 存入金額 public AddMoneyThread(Account account, double money) { this.account = account; this.money = money; } @Override public void run() { account.deposit(money); } }

 

 

  • 測試類:

 

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Test01 { public static void main(String[] args) { Account account = new Account(); ExecutorService service = Executors.newFixedThreadPool(100); for(int i = 1; i <= 100; i++) { service.execute(new AddMoneyThread(account, 1)); } service.shutdown(); while(!service.isTerminated()) {} System.out.println("帳戶餘額: " + account.getBalance()); } }

 

 

在沒有同步的狀況下,執行結果一般是顯示帳戶餘額在10元如下,出現這種情況的緣由是,當一個線程A試圖存入1元的時候,另一個線程B也可以進入存款的方法中,線程B讀取到的帳戶餘額仍然是線程A存入1元錢以前的帳戶餘額,所以也是在原來的餘額0上面作了加1元的操做,同理線程C也會作相似的事情,因此最後100個線程執行結束時,原本指望帳戶餘額爲100元,但實際獲得的一般在10元如下(極可能是1元哦)。解決這個問題的辦法就是同步,當一個線程對銀行帳戶存錢時,須要將此帳戶鎖定,待其操做完成後才容許其餘的線程進行操做,代碼有以下幾種調整方案:

 

  • 在銀行帳戶的存款(deposit)方法上同步(synchronized)關鍵字

 

/** * 銀行帳戶 * @author 駱昊 * */ public class Account { private double balance; // 帳戶餘額 /** * 存款 * @param money 存入金額 */ public synchronized void deposit(double money) { double newBalance = balance + money; try { Thread.sleep(10); // 模擬此業務須要一段處理時間 } catch(InterruptedException ex) { ex.printStackTrace(); } balance = newBalance; } /** * 得到帳戶餘額 */ public double getBalance() { return balance; } }

 

  • 在線程調用存款方法時對銀行帳戶進行同步

 

/** * 存錢線程 * @author 駱昊 * */ public class AddMoneyThread implements Runnable { private Account account; // 存入帳戶 private double money; // 存入金額 public AddMoneyThread(Account account, double money) { this.account = account; this.money = money; } @Override public void run() { synchronized (account) { account.deposit(money); } } }

 

  • 經過Java 5顯示的鎖機制,爲每一個銀行帳戶建立一個鎖對象,在存款操做進行加鎖和解鎖的操做

 

import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; /** * 銀行帳戶 * * @author 駱昊 * */ public class Account { private Lock accountLock = new ReentrantLock(); private double balance; // 帳戶餘額 /** * 存款 * * @param money * 存入金額 */ public void deposit(double money) { accountLock.lock(); try { double newBalance = balance + money; try { Thread.sleep(10); // 模擬此業務須要一段處理時間 } catch (InterruptedException ex) { ex.printStackTrace(); } balance = newBalance; } finally { accountLock.unlock(); } } /** * 得到帳戶餘額 */ public double getBalance() { return balance; } }

 

按照上述三種方式對代碼進行修改後,重寫執行測試代碼Test01,將看到最終的帳戶餘額爲100元。固然也能夠使用Semaphore或CountdownLatch來實現同步。

 

6一、編寫多線程程序有幾種實現方式? 
答: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); } }

 

 

6二、synchronized關鍵字的用法? 
答:synchronized關鍵字能夠將對象或者方法標記爲同步,以實現對對象和方法的互斥訪問,能夠用synchronized(對象) { … }定義同步代碼塊,或者在聲明方法時將synchronized做爲方法的修飾符。在第60題的例子中已經展現了synchronized關鍵字的用法。

 

6三、舉例說明同步和異步。 
答:若是系統中存在臨界資源(資源數量少於競爭資源的線程數量的資源),例如正在寫的數據之後可能被另外一個線程讀到,或者正在讀的數據可能已經被另外一個線程寫過了,那麼這些數據就必須進行同步存取(數據庫操做中的排他鎖就是最好的例子)。當應用程序在對象上調用了一個須要花費很長時間來執行的方法,而且不但願讓程序等待方法的返回時,就應該使用異步編程,在不少狀況下采用異步途徑每每更有效率。事實上,所謂的同步就是指阻塞式操做,而異步就是非阻塞式操做。

 

6四、啓動一個線程是調用run()仍是start()方法? 
答:啓動一個線程是調用start()方法,使線程所表明的虛擬處理機處於可運行狀態,這意味着它能夠由JVM 調度並執行,這並不意味着線程就會當即運行。run()方法是線程啓動後要進行回調(callback)的方法。

 

6五、什麼是線程池(thread pool)? 
答:在面向對象編程中,建立和銷燬對象是很費時間的,由於建立一個對象要獲取內存資源或者其它更多資源。在Java中更是如此,虛擬機將試圖跟蹤每個對象,以便可以在對象銷燬後進行垃圾回收。因此提升服務程序效率的一個手段就是儘量減小建立和銷燬對象的次數,特別是一些很耗資源的對象建立和銷燬,這就是」池化資源」技術產生的緣由。線程池顧名思義就是事先建立若干個可執行的線程放入一個池(容器)中,須要的時候從池中獲取線程不用自行建立,使用完畢不須要銷燬線程而是放回池中,從而減小建立和銷燬線程對象的開銷。 
Java 5+中的Executor接口定義一個執行線程的工具。它的子類型即線程池接口是ExecutorService。要配置一個線程池是比較複雜的,尤爲是對於線程池的原理不是很清楚的狀況下,所以在工具類Executors面提供了一些靜態工廠方法,生成一些經常使用的線程池,以下所示: 
- newSingleThreadExecutor:建立一個單線程的線程池。這個線程池只有一個線程在工做,也就是至關於單線程串行執行全部任務。若是這個惟一的線程由於異常結束,那麼會有一個新的線程來替代它。此線程池保證全部任務的執行順序按照任務的提交順序執行。 
- newFixedThreadPool:建立固定大小的線程池。每次提交一個任務就建立一個線程,直到線程達到線程池的最大大小。線程池的大小一旦達到最大值就會保持不變,若是某個線程由於執行異常而結束,那麼線程池會補充一個新線程。 
- newCachedThreadPool:建立一個可緩存的線程池。若是線程池的大小超過了處理任務所須要的線程,那麼就會回收部分空閒(60秒不執行任務)的線程,當任務數增長時,此線程池又能夠智能的添加新線程來處理任務。此線程池不會對線程池大小作限制,線程池大小徹底依賴於操做系統(或者說JVM)可以建立的最大線程大小。 
- newScheduledThreadPool:建立一個大小無限的線程池。此線程池支持定時以及週期性執行任務的需求。 
- newSingleThreadExecutor:建立一個單線程的線程池。此線程池支持定時以及週期性執行任務的需求。

 

第60題的例子中演示了經過Executors工具類建立線程池並使用線程池執行線程的代碼。若是但願在服務器上使用線程池,強烈建議使用newFixedThreadPool方法來建立線程池,這樣能得到更好的性能。

 

6六、線程的基本狀態以及狀態之間的關係? 
答: 
這裏寫圖片描述

 

說明:其中Running表示運行狀態,Runnable表示就緒狀態(萬事俱備,只欠CPU),Blocked表示阻塞狀態,阻塞狀態又有多種狀況,多是由於調用wait()方法進入等待池,也多是執行同步方法或同步代碼塊進入等鎖池,或者是調用了sleep()方法或join()方法等待休眠或其餘線程結束,或是由於發生了I/O中斷。

 

6七、簡述synchronized 和java.util.concurrent.locks.Lock的異同? 
答:Lock是Java 5之後引入的新的API,和關鍵字synchronized相比主要相同點:Lock 能完成synchronized所實現的全部功能;主要不一樣點:Lock有比synchronized更精確的線程語義和更好的性能,並且不強制性的要求必定要得到鎖。synchronized會自動釋放鎖,而Lock必定要求程序員手工釋放,而且最好在finally 塊中釋放(這是釋放外部資源的最好的地方)。

 

6八、Java中如何實現序列化,有什麼意義? 
答:序列化就是一種用來處理對象流的機制,所謂對象流也就是將對象的內容進行流化。能夠對流化後的對象進行讀寫操做,也可將流化後的對象傳輸於網絡之間。序列化是爲了解決對象流讀寫操做時可能引起的問題(若是不進行序列化可能會存在數據亂序的問題)。 
要實現序列化,須要讓一個類實現Serializable接口,該接口是一個標識性接口,標註該類對象是可被序列化的,而後使用一個輸出流來構造一個對象輸出流並經過writeObject(Object)方法就能夠將實現對象寫出(即保存其狀態);若是須要反序列化則能夠用一個輸入流創建對象輸入流,而後經過readObject方法從流中讀取對象。序列化除了可以實現對象的持久化以外,還可以用於對象的深度克隆(能夠參考第29題)。

 

6九、Java中有幾種類型的流? 
答:字節流和字符流。字節流繼承於InputStream、OutputStream,字符流繼承於Reader、Writer。在java.io 包中還有許多其餘的流,主要是爲了提升性能和使用方便。關於Java的I/O須要注意的有兩點:一是兩種對稱性(輸入和輸出的對稱性,字節和字符的對稱性);二是兩種設計模式(適配器模式和裝潢模式)。另外Java中的流不一樣於C#的是它只有一個維度一個方向。

 

面試題 - 編程實現文件拷貝。(這個題目在筆試的時候常常出現,下面的代碼給出了兩種實現方案)

 

import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.nio.ByteBuffer; import java.nio.channels.FileChannel; public final class MyUtil { private MyUtil() { throw new AssertionError(); } public static void fileCopy(String source, String target) throws IOException { try (InputStream in = new FileInputStream(source)) { try (OutputStream out = new FileOutputStream(target)) { byte[] buffer = new byte[4096]; int bytesToRead; while((bytesToRead = in.read(buffer)) != -1) { out.write(buffer, 0, bytesToRead); } } } } public static void fileCopyNIO(String source, String target) throws IOException { try (FileInputStream in = new FileInputStream(source)) { try (FileOutputStream out = new FileOutputStream(target)) { FileChannel inChannel = in.getChannel(); FileChannel outChannel = out.getChannel(); ByteBuffer buffer = ByteBuffer.allocate(4096); while(inChannel.read(buffer) != -1) { buffer.flip(); outChannel.write(buffer); buffer.clear(); } } } } }

 

注意:上面用到Java 7的TWR,使用TWR後能夠不用在finally中釋放外部資源 ,從而讓代碼更加優雅。

 

70、寫一個方法,輸入一個文件名和一個字符串,統計這個字符串在這個文件中出現的次數。 
答:代碼以下:

 

import java.io.BufferedReader; import java.io.FileReader; public final class MyUtil { // 工具類中的方法都是靜態方式訪問的所以將構造器私有不容許建立對象(絕對好習慣) private MyUtil() { throw new AssertionError(); } /** * 統計給定文件中給定字符串的出現次數 * * @param filename 文件名 * @param word 字符串 * @return 字符串在文件中出現的次數 */ public static int countWordInFile(String filename, String word) { int counter = 0; try (FileReader fr = new FileReader(filename)) { try (BufferedReader br = new BufferedReader(fr)) { String line = null; while ((line = br.readLine()) != null) { int index = -1; while (line.length() >= word.length() && (index = line.indexOf(word)) >= 0) { counter++; line = line.substring(index + word.length()); } } } } catch (Exception ex) { ex.printStackTrace(); } return counter; } }

 

7一、如何用Java代碼列出一個目錄下全部的文件? 
答: 
若是隻要求列出當前文件夾下的文件,代碼以下所示:

 

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

 

 

 

若是須要對文件夾繼續展開,代碼以下所示:

 

import java.io.File;

class Test12 {

    public static void main(String[] args) { showDirectory(new File("/Users/Hao/Downloads")); } public static void showDirectory(File f) { _walkDirectory(f, 0); } private static void _walkDirectory(File f, int level) { if(f.isDirectory()) { for(File temp : f.listFiles()) { _walkDirectory(temp, level + 1); } } else { for(int i = 0; i < level - 1; i++) { System.out.print("\t"); } System.out.println(f.getName()); } } }

 

在Java 7中能夠使用NIO.2的API來作一樣的事情,代碼以下所示:

 

class ShowFileTest {

    public static void main(String[] args) throws IOException { Path initPath = Paths.get("/Users/Hao/Downloads"); Files.walkFileTree(initPath, new SimpleFileVisitor<Path>() { @Override public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException { System.out.println(file.getFileName().toString()); return FileVisitResult.CONTINUE; } }); } }

 

7二、用Java的套接字編程實現一個多線程的回顯(echo)服務器。 
答:

 

import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.io.PrintWriter; import java.net.ServerSocket; import java.net.Socket; public class EchoServer { private static final int ECHO_SERVER_PORT = 6789; public static void main(String[] args) { try(ServerSocket server = new ServerSocket(ECHO_SERVER_PORT)) { System.out.println("服務器已經啓動..."); while(true) { Socket client = server.accept(); new Thread(new ClientHandler(client)).start(); } } catch (IOException e) { e.printStackTrace(); } } private static class ClientHandler implements Runnable { private Socket client; public ClientHandler(Socket client) { this.client = client; } @Override public void run() { try(BufferedReader br = new BufferedReader(new InputStreamReader(client.getInputStream())); PrintWriter pw = new PrintWriter(client.getOutputStream())) { String msg = br.readLine(); System.out.println("收到" + client.getInetAddress() + "發送的: " + msg); pw.println(msg); pw.flush(); } catch(Exception ex) { ex.printStackTrace(); } finally { try { client.close(); } catch (IOException e) { e.printStackTrace(); } } } } }

 

 

 

注意:上面的代碼使用了Java 7的TWR語法,因爲不少外部資源類都間接的實現了AutoCloseable接口(單方法回調接口),所以能夠利用TWR語法在try結束的時候經過回調的方式自動調用外部資源類的close()方法,避免書寫冗長的finally代碼塊。此外,上面的代碼用一個靜態內部類實現線程的功能,使用多線程能夠避免一個用戶I/O操做所產生的中斷影響其餘用戶對服務器的訪問,簡單的說就是一個用戶的輸入操做不會形成其餘用戶的阻塞。固然,上面的代碼使用線程池能夠得到更好的性能,由於頻繁的建立和銷燬線程所形成的開銷也是不可忽視的。

 

下面是一段回顯客戶端測試代碼:

 

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

 

 

若是但願用NIO的多路複用套接字實現服務器,代碼以下所示。NIO的操做雖然帶來了更好的性能,可是有些操做是比較底層的,對於初學者來講仍是有些難於理解。

 

import java.io.IOException; import java.net.InetSocketAddress; import java.nio.ByteBuffer; import java.nio.CharBuffer; import java.nio.channels.SelectionKey; import java.nio.channels.Selector; import java.nio.channels.ServerSocketChannel; import java.nio.channels.SocketChannel; import java.util.Iterator; public class EchoServerNIO { private static final int ECHO_SERVER_PORT = 6789; private static final int ECHO_SERVER_TIMEOUT = 5000; private static final int BUFFER_SIZE = 1024; private static ServerSocketChannel serverChannel = null; private static Selector selector = null; // 多路複用選擇器 private static ByteBuffer buffer = null; // 緩衝區 public static void main(String[] args) { init(); listen(); } private static void init() { try { serverChannel = ServerSocketChannel.open(); buffer = ByteBuffer.allocate(BUFFER_SIZE); serverChannel.socket().bind(new InetSocketAddress(ECHO_SERVER_PORT)); serverChannel.configureBlocking(false); selector = Selector.open(); serverChannel.register(selector, SelectionKey.OP_ACCEPT); } catch (Exception e) { throw new RuntimeException(e); } } private static void listen() { while (true) { try { if (selector.select(ECHO_SERVER_TIMEOUT) != 0) { Iterator<SelectionKey> it = selector.selectedKeys().iterator(); while (it.hasNext()) { SelectionKey key = it.next(); it.remove(); handleKey(key); } } } catch (Exception e) { e.printStackTrace(); } } } private static void handleKey(SelectionKey key) throws IOException { SocketChannel channel = null; try { if (key.isAcceptable()) { ServerSocketChannel serverChannel = (ServerSocketChannel) key.channel(); channel = serverChannel.accept(); channel.configureBlocking(false); channel.register(selector, SelectionKey.OP_READ); } else if (key.isReadable()) { channel = (SocketChannel) key.channel(); buffer.clear(); if (channel.read(buffer) > 0) { buffer.flip(); CharBuffer charBuffer = CharsetHelper.decode(buffer); String msg = charBuffer.toString(); System.out.println("收到" + channel.getRemoteAddress() + "的消息:" + msg); channel.write(CharsetHelper.encode(CharBuffer.wrap(msg))); } else { channel.close(); } } } catch (Exception e) { e.printStackTrace(); if (channel != null) { channel.close(); } } } }

 

 

 

import java.nio.ByteBuffer; import java.nio.CharBuffer; import java.nio.charset.CharacterCodingException; import java.nio.charset.Charset; import java.nio.charset.CharsetDecoder; import java.nio.charset.CharsetEncoder; public final class CharsetHelper { private static final String UTF_8 = "UTF-8"; private static CharsetEncoder encoder = Charset.forName(UTF_8).newEncoder(); private static CharsetDecoder decoder = Charset.forName(UTF_8).newDecoder(); private CharsetHelper() { } public static ByteBuffer encode(CharBuffer in) throws CharacterCodingException{ return encoder.encode(in); } public static CharBuffer decode(ByteBuffer in) throws CharacterCodingException{ return decoder.decode(in); } }

 

7三、XML文檔定義有幾種形式?它們之間有何本質區別?解析XML文檔有哪幾種方式? 
答:XML文檔定義分爲DTD和Schema兩種形式,兩者都是對XML語法的約束,其本質區別在於Schema自己也是一個XML文件,能夠被XML解析器解析,並且能夠爲XML承載的數據定義類型,約束能力較之DTD更強大。對XML的解析主要有DOM(文檔對象模型,Document Object Model)、SAX(Simple API for XML)和StAX(Java 6中引入的新的解析XML的方式,Streaming API for XML),其中DOM處理大型文件時其性能降低的很是厲害,這個問題是由DOM樹結構佔用的內存較多形成的,並且DOM解析方式必須在解析文件以前把整個文檔裝入內存,適合對XML的隨機訪問(典型的用空間換取時間的策略);SAX是事件驅動型的XML解析方式,它順序讀取XML文件,不須要一次所有裝載整個文件。當遇到像文件開頭,文檔結束,或者標籤開頭與標籤結束時,它會觸發一個事件,用戶經過事件回調代碼來處理XML文件,適合對XML的順序訪問;顧名思義,StAX把重點放在流上,實際上StAX與其餘解析方式的本質區別就在於應用程序可以把XML做爲一個事件流來處理。將XML做爲一組事件來處理的想法並不新穎(SAX就是這樣作的),但不一樣之處在於StAX容許應用程序代碼把這些事件逐個拉出來,而不用提供在解析器方便時從解析器中接收事件的處理程序。

 

7四、你在項目中哪些地方用到了XML? 
答:XML的主要做用有兩個方面:數據交換和信息配置。在作數據交換時,XML將數據用標籤組裝成起來,而後壓縮打包加密後經過網絡傳送給接收者,接收解密與解壓縮後再從XML文件中還原相關信息進行處理,XML曾經是異構系統間交換數據的事實標準,但此項功能幾乎已經被JSON(JavaScript Object Notation)取而代之。固然,目前不少軟件仍然使用XML來存儲配置信息,咱們在不少項目中一般也會將做爲配置信息的硬代碼寫在XML文件中,Java的不少框架也是這麼作的,並且這些框架都選擇了dom4j做爲處理XML的工具,由於Sun公司的官方API實在不怎麼好用。

 

補充:如今有不少時髦的軟件(如Sublime)已經開始將配置文件書寫成JSON格式,咱們已經強烈的感覺到XML的另外一項功能也將逐漸被業界拋棄。

 

7五、闡述JDBC操做數據庫的步驟。 
答:下面的代碼以鏈接本機的Oracle數據庫爲例,演示JDBC操做數據庫的步驟。

 

  • 加載驅動。

 

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

 

  • 建立鏈接。

 

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

 

  • 建立語句。

 

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

 

  • 執行語句。

 

 ResultSet rs = ps.executeQuery();

 

  • 1

 

  • 處理結果。

 

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

 

  • 關閉資源。

 

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

 

提示:關閉外部資源的順序應該和打開的順序相反,也就是說先關閉ResultSet、再關閉Statement、在關閉Connection。上面的代碼只關閉了Connection(鏈接),雖然一般狀況下在關閉鏈接時,鏈接上建立的語句和打開的遊標也會關閉,但不能保證老是如此,所以應該按照剛纔說的順序分別關閉。此外,第一步加載驅動在JDBC 4.0中是能夠省略的(自動從類路徑中加載驅動),可是咱們建議保留。

 

7六、Statement和PreparedStatement有什麼區別?哪一個性能更好? 
答:與Statement相比,①PreparedStatement接口表明預編譯的語句,它主要的優點在於能夠減小SQL的編譯錯誤並增長SQL的安全性(減小SQL注射攻擊的可能性);②PreparedStatement中的SQL語句是能夠帶參數的,避免了用字符串鏈接拼接SQL語句的麻煩和不安全;③當批量處理SQL或頻繁執行相同的查詢時,PreparedStatement有明顯的性能上的優點,因爲數據庫能夠將編譯優化後的SQL語句緩存起來,下次執行相同結構的語句時就會很快(不用再次編譯和生成執行計劃)。

 

補充:爲了提供對存儲過程的調用,JDBC API中還提供了CallableStatement接口。存儲過程(Stored Procedure)是數據庫中一組爲了完成特定功能的SQL語句的集合,經編譯後存儲在數據庫中,用戶經過指定存儲過程的名字並給出參數(若是該存儲過程帶有參數)來執行它。雖然調用存儲過程會在網絡開銷、安全性、性能上得到不少好處,可是存在若是底層數據庫發生遷移時就會有不少麻煩,由於每種數據庫的存儲過程在書寫上存在很多的差異。

 

7七、使用JDBC操做數據庫時,如何提高讀取數據的性能?如何提高更新數據的性能? 
答:要提高讀取數據的性能,能夠指定經過結果集(ResultSet)對象的setFetchSize()方法指定每次抓取的記錄數(典型的空間換時間策略);要提高更新數據的性能能夠使用PreparedStatement語句構建批處理,將若干SQL語句置於一個批處理中執行。

 

7八、在進行數據庫編程時,鏈接池有什麼做用? 
答:因爲建立鏈接和釋放鏈接都有很大的開銷(尤爲是數據庫服務器不在本地時,每次創建鏈接都須要進行TCP的三次握手,釋放鏈接須要進行TCP四次握手,形成的開銷是不可忽視的),爲了提高系統訪問數據庫的性能,能夠事先建立若干鏈接置於鏈接池中,須要時直接從鏈接池獲取,使用結束時歸還鏈接池而沒必要關閉鏈接,從而避免頻繁建立和釋放鏈接所形成的開銷,這是典型的用空間換取時間的策略(浪費了空間存儲鏈接,但節省了建立和釋放鏈接的時間)。池化技術在Java開發中是很常見的,在使用線程時建立線程池的道理與此相同。基於Java的開源數據庫鏈接池主要有:C3P0ProxoolDBCPBoneCPDruid等。

 

補充:在計算機系統中時間和空間是不可調和的矛盾,理解這一點對設計知足性能要求的算法是相當重要的。大型網站性能優化的一個關鍵就是使用緩存,而緩存跟上面講的鏈接池道理很是相似,也是使用空間換時間的策略。能夠將熱點數據置於緩存中,當用戶查詢這些數據時能夠直接從緩存中獲得,這不管如何也快過去數據庫中查詢。固然,緩存的置換策略等也會對系統性能產生重要影響,對於這個問題的討論已經超出了這裏要闡述的範圍。

 

7九、什麼是DAO模式? 
答:DAO(Data Access Object)顧名思義是一個爲數據庫或其餘持久化機制提供了抽象接口的對象,在不暴露底層持久化方案實現細節的前提下提供了各類數據訪問操做。在實際的開發中,應該將全部對數據源的訪問操做進行抽象化後封裝在一個公共API中。用程序設計語言來講,就是創建一個接口,接口中定義了此應用程序中將會用到的全部事務方法。在這個應用程序中,當須要和數據源進行交互的時候則使用這個接口,而且編寫一個單獨的類來實現這個接口,在邏輯上該類對應一個特定的數據存儲。DAO模式實際上包含了兩個模式,一是Data Accessor(數據訪問器),二是Data Object(數據對象),前者要解決如何訪問數據的問題,然後者要解決的是如何用對象封裝數據。

 

80、事務的ACID是指什麼? 
答: 
- 原子性(Atomic):事務中各項操做,要麼全作要麼全不作,任何一項操做的失敗都會致使整個事務的失敗; 
- 一致性(Consistent):事務結束後系統狀態是一致的; 
- 隔離性(Isolated):併發執行的事務彼此沒法看到對方的中間狀態; 
- 持久性(Durable):事務完成後所作的改動都會被持久化,即便發生災難性的失敗。經過日誌和同步備份能夠在故障發生後重建數據。

 

補充:關於事務,在面試中被問到的機率是很高的,能夠問的問題也是不少的。首先須要知道的是,只有存在併發數據訪問時才須要事務。當多個事務訪問同一數據時,可能會存在5類問題,包括3類數據讀取問題(髒讀、不可重複讀和幻讀)和2類數據更新問題(第1類丟失更新和第2類丟失更新)。

 

髒讀(Dirty Read):A事務讀取B事務還沒有提交的數據並在此基礎上操做,而B事務執行回滾,那麼A讀取到的數據就是髒數據。

 

時間 轉帳事務A 取款事務B
T1   開始事務
T2 開始事務  
T3   查詢帳戶餘額爲1000元
T4   取出500元餘額修改成500元
T5 查詢帳戶餘額爲500元(髒讀)  
T6   撤銷事務餘額恢復爲1000元
T7 匯入100元把餘額修改成600元  
T8 提交事務  

 


 

不可重複讀(Unrepeatable Read):事務A從新讀取前面讀取過的數據,發現該數據已經被另外一個已提交的事務B修改過了。

 

時間 轉帳事務A 取款事務B
T1   開始事務
T2 開始事務  
T3   查詢帳戶餘額爲1000元
T4 查詢帳戶餘額爲1000元  
T5   取出100元修改餘額爲900元
T6   提交事務
T7 查詢帳戶餘額爲900元(不可重複讀)  

 


 

幻讀(Phantom Read):事務A從新執行一個查詢,返回一系列符合查詢條件的行,發現其中插入了被事務B提交的行。

 

時間 統計金額事務A 轉帳事務B
T1   開始事務
T2 開始事務  
T3 統計總存款爲10000元  
T4   新增一個存款帳戶存入100元
T5   提交事務
T6 再次統計總存款爲10100元(幻讀)  

 


 

第1類丟失更新:事務A撤銷時,把已經提交的事務B的更新數據覆蓋了。

 

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

 


 

第2類丟失更新:事務A覆蓋事務B已經提交的數據,形成事務B所作的操做丟失。

 

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

 


 

數據併發訪問所產生的問題,在有些場景下多是容許的,可是有些場景下可能就是致命的,數據庫一般會經過鎖機制來解決數據併發訪問問題,按鎖定對象不一樣能夠分爲表級鎖和行級鎖;按併發事務鎖定關係能夠分爲共享鎖和獨佔鎖,具體的內容你們能夠自行查閱資料進行了解。 
直接使用鎖是很是麻煩的,爲此數據庫爲用戶提供了自動鎖機制,只要用戶指定會話的事務隔離級別,數據庫就會經過分析SQL語句而後爲事務訪問的資源加上合適的鎖,此外,數據庫還會維護這些鎖經過各類手段提升系統的性能,這些對用戶來講都是透明的(就是說你不用理解,事實上我確實也不知道)。ANSI/ISO SQL 92標準定義了4個等級的事務隔離級別,以下表所示:

 

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

 

須要說明的是,事務隔離級別和數據訪問的併發性是對立的,事務隔離級別越高併發性就越差。因此要根據具體的應用來肯定合適的事務隔離級別,這個地方沒有萬能的原則。

 

8一、JDBC中如何進行事務處理? 
答:Connection提供了事務處理的方法,經過調用setAutoCommit(false)能夠設置手動提交事務;當事務完成後用commit()顯式提交事務;若是在事務處理過程當中發生異常則經過rollback()進行事務回滾。除此以外,從JDBC 3.0中還引入了Savepoint(保存點)的概念,容許經過代碼設置保存點並讓事務回滾到指定的保存點。 
這裏寫圖片描述

 

8二、JDBC可否處理Blob和Clob? 
答: Blob是指二進制大對象(Binary Large Object),而Clob是指大字符對象(Character Large Objec),所以其中Blob是爲存儲大的二進制數據而設計的,而Clob是爲存儲大的文本數據而設計的。JDBC的PreparedStatement和ResultSet都提供了相應的方法來支持Blob和Clob操做。下面的代碼展現瞭如何使用JDBC操做LOB: 
下面以MySQL數據庫爲例,建立一個張有三個字段的用戶表,包括編號(id)、姓名(name)和照片(photo),建表語句以下:

 

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

 

 

 

下面的Java代碼向數據庫中插入一條記錄:

 

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

 

 

 

8三、簡述正則表達式及其用途。 
答:在編寫處理字符串的程序時,常常會有查找符合某些複雜規則的字符串的須要。正則表達式就是用於描述這些規則的工具。換句話說,正則表達式就是記錄文本規則的代碼。

 

說明:計算機誕生初期處理的信息幾乎都是數值,可是時過境遷,今天咱們使用計算機處理的信息更多的時候不是數值而是字符串,正則表達式就是在進行字符串匹配和處理的時候最爲強大的工具,絕大多數語言都提供了對正則表達式的支持。

 

8四、Java中是如何支持正則表達式操做的? 
答:Java中的String類提供了支持正則表達式操做的方法,包括:matches()、replaceAll()、replaceFirst()、split()。此外,Java中能夠用Pattern類表示正則表達式對象,它提供了豐富的API進行各類正則表達式操做,請參考下面面試題的代碼。

 

面試題: - 若是要從字符串中截取第一個英文左括號以前的字符串,例如:北京市(朝陽區)(西城區)(海淀區),截取結果爲:北京市,那麼正則表達式怎麼寫?

 

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

 

說明:上面的正則表達式中使用了懶惰匹配和前瞻,若是不清楚這些內容,推薦讀一下網上頗有名的《正則表達式30分鐘入門教程》

 

8五、得到一個類的類對象有哪些方式? 
答: 
- 方法1:類型.class,例如:String.class 
- 方法2:對象.getClass(),例如:"hello".getClass() 
- 方法3:Class.forName(),例如:Class.forName("java.lang.String")

 

8六、如何經過反射建立對象? 
答: 
- 方法1:經過類對象調用newInstance()方法,例如:String.class.newInstance() 
- 方法2:經過類對象的getConstructor()或getDeclaredConstructor()方法得到構造器(Constructor)對象並調用其newInstance()方法建立對象,例如:String.class.getConstructor(String.class).newInstance("Hello");

 

8七、如何經過反射獲取和設置對象私有字段的值? 
答:能夠經過類對象的getDeclaredField()方法字段(Field)對象,而後再經過字段對象的setAccessible(true)將其設置爲能夠訪問,接下來就能夠經過get/set方法來獲取/設置字段的值了。下面的代碼實現了一個反射的工具類,其中的兩個靜態方法分別用於獲取和設置私有字段的值,字段能夠是基本類型也能夠是對象類型且支持多級對象操做,例如ReflectionUtil.get(dog, "owner.car.engine.id");能夠得到dog對象的主人的汽車的引擎的ID號。

 

import java.lang.reflect.Constructor; import java.lang.reflect.Field; import java.lang.reflect.Modifier; import java.util.ArrayList; import java.util.List; /** * 反射工具類 * @author 駱昊 * */ public class ReflectionUtil { private ReflectionUtil() { throw new AssertionError(); } /** * 經過反射取對象指定字段(屬性)的值 * @param target 目標對象 * @param fieldName 字段的名字 * @throws 若是取不到對象指定字段的值則拋出異常 * @return 字段的值 */ public static Object getValue(Object target, String fieldName) { Class<?> clazz = target.getClass(); String[] fs = fieldName.split("\\."); try { for(int i = 0; i < fs.length - 1; i++) { Field f = clazz.getDeclaredField(fs[i]); f.setAccessible(true); target = f.get(target); clazz = target.getClass(); } Field f = clazz.getDeclaredField(fs[fs.length - 1]); f.setAccessible(true); return f.get(target); } catch (Exception e) { throw new RuntimeException(e); } } /** * 經過反射給對象的指定字段賦值 * @param target 目標對象 * @param fieldName 字段的名稱 * @param value 值 */ public static void setValue(Object target, String fieldName, Object value) { Class<?> clazz = target.getClass(); String[] fs = fieldName.split("\\."); try { for(int i = 0; i < fs.length - 1; i++) { Field f = clazz.getDeclaredField(fs[i]); f.setAccessible(true); Object val = f.get(target); if(val == null) { Constructor<?> c = f.getType().getDeclaredConstructor(); c.setAccessible(true); val = c.newInstance(); f.set(target, val); } target = val; clazz = target.getClass(); } Field f = clazz.getDeclaredField(fs[fs.length - 1]); f.setAccessible(true); f.set(target, value); } catch (Exception e) { throw new RuntimeException(e); } } }

 

8八、如何經過反射調用對象的方法? 
答:請看下面的代碼:

 

import java.lang.reflect.Method;

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

 

 

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

 

這裏寫圖片描述 
這裏寫圖片描述

 

90、簡述一下你瞭解的設計模式。 
答:所謂設計模式,就是一套被反覆使用的代碼設計經驗的總結(情境中一個問題通過證明的一個解決方案)。使用設計模式是爲了可重用代碼、讓代碼更容易被他人理解、保證代碼可靠性。設計模式令人們能夠更加簡單方便的複用成功的設計和體系結構。將已證明的技術表述成設計模式也會使新系統開發者更加容易理解其設計思路。 
在GoF的《Design Patterns: Elements of Reusable Object-Oriented Software》中給出了三類(建立型[對類的實例化過程的抽象化]、結構型[描述如何將類或對象結合在一塊兒造成更大的結構]、行爲型[對在不一樣的對象之間劃分責任和算法的抽象化])共23種設計模式,包括:Abstract Factory(抽象工廠模式),Builder(建造者模式),Factory Method(工廠方法模式),Prototype(原始模型模式),Singleton(單例模式);Facade(門面模式),Adapter(適配器模式),Bridge(橋樑模式),Composite(合成模式),Decorator(裝飾模式),Flyweight(享元模式),Proxy(代理模式);Command(命令模式),Interpreter(解釋器模式),Visitor(訪問者模式),Iterator(迭代子模式),Mediator(調停者模式),Memento(備忘錄模式),Observer(觀察者模式),State(狀態模式),Strategy(策略模式),Template Method(模板方法模式), Chain Of Responsibility(責任鏈模式)。 
面試被問到關於設計模式的知識時,能夠揀最經常使用的做答,例如: 
- 工廠模式:工廠類能夠根據條件生成不一樣的子類實例,這些子類有一個公共的抽象父類而且實現了相同的方法,可是這些方法針對不一樣的數據進行了不一樣的操做(多態方法)。當獲得子類的實例後,開發人員能夠調用基類中的方法而沒必要考慮到底返回的是哪個子類的實例。 
- 代理模式:給一個對象提供一個代理對象,並由代理對象控制原對象的引用。實際開發中,按照使用目的的不一樣,代理能夠分爲:遠程代理、虛擬代理、保護代理、Cache代理、防火牆代理、同步化代理、智能引用代理。 
- 適配器模式:把一個類的接口變換成客戶端所期待的另外一種接口,從而使本來因接口不匹配而沒法在一塊兒使用的類可以一塊兒工做。 
- 模板方法模式:提供一個抽象類,將部分邏輯以具體方法或構造器的形式實現,而後聲明一些抽象方法來迫使子類實現剩餘的邏輯。不一樣的子類能夠以不一樣的方式實現這些抽象方法(多態實現),從而實現不一樣的業務邏輯。 
除此以外,還能夠講講上面提到的門面模式、橋樑模式、單例模式、裝潢模式(Collections工具類和I/O系統中都使用裝潢模式)等,反正基本原則就是揀本身最熟悉的、用得最多的做答,以避免言多必失。

 

9一、用Java寫一個單例類。 
答: 
- 餓漢式單例

 

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

 

 

  • 懶漢式單例

 

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

 

注意:實現一個單例有兩點注意事項,①將構造器私有,不容許外界經過構造器建立對象;②經過公開的靜態方法向外界返回類的惟一實例。這裏有一個問題能夠思考:Spring的IoC容器能夠爲普通的類建立單例,它是怎麼作到的呢?

 

9二、什麼是UML? 
答:UML是統一建模語言(Unified Modeling Language)的縮寫,它發表於1997年,綜合了當時已經存在的面向對象的建模語言、方法和過程,是一個支持模型化和軟件系統開發的圖形化語言,爲軟件開發的全部階段提供模型化和可視化支持。使用UML能夠幫助溝通與交流,輔助應用設計和文檔的生成,還可以闡釋系統的結構和行爲。

 

9三、UML中有哪些經常使用的圖? 
答:UML定義了多種圖形化的符號來描述軟件系統部分或所有的靜態結構和動態結構,包括:用例圖(use case diagram)、類圖(class diagram)、時序圖(sequence diagram)、協做圖(collaboration diagram)、狀態圖(statechart diagram)、活動圖(activity diagram)、構件圖(component diagram)、部署圖(deployment diagram)等。在這些圖形化符號中,有三種圖最爲重要,分別是:用例圖(用來捕獲需求,描述系統的功能,經過該圖能夠迅速的瞭解系統的功能模塊及其關係)、類圖(描述類以及類與類之間的關係,經過該圖能夠快速瞭解系統)、時序圖(描述執行特定任務時對象之間的交互關係以及執行順序,經過該圖能夠了解對象能接收的消息也就是說對象可以向外界提供的服務)。 
用例圖: 
這裏寫圖片描述
類圖: 
這裏寫圖片描述 
時序圖: 
這裏寫圖片描述

 

9四、用Java寫一個冒泡排序。 
答:冒泡排序幾乎是個程序員都寫得出來,可是面試的時候如何寫一個逼格高的冒泡排序卻不是每一個人都能作到,下面提供一個參考代碼:

 

import java.util.Comparator; /** * 排序器接口(策略模式: 將算法封裝到具備共同接口的獨立的類中使得它們能夠相互替換) * @author駱昊 * */ public interface Sorter { /** * 排序 * @param list 待排序的數組 */ public <T extends Comparable<T>> void sort(T[] list); /** * 排序 * @param list 待排序的數組 * @param comp 比較兩個對象的比較器 */ public <T> void sort(T[] list, Comparator<T> comp); }

 

 

import java.util.Comparator; /** * 冒泡排序 * * @author駱昊 * */ public class BubbleSorter implements Sorter { @Override public <T extends Comparable<T>> void sort(T[] list) { boolean swapped = true; for (int i = 1, len = list.length; i < len && swapped; ++i) { swapped = false; for (int j = 0; j < len - i; ++j) { if (list[j].compareTo(list[j + 1]) > 0) { T temp = list[j]; list[j] = list[j + 1]; list[j + 1] = temp; swapped = true; } } } } @Override public <T> void sort(T[] list, Comparator<T> comp) { boolean swapped = true; for (int i = 1, len = list.length; i < len && swapped; ++i) { swapped = false; for (int j = 0; j < len - i; ++j) { if (comp.compare(list[j], list[j + 1]) > 0) { T temp = list[j]; list[j] = list[j + 1]; list[j + 1] = temp; swapped = true; } } } } }

 

9五、用Java寫一個折半查找。 
答:折半查找,也稱二分查找、二分搜索,是一種在有序數組中查找某一特定元素的搜索算法。搜素過程從數組的中間元素開始,若是中間元素正好是要查找的元素,則搜素過程結束;若是某一特定元素大於或者小於中間元素,則在數組大於或小於中間元素的那一半中查找,並且跟開始同樣從中間元素開始比較。若是在某一步驟數組已經爲空,則表示找不到指定的元素。這種搜索算法每一次比較都使搜索範圍縮小一半,其時間複雜度是O(logN)。

 

import java.util.Comparator;

public class MyUtil { public static <T extends Comparable<T>> int binarySearch(T[] x, T key) { return binarySearch(x, 0, x.length- 1, key); } // 使用循環實現的二分查找 public static <T> int binarySearch(T[] x, T key, Comparator<T> comp) { int low = 0; int high = x.length - 1; while (low <= high) { int mid = (low + high) >>> 1; int cmp = comp.compare(x[mid], key); if (cmp < 0) { low= mid + 1; } else if (cmp > 0) { high= mid - 1; } else { return mid; } } return -1; } // 使用遞歸實現的二分查找 private static<T extends Comparable<T>> int binarySearch(T[] x, int low, int high, T key) { if(low <= high) { int mid = low + ((high -low) >> 1); if(key.compareTo(x[mid])== 0) { return mid; } else if(key.compareTo(x[mid])< 0) { return binarySearch(x,low, mid - 1, key); } else { return binarySearch(x,mid + 1, high, key); } } return -1; } }

 

 

 

說明:上面的代碼中給出了折半查找的兩個版本,一個用遞歸實現,一個用循環實現。須要注意的是計算中間位置時不該該使用(high+ low) / 2的方式,由於加法運算可能致使整數越界,這裏應該使用如下三種方式之一:low + (high - low) / 2或low + (high – low) >> 1或(low + high) >>> 1(>>>是邏輯右移,是不帶符號位的右移)

相關文章
相關標籤/搜索