Java面試題大全（javaSe,HTML,CSS,js,Spring框架等）
目錄javascript
1. Java基礎部分 7html
1、一個".java"源文件中是否能夠包括多個類（不是內部類）？有什麼限制？ 7前端
2、Java有沒有goto? 7java
3、說說&和&&的區別。 7node
4、在JAVA中如何跳出當前的多重嵌套循環？ 7mysql
5、switch語句可否做用在byte上，可否做用在long上，可否做用在String上? 8git
6、short s1 = 1; s1 = s1 + 1;有什麼錯? short s1 = 1; s1 += 1;有什麼錯? 8程序員
7、char型變量中能不能存貯一箇中文漢字?爲何? 8web
8、用最有效率的方法算出2乘以8等於幾? 8面試
9、請設計一個一百億的計算器 8
10、使用final關鍵字修飾一個變量時，是引用不能變，仍是引用的對象不能變？ 8
11、"=="和equals方法究竟有什麼區別？ 9
12、靜態變量和實例變量的區別？ 9
13、是否能夠從一個static方法內部發出對非static方法的調用？ 9
14、Integer與int的區別 9
15、Math.round(11.5)等於多少? Math.round(-11.5)等於多少? 10
16、下面的代碼有什麼不妥之處? 10
17、請說出做用域public，private，protected，以及不寫時的區別 10
18、Overload和Override的區別。Overloaded的方法是否能夠改變返回值的類型? 10
19、構造器Constructor是否可被override? 10
20、接口是否可繼承接口?抽象類是否可實現(implements)接口?抽象類是否可繼承具體類(concrete class)?抽象類中是否能夠有靜態的main方法？抽象類是否可有之內部類？接口是否能夠有內部類？ 10
21、寫clone()方法時，一般都有一行代碼(不是必須有)，是什麼？ 11
22、面向對象的特徵有哪些方面 11
23、java中實現多態的機制是什麼？ 11
24、abstract class和interface有什麼區別? 11
25、abstract的method是否可同時是static，是否可同時是native，是否可同時是synchronized，是否可同時是final? 12
26、什麼是內部類？Static Nested Class和Inner Class的不一樣。 12
27、內部類能夠引用它的包含類的成員嗎？有沒有什麼限制？ 12
28、Anonymous Inner Class (匿名內部類)是否能夠extends(繼承)其它類，是否能夠implements(實現)interface(接口)? 12
29、super.getClass()方法和this.getClass()方法返回對象是否相同？ 12
30、String是最基本的數據類型嗎? 12
31、String s = "Hello";s = s + " world!";這兩行代碼執行後，原始的String對象中的內容到底變了沒有？ 12
32、是否能夠繼承String類? 12
33、String s = new String("xyz");建立了幾個String Object?兩者之間有什麼區別？ 13
34、String和StringBuffer的區別 13
34.1、StringBuffer和StringBuilder的區別 13
35、如何把一段逗號分割的字符串轉換成一個數組? 13
36、數組有沒有length()這個方法? String有沒有length()這個方法？JS的數組有沒有length()方法？JS的字符串有沒有length()方法？ 14
37、下面這條語句一共建立了多少個對象：String s="a"+"b"+"c"+"d"; 14
38、try {}裏有一個return語句，那麼緊跟在這個try後的finally {}裏的code會不會被執行，何時被執行，在return前仍是後? 14
39、下面的程序代碼輸出的結果是多少？ 15
40、final, finally, finalize的區別。 16
41、運行時異常(Runtime)與檢查異常(Checked)有何異同？ 16
42、error和exception有什麼區別? 16
43、Java中的異常處理機制的簡單原理和應用。 17
44、請寫出你最多見到的5個RuntimeException。 17
45、Java語言如何進行異常處理，關鍵字：throws,throw,try,catch,finally分別表明什麼意義？在try塊中能夠拋出異常嗎？ 17
46、 Java中有幾種方法能夠實現一個線程？用什麼關鍵字修飾同步方法? stop()和suspend()方法爲什麼不推薦使用？ 18
47、 sleep()和 wait()有什麼區別? 19
48、同步和異步有何異同，在什麼狀況下分別使用他們？舉例說明。 19
49. 下面兩個方法同步嗎？（本身發明） 19
50、多線程有幾種實現方法?同步有幾種實現方法? 20
51、啓動一個線程是用run()仍是start()? 20
52、當一個線程進入一個對象的一個synchronized方法後，其它線程是否可進入此對象的其它方法? 20
53、線程的基本概念、線程的基本狀態以及狀態之間的關係 20
54、簡述synchronized和java.util.concurrent.locks.Lock的異同？ 20
55、設計4個線程，其中兩個線程每次對j增長1，另外兩個線程對j每次減小1。寫出程序。 21
56、子線程循環10次，接着主線程循環100，接着又回到子線程循環10次，接着再回到主線程又循環100，如此循環50次，請寫出程序。 22
57、介紹Collection框架的結構 23
58、Collection框架中實現比較要實現什麼接口 24
59、ArrayList和Vector的區別 24
60、HashMap和Hashtable的區別 24
61、List和 Map區別? 24
62、List, Set, Map是否繼承自Collection接口? 24
63、List、Map、Set三個接口，存取元素時，各有什麼特色？ 24
64、說出ArrayList,Vector, LinkedList的存儲性能和特性 25
65、去掉一個Vector集合中重複的元素 25
66、Collection和 Collections的區別。 25
67、Set裏的元素是不能重複的，那麼用什麼方法來區分重複與否呢?是用==仍是equals()?它們有何區別? 25
68、你所知道的集合類都有哪些？主要方法？ 25
69、兩個對象值相同(x.equals(y) == true)，但卻可有不一樣的hash code，這句話對不對? 26
70、TreeSet裏面放對象，若是同時放入了父類和子類的實例對象，那比較時使用的是父類的compareTo方法，仍是使用的子類的compareTo方法，仍是拋異常！ 26
71、說出一些經常使用的類，包，接口，請各舉5個 26
72、Java中有幾種類型的流？JDK爲每種類型的流提供了一些抽象類以供繼承，請說出他們分別是哪些類？ 26
73、字節流與字符流的區別 26
74、什麼是java序列化，如何實現java序列化？或者請解釋Serializable接口的做用。 26
75、描述一下JVM加載class文件的原理機制? 27
76、heap和stack有什麼區別。 27
77、GC是什麼?爲何要有GC? 27
78、垃圾回收的優勢和原理。並考慮2種回收機制。 27
79、垃圾回收器的基本原理是什麼？垃圾回收器能夠立刻回收內存嗎？有什麼辦法主動通知虛擬機進行垃圾回收？ 27
80、何時用assert。 28
81、java中會存在內存泄漏嗎，請簡單描述。 28
82、能不能本身寫個類，也叫java.lang.String？ 28
83. Java代碼查錯 29
84、SSH集成方式 33
二.算法與編程 33
1、編寫一個程序，將a.txt文件中的單詞與b.txt文件中的單詞交替合併到c.txt文件中，a.txt文件中的單詞用回車符分隔，b.txt文件中用回車或空格進行分隔。 33
2、編寫一個程序，將d:\java目錄下的全部.java文件複製到d:\jad目錄下，並將原來文件的擴展名從.java改成.jad。 34
3、編寫一個截取字符串的函數，輸入爲一個字符串和字節數，輸出爲按字節截取的字符串，但要保證漢字不被截取半個，如「我ABC」，4，應該截取「我AB」，輸入「我ABC漢DEF」，6，應該輸出「我ABC」，而不是「我ABC+漢的半個」。 35
4、有一個字符串，其中包含中文字符、英文字符和數字字符，請統計和打印出各個字符的個數。 35
5、說明生活中遇到的二叉樹，用java實現二叉樹 36
6、從相似以下的文本文件中讀取出全部的姓名，並打印出重複的姓名和重複的次數，並按重複次數排序： 37
7、寫一個Singleton出來。 39
8、遞歸算法題1 40
9、遞歸算法題2 41
10、排序都有哪幾種方法？請列舉。用JAVA實現一個快速排序。 41
11、有數組a[n]，用java代碼將數組元素順序顛倒 42
12、金額轉換，阿拉伯數字的金額轉換成中國傳統的形式如：（￥1011）－>（一千零一拾一元整）輸出。 43
13、不使用遞歸遍歷二叉樹 43
14、以最快的效率找出一個數組中第二大的數 45
三. html&JavaScript&ajax部分 46
1. 判斷第二個日期比第一個日期大 46
2. 用table顯示n條記錄，每3行換一次顏色，即1，2，3用紅色字體，4，5，6用綠色字體，7，8，9用紅顏色字體。 47
3、HTML的 form提交以前如何驗證數值文本框的內容所有爲數字?不然的話提示用戶並終止提交? 47
4、請寫出用於校驗HTML文本框中輸入的內容所有爲數字的javascript代碼 48
5、說說你用過那些ajax技術和框架，說說它們的區別 48
四. Java web部分 48
1、Tomcat的優化經驗 48
2、HTTP請求的GET與POST方式的區別 48
3、解釋一下什麼是servlet; 49
4、說一說Servlet的生命週期? 49
5、Servlet的基本架構 49
6、Servlet API中forward()與redirect()的區別？ 49
7、什麼狀況下調用doGet()和doPost()？ 49
8、Request對象的主要方法： 49
9、request.getAttribute()和 request.getParameter()有何區別? 50
10. jsp有哪些內置對象?做用分別是什麼?分別有什麼方法？ 50
12. jsp生命週期? 51
12. jsp有哪些動做?做用分別是什麼? 51
13、JSP的經常使用指令 51
14. JSP中動態INCLUDE與靜態INCLUDE的區別？ 51
15、兩種跳轉方式分別是什麼?有什麼區別? 51
16、頁面間對象傳遞的方法 51
17、JSP和Servlet有哪些相同點和不一樣點，他們之間的聯繫是什麼？ 51
18、MVC的各個部分都有那些技術來實現?如何實現? 52
19、咱們在web應用開發過程當中常常遇到輸出某種編碼的字符，如iso-8859-1等，如何輸出一個某種編碼的字符串？ 52
20、如今輸入n個數字，以逗號分開；而後可選擇升或者降序排序；按提交鍵就在另外一頁面顯示按什麼排序，結果爲，提供reset 52
五.數據庫部分 52
1、根據部門號從高到低，工資從低到高列出每一個員工的信息。 52
2、列出各個部門中工資高於本部門的平均工資的員工數和部門號，並按部門號排序 52
3、存儲過程、函數與觸發器必須講，常常被面試到? 53
4、數據庫三範式是什麼? 54
5、說出一些數據庫優化方面的經驗? 55
6、union和union all有什麼不一樣? 56
6.1、表test中有兩個字段a、b，都爲數值型，若是a大於b，取a列的值，若是a不大於b，取b列的值，寫出你認爲最有效率的SQL，兼容全部數據庫。 56
7、分頁語句 56
8.用一條SQL語句查詢出每門課都大於80分的學生姓名 56
9.全部部門之間的比賽組合 56
10.每月份的發生額都比101科目多的科目 57
11.統計每一年每個月的信息 58
12.顯示文章標題，發帖人、最後回覆時間 59
13.刪除除了id號不一樣,其餘都相同的學生冗餘信息 60
14.航空網的幾個航班查詢題： 60
15.查出比經理薪水還高的員工信息： 61
16、求出小於45歲的各個老師所帶的大於12歲的學生人數 61
17.求出發帖最多的人： 61
18、一個用戶表中有一個積分字段，假如數據庫中有100多萬個用戶，若要在每一年第一天凌晨將積分清零，你將考慮什麼，你將想什麼辦法解決? 61
19、一個用戶具備多個角色，請查詢出該表中具備該用戶的全部角色的其餘用戶。(跟第42條SQL語句同) 62
20. xxx公司的sql面試 62
21、註冊Jdbc驅動程序的三種方式 63
22、用JDBC如何調用存儲過程 64
23、JDBC中的PreparedStatement相比Statement的好處 64
24、Class.forName的做用?爲何要用? 64
25、大數據量下的分頁解決方法。 64
26、用 JDBC查詢學生成績單,把主要代碼寫出來（考試機率極大）. 65
27、這段代碼有什麼不足之處? 65
28、說出數據鏈接池的工做機制是什麼? 65
29、爲何要用 ORM? 和 JDBC有何不同? 66
30. 數據庫大數據處理 66
31. 存儲過程和函數具體的區別： 66
六. XML部分 66
1、xml有哪些解析技術?區別是什麼? 66
2、你在項目中用到了xml技術的哪些方面?如何實現的? 67
3、用jdom解析xml文件時如何解決中文問題?如何解析? 67
4、編程用JAVA解析XML的方式. 68
5、XML文檔定義有幾種形式？它們之間有何本質區別？解析XML文檔有哪幾種方式？ 69
七.流行的框架與新技術 70
1、 談談你對Struts的理解。 70
2、談談你對Hibernate的理解。 70
3、AOP的做用。 70
4、你對Spring的理解。 71
5、談談Struts中的ActionServlet。 71
6、Struts優缺點 71
7、STRUTS的應用(如STRUTS架構) 72
8、說說struts1與struts2的區別。 72
9、hibernate中的update()和saveOrUpdate()的區別，session的load()和get()的區別。 72
10、簡述 Hibernate和 JDBC的優缺點?如何書寫一個 one to many配置文件. 72
11、iBatis與Hibernate有什麼不一樣? 72
12、寫Hibernate的一對多和多對一雙向關聯的orm配置? hibernate的inverse屬性的做用? 73
13、在DAO中如何體現DAO設計模式? 73
14、Spring+Hibernate中委託方案怎麼配置? 73
15. hibernate進行多表查詢每一個表中各取幾個字段，也就是說查詢出來的結果集沒有一個實體類與之對應如何解決； 73
16.介紹一下Hibernate的二級緩存 74
17、Spring的依賴注入是什麼意思?給一個 Bean 的 message屬性,字符串類型,注入值爲"Hello"的 XML配置文件該怎麼寫? 74
18、JDO是什麼? 74
19、什麼是spring的AOP 75
20、Struts的工做流程！ 75
21、Spring與EJB的區別 75
八.軟件工程與設計模式 75
1、UML方面 75
2、j2ee經常使用的設計模式？說明工廠模式。 75
3、開發中都用到了那些設計模式?用在什麼場合? 75
九. j2ee部分 76
1、BS與CS的聯繫與區別。 76
2、應用服務器與WEB SERVER的區別？ 77
3、應用服務器有那些？ 77
4、J2EE是什麼？ 77
5、J2EE是技術仍是平臺仍是框架？什麼是J2EE 77
6、請對如下在J2EE中經常使用的名詞進行解釋(或簡單描述) 77
7、如何給weblogic指定大小的內存? 78
8、如何設定的weblogic的熱啓動模式(開發模式)與產品發佈模式? 78
9、如何啓動時不需輸入用戶名與密碼? 78
10、在weblogic管理制臺中對一個應用域(或者說是一個網站,Domain)進行jms及ejb或鏈接池等相關信息進行配置後,實際保存在什麼文件中? 78
11、說說weblogic中一個Domain的缺省目錄結構?好比要將一個簡單的helloWorld.jsp放入何目錄下,然的在瀏覽器上就可打入http://主機:端口號//helloword.jsp就能夠看到運行結果了?又好比這其中用到了一個本身寫的javaBean該如何辦? 78
12、在weblogic中發佈ejb需涉及到哪些配置文件 78
13、如何在weblogic中進行ssl配置與客戶端的認證配置或說說j2ee(標準)進行ssl的配置? 78
14、如何查看在weblogic中已經發布的EJB? 78
1. Java基礎部分
基礎部分的順序：基本語法，類相關的語法，內部類的語法，繼承相關的語法，異常的語法，線程的語法，集合的語法，io的語法，虛擬機方面的語法。
1、一個".java"源文件中是否能夠包括多個類（不是內部類）？有什麼限制？
能夠有多個類，但只能有一個public的類，而且public的類名必須與文件名相一致。
一個文件中能夠只有非public類，若是隻有一個非public類，此類能夠跟文件名不一樣
2、Java有沒有goto?
java中的保留字，如今沒有在java中使用。
3、說說&和&&的區別。
&和&&均可以用做邏輯與的運算符，&&爲短路與，&不是短路與。
另外&能夠作爲整數的位運算符
例1：對於if(str != null&& !str.equals(「」))表達式，當str爲null時，後面的表達式不會執行，因此不會出現NullPointerException若是將&&改成&，則會拋出NullPointerException異常。
&&還具備短路的功能，即若是第一個表達式爲false，則再也不計算第二個表達式，
例2：If(x==33 &++y>0) y會增加，if(x==33 && ++y>0)不會增加
備註：這道題先說二者的共同點，再說出&&和&的特殊之處，並列舉一些經典的例子來代表本身理解透徹深刻、實際經驗豐富。
4、在JAVA中如何跳出當前的多重嵌套循環？
1. Break + 標籤
2. 直接使用Break
3. 使用方法的return
在Java中，要想跳出多重循環，能夠在外面的循環語句前定義一個標號，而後在裏層循環體的代碼中使用帶有標號的break語句，便可跳出外層循環。例如，
ok: for (int i = 0; i < 10; i++) {
for (int j = 0; j < 10; j++) {
System.out.println("i=" + i + ",j=" + j);
if (j == 5)
break ok;
}
}
另外，我我的一般並不使用標號這種方式，而是讓外層的循環條件表達式的結果能夠受到裏層循環體代碼的控制，例如，要在二維數組中查找到某個數字。
int arr[][] ={{1,2,3},{4,5,6,7},{9}};
boolean found = false;
for(int i=0;i<arr.length&& !found;i++) {
for(int j=0;j<arr[i].length;j++){
System.out.println("i=" + i + ",j=" + j);
if(arr[i][j] ==5) {
found = true;
break;
}
}
}
第三種，使用方法的return
private static int test() {
int count = 0;
for (int i = 0; i < 10; i++) {
for (int j = 0; j < 10; j++) {
count++;
System.out.println("i=" + i + ",j=" + j);
if (j == 5) {
return count;
}
}
}
return 0;
}
5、switch語句可否做用在byte上，可否做用在long上，可否做用在String上?
做用在byte, short, char, int, enum
封裝類對象和枚舉，其它基本數據類型及引用數據類型都不能作爲case的條件
6、short s1 = 1; s1 = s1 + 1;有什麼錯? short s1 = 1; s1 += 1;有什麼錯?
對於short s1 = 1; s1 = s1 + 1;因爲s1+1運算時會自動提高表達式的類型，因此結果是int型，再賦值給short類型s1時，編譯器將報告須要強制轉換類型的錯誤。
對於short s1 = 1; s1 += 1;因爲 +=是java語言規定的運算符，java編譯器會對它進行特殊處理，所以能夠正確編譯。
7、char型變量中能不能存貯一箇中文漢字?爲何?
char型變量是用來存儲Unicode編碼的字符的，unicode編碼字符集中包含了漢字
補充說明：unicode編碼佔用兩個字節，因此，char類型的變量也是佔用兩個字節。
8、用最有效率的方法算出2乘以8等於幾?
2 << 3
由於將一個數左移n位，就至關於乘以了2的n次方，那麼，一個數乘以8只要將其左移3位便可，而位運算cpu直接支持的，效率最高，因此，2乘以8等於幾的最效率的方法是2 << 3。
9、請設計一個一百億的計算器
若是隻是大整數運算，使用BigInteger就能夠
若是有浮點數據參與去處，須要使用BigDecimal進行運算
Java中基本類型的浮點數運算是不精確的，須要使用BigDecimal運算，尤爲是金融、會計方向的軟件
10、使用final關鍵字修飾一個變量時，是引用不能變，仍是引用的對象不能變？\指引用變量不能變，引用變量所指向的對象中的內容 能夠改變也就是不能再去new
引用變量不能從新賦值，可是引用指向的對象的內容能夠變化
例1：final StringBuffer a=new StringBuffer("immutable");
a=new StringBuffer("");
有編譯錯
例2：
final StringBuffer a=new StringBuffer("immutable");
a.append(「123」);
正確
11、"=="和equals方法究竟有什麼區別？
他們的區別主要存在在引用數據類型上
==爲比較兩側的對象是否同一對象，是用內存地址來比較的
equals是方法，默認是用內存地址比較，重寫後，主要是用來比較兩側的對象的值是否相同，和equals方法中的實現有關
==能夠兩側都爲null，但equals左側的引用指向的對象不能空，否則有NullPointerException
除非須要比較兩個引用指向的對象是同一對象，通常都使用equals方法進行比較。尤爲是String之類的值對象，另外，常量儘可能放在比較的左側
12、靜態變量和實例變量的區別？
在語法定義上的區別：靜態變量前要加static關鍵字，而實例變量前則不加。
在程序運行時的區別：實例變量屬於某個對象的屬性，必須建立了實例對象，其中的實例變量纔會被分配空間，才能使用這個實例變量。靜態變量不屬於某個實例對象，而是屬於類，因此也稱爲類變量，只要程序加載了類的字節碼，不用建立任何實例對象，靜態變量就會被分配空間，靜態變量就能夠被使用了。
總之，實例變量必須建立對象後才能夠經過這個對象來使用，靜態變量則能夠直接使用類名來引用。
13、是否能夠從一個static方法內部發出對非static方法的調用？
不能夠。由於非static方法（實例方法）是要與對象關聯在一塊兒的，必須建立一個對象後，才能夠在該對象上進行方法調用，而static方法調用時不須要建立對象，能夠直接調用。也就是說，當一個static方法被調用時，可能尚未建立任何實例對象，若是從一個static方法中發出對非static方法的調用，那個非static方法是關聯到哪一個對象上的呢？這個邏輯沒法成立，因此，一個static方法內部發出對非static方法的調用。
14、Integer與int的區別
int是java提供的8種原始數據類型之一，意思整型，佔用4字節。
Integer是java爲int提供的封裝類，是引用數據類型。
int的默認值爲0，而Integer的默認值爲null，即Integer能夠區分出未賦值和值爲0的區別，int則沒法表達出未賦值的狀況。
例如，要想表達出沒有參加考試和考試成績爲0的區別，則只能使用Integer
在JSP開發中，Integer的默認爲null，因此用el表達式在文本框中顯示時，值爲空白字符串，而int默認的默認值爲0，因此用el表達式在文本框中顯示時，結果爲0，因此，int不適合做爲web層的表單數據的類型。
在Hibernate中，若是將OID定義爲Integer類型，那麼Hibernate就能夠根據其值是否爲null而判斷一個對象是不是臨時的，若是將OID定義爲了int類型，還須要在hbm映射文件中設置其unsaved-value屬性爲0。
另外，Integer提供了多個與整數相關的操做方法，例如，將一個字符串轉換成整數，Integer中還定義了表示整數的最大值和最小值的常量。
15、Math.round(11.5)等於多少? Math.round(-11.5)等於多少?
Math類中提供了三個與取整有關的方法：ceil、floor、round，這些方法的做用與它們的英文名稱的含義相對應，例如，ceil的英文意義是天花板，該方法就表示向上取整，Math.ceil(11.3)的結果爲12,Math.ceil(-11.3)的結果是-11；floor的英文意義是地板，該方法就表示向下取整，Math.ceil(11.6)的結果爲11,Math.ceil(-11.6)的結果是-12；最難掌握的是round方法，它表示「四捨五入」，算法爲Math.floor(x+0.5)，即將原來的數字加上0.5後再向下取整，因此，Math.round(11.5)的結果爲12，Math.round(-11.5)的結果爲-11。
16、下面的代碼有什麼不妥之處?
1. if(username.equals(「zxx」){}
username可能爲null,會報空指針錯誤；改成"zxx".equals(username)
2. int x = 1;
return x==1?true:false; 這個改爲return x==1;就能夠!
17、請說出做用域public，private，protected，以及不寫時的區別
這四個做用域的可見範圍以下表所示。
說明：若是在修飾的元素上面沒有寫任何訪問修飾符，則表示friendly/default。
| 做用域 |
當前類 |
同package |
子孫類 |
其餘package |
| public |
√ |
√ |
√ |
√ |
| protected |
√ |
√ |
√ |
× |
| friendly/default |
√ |
√ |
× |
× |
| private |
√ |
× |
× |
× |
備註：只要記住了有4種訪問權限，4個訪問範圍，而後將全選和範圍在水平和垂直方向上分別按排從小到大或從大到小的順序排列，就很容易畫出上面的圖了。
18、Overload和Override的區別。Overloaded的方法是否能夠改變返回值的類型?
Overload是重載的意思，Override是覆蓋的意思，也就是重寫。
Overload和Override有共同之處，兩個方法的方法名都必須相同，若是不一樣，既不構成Overload，也不構成Override。
- Override必須發生在父子類之間，Overload能夠不在父子類之間
- Override的特色：
a) 參數列表徹底相同：個數相同、類型相同、順序相同
b) 子類的返回值不能比父類的返回值範圍大
c) 子類方法拋出的異常不能比父類方法拋出的異常範圍大
d) 修飾符只能爲public、protected、friendly，不能爲private
e) 父子類方法不能使用static修飾
- 重載發生在同一個類或父子類之間，重載中參數列表至少知足個數不一樣、類型不一樣、順序不一樣中的一個條件，不包含父子類之間的static方法
19、構造器Constructor是否可被override?
構造器Constructor不能被繼承，所以不能重寫Override，但能夠被重載Overload。
20、接口是否可繼承接口?抽象類是否可實現(implements)接口?抽象類是否可繼承具體類(concrete class)?抽象類中是否能夠有靜態的main方法？抽象類是否可有之內部類？接口是否能夠有內部類？
接口能夠繼承接口；抽象類能夠實現(implements)接口；抽象類可以繼承具體類；抽象類中能夠有靜態的main方法；抽象類可有之內部類；接口能夠有內部類，但必須是static內部類，但不必定是final的。
只有記住抽象類與普通類的惟一區別就是不能建立實例對象和容許有abstract方法。
21、寫clone()方法時，一般都有一行代碼(不是必須有)，是什麼？
clone 有缺省行爲，super.clone();由於首先要把類中的成員複製到位，而後纔是複製本身的成員。
22、面向對象的特徵有哪些方面
1. 封裝，隱藏內部實現，只暴露公共行爲
2. 繼承，提升代碼的重用性
3. 多態，體現現實生活中類似對象的差別性
4. 抽象，抽取現實世界中類似對象的共同點
23、java中實現多態的機制是什麼？
經過繼承父類或實現接口。
繼承指子類繼承父類的全部屬性、方法、內部類。對於屬性而言，若是子類的屬性名和父類的屬性名相同，則子類會把父類的屬性隱藏。屬性根據引用來調用，方法根據對象來調用；Java中只有單繼承，一個子類只能直接繼承一個父類。
實現指某類能夠實現接口中的部分或全部方法，並能繼承接口中的全部的屬性和內部類。接口中的屬性都爲public static final類型，方法都爲public類型，內部類都爲public static類型。接口能夠繼承多個接口，實現類能夠實現多個接口。
24、abstract class和interface有什麼區別?
含有abstract修飾符的class即爲抽象類，abstract類不能建立的實例對象。含有abstract方法的類必須定義爲abstract class，abstract class類中的方法沒必要是抽象的。abstract class類中定義抽象方法必須在具體(Concrete)子類中實現，因此，不能有抽象構造方法或抽象靜態方法。若是的子類沒有實現抽象父類中的全部抽象方法，那麼子類也必須定義爲abstract類型。
接口（interface）能夠說成是抽象類的一種特例，接口中的全部方法都必須是抽象的。接口中的方法定義默認爲public abstract類型，接口中的成員變量類型默認爲public static final。
下面比較一下二者的語法區別：
1. 抽象類能夠有構造方法，接口中不能有構造方法。
2. 抽象類中能夠有普通成員變量，接口中沒有普通成員變量
3. 抽象類中能夠包含非抽象的普通方法，接口中的全部方法必須都是抽象的，不能有非抽象的普通方法。
4. 抽象類中的抽象方法的訪問類型能夠是public，protected和默認類型，但接口中的抽象方法只能是public類型的，而且默認即爲public abstract類型。
5. 抽象類中能夠包含靜態方法，接口中不能包含靜態方法
6. 抽象類和接口中均可以包含靜態成員變量，抽象類中的靜態成員變量的訪問類型能夠任意，但接口中定義的變量只能是public static final類型，而且默認即爲public static final類型。
7. 一個類能夠實現多個接口，但只能繼承一個抽象類。
下面接着再說說二者在應用上的區別：
接口更多的是在系統架構設計方法發揮做用，主要用於定義模塊之間的通訊契約；
而抽象類在代碼實現方面發揮做用，能夠實現代碼的重用。
25、abstract的method是否可同時是static，是否可同時是native，是否可同時是synchronized，是否可同時是final?
abstract的method不能夠是static的，由於抽象的方法是要被子類實現的，而static與子類扯不上關係！
native方法表示該方法要用另一種依賴平臺的編程語言實現的，不存在着被子類實現的問題，因此，它也不能是抽象的，不能與abstract混用。
synchronized和abstract合用的問題不能共用，abstract方法只能存在於抽象類或接口中，它不能直接產生對象，而默認synchronized方法對當前對象加鎖，沒有對象是不能加鎖。
另外synchronized不能被繼承，子類繼承時，須要另加修改符。
final方法和abstract不能共用，由於final是不能被子類重寫的，而抽象方法必須被某級子類重寫。
26、什麼是內部類？Static Nested Class和Inner Class的不一樣。
內部類就是在一個類的內部定義的類。內部能夠定義在除參數位置上的任意位置。
1. 靜態內部類須要使用static修飾，而普通內部類不能使用static修飾
2. 靜態內部類只能定義在和屬性同級，普通內部類能夠定義在除參數位置之外的任意位置
3. 靜態內部類必需有名稱，而普通內部類能夠是匿名的
4. 靜態內部類沒有this引用，只此只能訪問外部類的靜態成員，而普通內部類能夠訪問外部類的所有成員
5. 靜態內部類訪問外部類的同名函數時，使用「外部類名.方法名」便可，而普通內部類須要使用「外部類名.this.外部方法」
6. 靜態內部類能夠定義靜態方法，而普通內部類不能定義靜態方法，但能定義簡單數據類型的靜態屬性，不能定義引用類型的靜態屬性。
27、內部類能夠引用它的包含類的成員嗎？有沒有什麼限制？
1. 若是內部類爲靜態內部類，只能調用外部類的靜態成員；若是有重名成員，須要用「外部類名.成員名」訪問；不能調用外部類的對象成員。
2. 若是內部類爲非靜態內部類，則能夠調用外部類的全部成員；若是有重名成員，須要使用「外部類名.this.成員名」
28、Anonymous Inner Class (匿名內部類)是否能夠extends(繼承)其它類，是否能夠implements(實現)interface(接口)?
能夠繼承其餘類或實現其餘接口。不只是能夠，而是必須!
29、super.getClass()方法和this.getClass()方法返回對象是否相同？
返回的Class對象是同一對象，都是子類的對象。final方法，不容許重寫
30、String是最基本的數據類型嗎?
基本數據類型包括byte、int、char、long、float、double、boolean和short。
String是引用數據類型。
java.lang.String類是final類型的，所以不能夠繼承這個類、不能修改這個類。爲了提升效率節省空間，咱們應該用StringBuffer/StringBuilder類
31、String s = "Hello";s = s + " world!";這兩行代碼執行後，原始的String對象中的內容到底變了沒有？
沒有。由於String被設計成不可變(immutable)類，因此它的全部對象都是不可變對象。
s = s + " world!";至關於: (JDK 1.5以上版本)
s = new StringBuilder(String.valueOf(s)).append(" world!").toString();
32、是否能夠繼承String類?
String類是final類故不能夠繼承。
33、String s = new String("xyz");建立了幾個String Object?兩者之間有什麼區別？
兩個對象。一個是"xyz"，爲緩衝區對象。另外一個是new出來的String對象。
這兩個對象的值相同，但不是同一個對象。
補充，新建對象有幾種方式？
1. 使用new關鍵字
2. 使用反射，調用newInstance
3. 使用clone方法
4. 使用序列化與反序列化
5. 動態代理(Proxy類和CGLIB)
34、String和StringBuffer的區別
這兩個類都實現了CharSequence接口。
1. 類型不一樣，由於不是一個類，也沒有繼承關係，作參數時不能共用
2. String對象是不可變對象，不能修改值。而StringBuffer是可變對象，能修改值。
3. 拼接字符串時，String會產生新對象，而StringBuffer只是增長新字符，不產生新對象，所以效率高。
4. String覆蓋了equals方法和hashCode方法，而StringBuffer沒有覆蓋equals方法和hashCode方法，因此，將StringBuffer對象存儲進Java集合類中時會出現問題。
34.1、StringBuffer和StringBuilder的區別
相同之處，這兩類都是可變長的字符串存儲類，都實現了CharSequence接口
1. 類型不一樣，由於不是一個類，也沒有繼承關係，作參數時不能共用
2. StringBuffer爲線程安全類，StringBuilder爲線程非安全類
3. StringBuffer性能低，StringBuilder性能高，若是在局部優先使用StringBuilder
4. JDK在1.5以前，字符串相加使用StringBuffer對象，在1.5以後使用StringBuilder對象
35、如何把一段逗號分割的字符串轉換成一個數組?
- 用正則表達式，代碼大概爲：String [] result = orgStr.split(「,」, -1);
- 用 StingTokenizer ,代碼爲：
StringTokenizer tokener = new StringTokenizer(s, ",");
String[] result = new String[tokener.countTokens()];
Integer i = 0;
while (tokener.hasMoreTokens()) {
result[i++] = tokener.nextToken();
}
- 最笨的辦法，用String.indexOf()
int index = -1;
int oldIndex = 0;
List<String> ss = new ArrayList<String>();
while ((index = s.indexOf(',', index + 1)) != -1) {
ss.add(s.substring(oldIndex, index));
oldIndex = index + 1;
}
if (s.charAt(s.length() - 1) == ',') {
ss.add("");
}
String[] array = ss.toArray(new String[ss.size()]);
System.out.println(Arrays.toString(array));
36、數組有沒有length()這個方法? String有沒有length()這個方法？JS的數組有沒有length()方法？JS的字符串有沒有length()方法？
數組沒有length()這個方法，有length的屬性。String有有length()這個方法。JS中只有length屬性，沒有length方法。
37、下面這條語句一共建立了多少個對象：String s="a"+"b"+"c"+"d";
答：產生了一個對象，即"abcd"
對於以下代碼：
String s1 = "a";
String s2 = s1 + "b";
String s3 = "a" + "b";
System.out.println(s2 == "ab"); // false
System.out.println(s3 == "ab"); // true
String s = "a" + "b" + "c" + "d";
System.out.println(s == "abcd"); // true s被優化爲」abcd」
38、try {}裏有一個return語句，那麼緊跟在這個try後的finally {}裏的code會不會被執行，何時被執行，在return前仍是後?
也許你的答案是在return以前，但往更細地說，個人答案是在return中間執行，請看下面程序代碼的運行結果：
public class Test {
public static void main(String[] args) {
System.out.println(test());
}
static int test() {
int x = 1;
try {
return x;
}
finally {
++x;
}
}
}
---------執行結果 ---------
1
運行結果是1，爲何呢？主函數調用子函數並獲得結果的過程，比如主函數準備一個空罐子，當子函數要返回結果時，先把結果放在罐子裏，而後再將程序邏輯返回到主函數。所謂返回，就是子函數說，我不運行了，你主函數繼續運行吧，這沒什麼結果可言，結果是在說這話以前放進罐子裏的。
39、下面的程序代碼輸出的結果是多少？
public class SmallT {
public static void main(String args[]) {
SmallT t = new SmallT();
int b = t.get();
System.out.println(b);
}
public int get() {
try {
return 1;
} finally {
return 2;
}
}
}
返回的結果是2。
我能夠經過下面一個例子程序來幫助我解釋這個答案，從下面例子的運行結果中能夠發現，try中的return語句調用的函數先於finally中調用的函數執行，也就是說return語句先執行，finally語句後執行，因此，返回的結果是2。Return並非讓函數立刻返回，而是return語句執行後，將把返回結果放置進函數棧中，此時函數並非立刻返回，它要執行finally語句後才真正開始返回。
在講解答案時能夠用下面的程序來幫助分析：
public class Test {
public static void main(String[] args) {
System.out.println(newTest().test());
}
int test() {
try {
return func1();
} finally {
return func2();
}
}
int func1() {
System.out.println("func1");
return 1;
}
int func2() {
System.out.println("func2");
return 2;
}
}
-----------執行結果-----------------
func1
func2
2
結論：finally中的代碼比return和break語句後執行
40、final, finally, finalize的區別。
final 用於聲明屬性，方法和類，分別表示屬性不可變，方法不可覆蓋，類不可繼承。
內部類要訪問局部變量，局部變量必須定義成final類型
final int[] number = { 20 };
new Thread() {
@Override
public void run() {
for (int k = 0; k < 20; k++) {
number[0]++;
}
}
}.start();
Thread.sleep(10);
System.out.println(number[0]);
finally是異常處理語句結構的一部分，表示老是執行，用來釋放資源。
finalize是Object類的一個方法，在垃圾收集器執行的時候會調用被回收對象的此方法，能夠覆蓋此方法提供垃圾收集時的其餘資源回收，例如關閉文件等。JVM不保證此方法總被調用
41、運行時異常(Runtime)與檢查異常(Checked)有何異同？
異常表示程序運行過程當中可能出現的非正常狀態，運行時異常表示虛擬機的一般操做中可能遇到的異常，是一種常見運行錯誤。java編譯器要求方法必須聲明拋出可能發生的非運行時異常，可是並不要求必須聲明拋出未被捕獲的運行時異常。
運行時異常爲編程時的異常，應該在生產環境正常運行狀態下不會發生的異常
檢查異常一般爲一種設計模式，表示某處執行時可能由於條件不足而出現異常，程序必須對此進行處理，JVM會提示編程人員捕獲或從新拋出異常
42、error和exception有什麼區別?
error 表示恢復不是不可能但很困難的狀況下的一種嚴重問題。好比說內存溢出，不可能期望程序能處理這樣的狀況。exception表示一種設計或實現問題，也就是說，它表示若是程序運行正常，正常狀況下從不會發生的狀況。
43、Java中的異常處理機制的簡單原理和應用。
異常是指java程序運行時（非編譯）所發生的非正常狀況或錯誤。
Java使用面向對象的方式來處理異常，它把程序中發生的每一個異常也都分別封裝到一個對象中，該對象中包含有異常的信息。
Java能夠自定義異常類，全部異常的根類爲java.lang.Throwable，Throwable下面又派生了兩個子類：Error和Exception。
- Error表示應用程序自己沒法克服和恢復的一種嚴重問題，程序只有退的份了，例如說內存溢出和線程死鎖等系統問題。
- Exception表示程序還可以克服和恢復的問題，其中又分爲運行時異常和檢查異常，運行時異常是軟件自己缺陷所致使的問題，也就是軟件開發人員考慮不周所致使的問題，軟件使用者沒法克服和恢復這種問題，但在這種問題下還可讓軟件系統繼續運行或者讓軟件死掉。例如，數組越界（ArrayIndexOutOfBoundsException），空指針異常（NullPointerException）、類轉換異常（ClassCastException）；檢查異常是運行環境的變化或異常所致使的問題，是用戶可以克服的問題，例如，網絡斷線，硬盤空間不夠，發生這樣的異常後，程序不該該死掉。
Java爲運行時異常和檢查異常提供了不一樣的解決方案，編譯器強制檢查異常必須try..catch處理或用throws聲明繼續拋給上層調用方法處理，因此檢查異常也稱爲checked異常，而運行異常能夠處理也能夠不處理，因此編譯器不強制用try..catch處理或用throws聲明，因此運行異常也稱爲Runtime異常。
提示答題者：就按照三個級別去思考：虛擬機必須宕機的錯誤，程序能夠死掉也能夠不死掉的錯誤，程序不該該死掉的錯誤
44、請寫出你最多見到的5個RuntimeException。
NullPointerException、ArrayIndexOutOfBoundsException、ClassCastException、IllegelArgumentException、SecurityException。
45、Java語言如何進行異常處理，關鍵字：throws,throw,try,catch,finally分別表明什麼意義？在try塊中能夠拋出異常嗎？
- Java語言如何進行異常處理見43題
- throws爲向上拋異常，當前方法沒法處理此異常，須要上層方法進行處理
throw程序出錯時，手工拋出異常，最好能把異常進行堆棧式拋出
try嘗試執行，裏面的語句可能出現異常，如出現異常須要處理
catch處理try中出現的異常
finally在try後執行清理操做，用於釋放資源
- 在try中能夠拋出異常
4六、Java中有幾種方法能夠實現一個線程？用什麼關鍵字修飾同步方法? stop()和suspend()方法爲什麼不推薦使用？
java5之前，有以下兩種：
第一種：
new Thread(){}.start();這表示調用Thread子類對象的run方法，new Thread(){}表示一個Thread的匿名子類的實例對象，子類加上run方法後的代碼以下：
new Thread() {
public void run() {
}
}.start();
第二種：
new Thread(new Runnable(){}).start();這表示調用Thread對象接受的Runnable對象的run方法，new Runnable(){}表示一個Runnable的匿名子類的實例對象,runnable的子類加上run方法後的代碼以下：
new Thread(new Runnable() {
public void run() {
}
}).start();
從Java5開始，還有以下一些線程池建立多線程的方式：
ExecutorService pool = Executors.newFixedThreadPool(3);
for (int i = 0; i < 10; i++) {
pool.execute(new Runable() {
public void run() {
}
});
}
Executors.newCachedThreadPool().execute(new Runable() {
public void run() {
}
});
Executors.newSingleThreadExecutor().execute(new Runable() {
public void run() {
}
});
有兩種實現方法，分別使用new Thread()和new Thread(runnable)形式，第一種直接調用thread的run方法，因此，咱們每每使用Thread子類，即new SubThread()。第二種調用runnable的run方法。
- 有兩種實現方法，分別是繼承Thread類與實現Runnable接口。能夠的話使用線程池
- 用synchronized關鍵字修飾同步方法
- 反對使用stop()，是由於它不安全。它會解除由線程獲取的全部鎖定，並且若是對象處於一種不連貫狀態，那麼其餘線程能在那種狀態下檢查和修改它們。結果很難檢查出真正的問題所在。suspend()方法容易發生死鎖。調用suspend()的時候，目標線程會停下來，但卻仍然持有在這以前得到的鎖定。此時，其餘任何線程都不能訪問鎖定的資源，除非被"掛起"的線程恢復運行。對任何線程來講，若是它們想恢復目標線程，同時又試圖使用任何一個鎖定的資源，就會形成死鎖。因此不該該使用suspend()，而應在本身的Thread類中置入一個標誌，指出線程應該活動仍是掛起。若標誌指出線程應該掛起，便用wait()命其進入等待狀態。若標誌指出線程應當恢復，則用一個notify()從新啓動線程。
4七、sleep()和 wait()有什麼區別?
1. sleep是在Thread類定義的，wait是在Object類定義的
2. sleep有兩個重載方法，wait有三個重載方法
3. sleep能自動喚醒，wait有參數的方法能自動喚醒，但無參數的重載方法不能自動喚醒，須要使用notify/notifyAll進行手動喚醒
4. sleep掛起時，不釋放鎖資源，wait掛起時，會釋放鎖資源
5. sleep調用時，不須要放在synchronized內，wait須要放在synchronized內
6. sleep通常不會產生死鎖，可是wait可能會產生死鎖
48、同步和異步有何異同，在什麼狀況下分別使用他們？舉例說明。
同步是指全部操做串行化執行，順序不能改變，前一操做未完成，後個操做不執行。
異步是指全部操做能夠並行執行，順序無關。
例如寄信
同步：若是沒有寄完，不能吃飯，郵遞員10天后送到，發送人被餓死
異步：寄出後能夠當即吃飯，郵遞員送完後，通知發送人送信結果。
若是強調執行順序的話，用同步。若是順序無關，則能夠用異步。
異步執行效率比同步高。該用同步時，若是用了異步，結果可能會出現不一致。
49. 下面兩個方法同步嗎？（本身發明）
class Test {
synchronized static void sayHello3() {
}
synchronized void getX() {
}
}
50、多線程有幾種實現方法?同步有幾種實現方法?
多線程有兩種實現方法，分別是繼承Thread類與實現Runnable接口
同步的實現方面有五種，分別是synchronized、wait與notify、sleep、suspend、join
synchronized: 一直持有鎖，直至執行結束
wait():使一個線程處於等待狀態，而且釋放所持有的對象的lock，需捕獲異常。
sleep():使一個正在運行的線程處於睡眠狀態，是一個靜態方法，需捕獲異常，不釋放鎖。
notify():喚醒一個處於等待狀態的線程，注意的是在調用此方法的時候，並不能確切的喚醒某一個等待狀態的線程，而是由JVM肯定喚醒哪一個線程，並且不是按優先級。
notityAll():喚醒全部處入等待狀態的線程，注意並非給全部喚醒線程一個對象的鎖，而是讓它們競爭。
51、啓動一個線程是用run()仍是start()?
啓動一個線程是調用start()方法，使線程就緒狀態，之後能夠被調度爲運行狀態，一個線程必須關聯一些具體的執行代碼，run()方法是該線程所關聯的執行代碼。
52、當一個線程進入一個對象的一個synchronized方法後，其它線程是否可進入此對象的其它方法?
若是其它方法中使用當前對象做爲鎖對象，則不能；
若是其它方法中沒有使用當前對象做爲鎖對象，則能。
53、線程的基本概念、線程的基本狀態以及狀態之間的關係
在多任務操做系統中，爲了提升CPU的利用率，能夠使用多進程編程。但對進程通訊比較困難，進程間數據不能共享，所以能夠使用多線程編程。一個進程至少包含一個主入口線程。
單個CPU，在同一時間只能處理一個線程的數據，可是操做系統的任務調度很是快，人眼沒法識別，感受上是多個線程同時執行。有的線程能夠已經用完CPU，正在做磁盤操做，此時並不使用CPU，可讓出CPU資源給其它線程使用，提升效率。
線程有生命週期及相關關係和對應方法見46題。
54、簡述synchronized和java.util.concurrent.locks.Lock的異同？
主要相同點：Lock能完成synchronized所實現的全部功能
主要不一樣點：
- 更好的語義
- 更高性能
- synchronized自動釋放鎖，Lock手動釋放，而且必須在finally從句中釋放。
- 功能強大，能夠用tryLock方法能夠非阻塞方式去拿鎖
舉例說明（對下面的題用lock進行了改寫）：
package com.huawei.interview;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class ThreadTest {
private int j;
private Lock lock = newReentrantLock();
public static void main(String[] args) {
ThreadTest tt = new ThreadTest();
for (int i = 0; i < 2; i++) {
new Thread(tt.new Adder()).start();
new Thread(tt.new Subtractor()).start();
}
}
private class Subtractor implements Runnable {
@Override
public void run() {
while (true) {
lock.lock();
try {
System.out.println("j--=" + j--);
} finally {
lock.unlock();
}
}
}
}
private class Adder implements Runnable {
@Override
public void run() {
while (true) {
lock.lock();
try {
System.out.println("j++=" + j++);
} finally {
lock.unlock();
}
}
}
}
}
55、設計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 (inti = 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 (inti = 0; i < 100; i++) {
inc();
}
}
}
class Dec implements Runnable {
public void run() {
for (inti = 0; i < 100; i++) {
dec();
}
}
}
}
56、子線程循環10次，接着主線程循環100，接着又回到子線程循環10次，接着再回到主線程又循環100，如此循環50次，請寫出程序。
public class ThreadTest {
public static void main(String[] args) throws Exception {
for (int i = 0; i < 50; i++) {
MainThread main = new MainThread();
main.start();
main.join();
}
}
}
class MainThread extends Thread {
@Override
public void run() {
SubThread sub = new SubThread();
sub.start();
try {
sub.join();
} catch (InterruptedException e) {
// LOG
}
for (int i = 0; i < 100; i++) {
System.out.println("main: " + i);
}
}
}
class SubThread extends Thread {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("sub: " + i);
}
}
}
57、介紹Collection框架的結構
Iterable （順序表）
àCollection（他下面能夠裝東西）
àList（是collection下面的接口）能夠重
àArrayList（局部變量用這個合適）
àLinkedList（是一個鏈表，按順序鏈接）
àVector（它是一個類，叫作向量，也算一種list，惟一區別 是跟線程同步）
àStack（棧（））
àSet（是collection下面的接口）不能夠重（無序的，
àHashSet
àSortedSet（它是一個接口）
àTreeSet（是用treeMap實現的）（value 不重要 Key重要）
Map（無序的，放進去取出來不一樣）（在數學上是集合，是一個元素元素不能又重的）
àSortedMap（
àTreeMap
àHashtable（跟它的區別）（它是舊實現 由於跟線程同步，另外它用的舊接口 便利用invtion便利）
àProperties
àHashMap
àLinkedHashMap
Collections，不屬於集合，是集合類的工具類
Arrays，不屬於集合類，是數據對象的工具類
58、Collection框架中實現比較要實現什麼接口
Comparable/Comparator
59、ArrayList和Vector的區別
1. 線程同步，Vector線程安全，ArrayList線程不安全
2. 效率問題，Vector效率低，ArrayList效率高
3. 增加數量，Vector以1.5倍增加，ArrayList以2倍增加
60、HashMap和Hashtable的區別
1. 線程同步，Hashtable線程安全，HashMap線程不安全
2. 效率問題，Hashtable效率低，HashMap效率高
3. HashMap能夠使用null做爲key，Hashtable不能夠使用null爲key
4. HashMap使用的是新實現，繼承AbstractMap，而Hashtable是繼承Dictionary類，實現比較老
5. Hash算法不一樣，HashMap的hash算法比Hashtable的hash算法效率高
6. HashMap把Hashtable的contains方法去掉了，改爲containsValue和containsKey。由於contains方法容易讓人引發誤解。
7. 取值不一樣，HashMap用的是Iterator接口，而Hashtable中還有使用Enumeration接口
61、List和 Map區別?
一個是存儲單列數據的集合，另外一個是存儲鍵和值的雙列數據的集合，List中存儲的數據是有順序，而且容許重複；Map中存儲的數據是沒有順序的，其鍵是不能重複的，它的值是能夠有重複的。
- List有重複值，Map沒有重複key，但能夠有重複值
- List有序，Map不必定有序
- List只能存單列值，Map能夠存雙列值
62、List, Set, Map是否繼承自Collection接口?
List、Set是，Map不是
63、List、Map、Set三個接口，存取元素時，各有什麼特色？
List使用get(index)取值，也能夠使用Iterator、toArray取值
Set只能經過Iterator、toArray取值
Map取值使用get(key)取值，也能夠使用keySet取鍵值集合，也可以使用values取值集合，entrySet取所有鍵值對映射。
64、說出ArrayList,Vector, LinkedList的存儲性能和特性
1. ArrayList和Vector使用數組存儲元素；LinkedList使用鏈表存儲元素
2. ArrayList和Vector插入刪除數據時，須要搬運數據，效率較差；LinkedList使用鏈表，不須要搬運數據，效率高
3. ArrayList和Vectory查詢時，按數組下標查詢，不須要遍歷，效率高；LinkedList須要遍歷，查詢效率底
4. ArrayList和Vector的區別見59條
65、去掉一個Vector集合中重複的元素
1. 自行遍歷，用另一個Vector來判斷是否有重複
2. 用Set(TreeSet或HashSet)來去重
3. 用Apache的CollectionUtil工具類去重
Vector newVector = new Vector();
for (int i = 0; i < vector.size(); i++) {
Object obj = vector.get(i);
if (!newVector.contains(obj))
newVector.add(obj);
}
還有一種簡單的方式，HashSet set = new HashSet(vector);
66、Collection和 Collections的區別。
Collection是集合類的上級接口，繼承與他的接口主要有Set和List.
Collections是針對集合類的一個工具類，他提供一系列靜態方法實現對各類集合的搜索、排序、線程安全化等操做。
67、Set裏的元素是不能重複的，那麼用什麼方法來區分重複與否呢?是用==仍是equals()?它們有何區別?
Set裏的元素是不能重複的，元素重複與否視具體狀況而定：
1. HashSet使用equals比較
2. TreeSet使用compareTo進行比較
68、你所知道的集合類都有哪些？主要方法？
最經常使用的集合類接口是List 和 Map。
List的具體實現包括ArrayList、Vector、LinkedList，它們是可變大小的列表，比較適合構建、存儲和操做任何類型對象的元素列表。List適用於按數值索引訪問元素的情形。
Set的具體實現包括HashSet和TreeSet，它們也是可變大小集合，但不適合用索引取值。
Map 提供了一個更通用的元素存儲方法。Map集合類用於存儲元素對（稱做"鍵"和"值"），其中每一個鍵映射到一個值。
ArrayList/Vector、LinkedList
HashSet/TreeSet
Properties/HashTable/TreeMap/HashMap
List的主要方法有：
add、get、remove、set、iterator、contains、addAll、removeAll、indexOf、toArray、clear、isEmpty
Set的主要方法有：
add、remove、iterator、contains、addAll、removeAll、toArray、clear、isEmpty
Map的主要方法有：
put、get、keySet、values、entrySet、clear、remove、isEmpty
69、兩個對象值相同(x.equals(y) == true)，但卻可有不一樣的hash code，這句話對不對?
1. equals等，hashCode同，所以重寫equals方法必須重寫hashCode
2. hashCode等，equals不必定同，但hashCode最好散列化
3. 任何對象equals null都得false
4. 沒有繼承關係的兩個類，equals都得false
5. 重寫equals方法的類最好是值類，即不可變
6. 若是A對象equals B對象，B對象equals C對象，則A對象equals C對象
70、TreeSet裏面放對象，若是同時放入了父類和子類的實例對象，那比較時使用的是父類的compareTo方法，仍是使用的子類的compareTo方法，仍是拋異常！
1. 若是子類從新實現了Comparable，且比較時所有使用父類的引用和屬性，則不會出錯
2. 若是子類從新實現了Comparable，且比較時使用了子類的引用和屬性，出異常
3. 子類沒有從新實現Comparable，則不會了出錯。
用哪一個對象比較，則調用哪一個對象的comparaTo方法
71、說出一些經常使用的類，包，接口，請各舉5個
要讓人家感受你對JavaEE開發很熟，因此，不能僅僅只列core java中的那些東西，要多列你在作ssh項目中涉及的那些東西。就寫你最近寫的那些程序中涉及的那些類。
經常使用的類：BufferedReader，BufferedWriter，FileReader，FileWirter，String，Integer，
java.util.Date，System，Class，List，HashMap
經常使用的包：java.lang，java.io，java.util，java.sql，javax.servlet，org.apache.strtuts.action，org.hibernate, org.springframework
經常使用的接口：List，Map，Document，NodeList，Servlet，HttpServletRequest，HttpServletResponse，HttpSession，Action(Struts)，Transaction(Hibernate) ，Session(Hibernate)，ApplicationContext(Spring)，FactoryBean(Spring)
72、Java中有幾種類型的流？JDK爲每種類型的流提供了一些抽象類以供繼承，請說出他們分別是哪些類？
字節流，字符流。字節流繼承於InputStream、OutputStream，字符流繼承於Reader、Writer。在java.io包中還有許多其餘的流，主要是爲了提升性能和使用方便。
FileInputStream、FileReader、ByteArrayInputStream、CharArrayReader、BufferedInputStream、BufferedReader、ZipInputStream、PrintStream、StringReader、ObjectInputStream、RandomAccessFile(不屬於流，但像流)
73、字節流與字符流的區別
字節流是按字節讀取或寫入設備，但字符流是以字符爲單位讀取或寫入設備。
若是是二進制文件，須要用字節流讀取。通常來講，字符流只處理文本文件。在設備中，大多數狀況是以字節形式存儲數據的，所以字符流經過須要傳入字節流當參數。
74、什麼是java序列化，如何實現java序列化？或者請解釋Serializable接口的做用。
序列化是把內存Java對象保存到存儲介質中，反序列化就是把存儲介質中的數據轉化爲Java對象。Java經過ObjectInputStream和ObjectOutputStream實現序列化和反序列化。須要進行序列化的對象的類必須實現Serializable接口，一般狀況下須要知足如下條件：
1. 強烈建議手動生成serialVersionUID常量
2. 若是須要加解密的話，須要實現兩個方法readObject和writeObject方法
3. 若是使用Hibernate二級緩存或其它緩存服務器的話，對象必須是可序列化的
4. 若是須要遠程調用對象或傳值的話，則對像須要序列化
5. 序列化類的可序列化成員必須也是可序列化的，不須要序列化的屬性用transient修飾
75、描述一下JVM加載class文件的原理機制?
1. 查找當前ClassLoader中是否有此class的類對象，有則返回
2. 若沒有的話，向上遞歸全部的父ClassLoader中有無此class類對象，有則返回
3. 若尚未，查找BootstrapClassLoader中有無此class類對象，有則返回
4. 若尚未的話，使用findClass或resolveClass加載類對象
a. 讀取class二進制文件
b. 根據字節數組生成Class對象
c. 緩存到當前ClassLoader中
JVM加載class對象是懶加載，按需加載
76、heap和stack有什麼區別。
Java的內存分爲兩類，一類是棧內存，一類是堆內存。
棧中存儲的是當前線程的方法調用、基本數據類型和對象的引用，棧是有序的。
堆中存儲的是對象，堆是無序的。
方法中的局部變量使用final修飾後，放在堆中，而不是棧中。
77、GC是什麼?爲何要有GC?
GC是垃圾回收的意思(Gabage Collection)，內存處理是編程人員容易出現問題的地方，忘記或者錯誤的內存回收會致使程序或系統的不穩定甚至崩潰，Java提供的GC功能能夠自動監測對象是否超過做用域從而達到自動回收內存的目的，Java語言沒有提供釋放已分配內存的顯示操做方法。線程對象在沒有終止前，即便沒有任何引用，也不會被垃圾回收。
只能建議JVM回收內存，不能強制，能夠使用System.gc()建議執行。
GC有三種方式，串行回收、並行回收、混合回收。
78、垃圾回收的優勢和原理。並考慮2種回收機制。
Java語言中一個顯著的特色就是引入了垃圾回收機制，使C++程序員最頭疼的內存管理的問題迎刃而解，它使得Java程序員在編寫程序的時候再也不須要考慮內存管理。因爲有垃圾回收機制，Java中的對象再也不有"做用域"的概念，只有對象的引用纔有"做用域"。垃圾回收能夠有效的防止內存泄露，更有效的使用內存。垃圾回收器一般是做爲一個單獨的低級別的線程運行，對內存堆中已經死亡的或者長時間沒有使用的對象進行清除和回收，程序員不能實時的調用垃圾回收器對某個對象或全部對象進行垃圾回收。回收機制有分代複製垃圾回收和標記垃圾回收，增量垃圾回收。
- 按時間輪詢，把沒有引用的對象進行回收
- 按內存的使用量超不超過報警值進行回收
- 按CPU空閒時間進行回收
- 程序建議JVM進行垃圾回收
GC有三種方式，串行回收、並行回收、混合回收。
79、垃圾回收器的基本原理是什麼？垃圾回收器能夠立刻回收內存嗎？有什麼辦法主動通知虛擬機進行垃圾回收？
對於GC來講，當程序員建立對象時，GC就開始監控這個對象的地址、大小以及使用狀況。一般，GC採用有向圖的方式記錄和管理堆(heap)中的全部對象。經過這種方式肯定哪些對象是"可達的"，哪些對象是"不可達的"。當GC肯定一些對象爲"不可達"時，GC就有責任回收這些內存空間。能夠。程序員能夠手動執行System.gc()，通知GC運行，可是Java語言規範並不保證GC必定會執行。
80、何時用assert。
assertion(斷言)在軟件開發中是一種經常使用的調試方式，不少開發語言中都支持這種機制。在實現中，assertion就是在程序中的一條語句，它對一個boolean表達式進行檢查，一個正確程序必須保證這個boolean表達式的值爲true；若是該值爲false，說明程序已經處於不正確的狀態下，assert將給出警告或退出。通常來講，assertion用於保證程序最基本、關鍵的正確性。assertion檢查一般在開發和測試時開啓。爲了提升性能，在軟件發佈後，assertion檢查一般是關閉的。
81、java中會存在內存泄漏嗎，請簡單描述。
會，緣由：
若是對象被集合類引用時，若是隻是添加，而不刪除，會引發內存泄漏，嚴重時會發出內存溢出。
Java中的內存泄露的狀況：長生命週期的對象持有短生命週期對象的引用就極可能發生內存泄露
內存泄露的另一種狀況：當一個對象被存儲進HashSet或HashMap中之後，就不能修改這個對象中的那些參與計算哈希值的字段了，不然，對象修改後的哈希值與最初存儲進HashSet集合中時的哈希值就不一樣了，在這種狀況下，即便在contains方法使用該對象的當前引用做爲的參數去HashSet集合中檢索對象，也將返回找不到對象的結果，這也會致使沒法從HashSet集合中單獨刪除當前對象，形成內存泄露。
82、能不能本身寫個類，也叫java.lang.String？
能夠，若是非要實現java.lang.String，須要自已寫ClassLoader，否則JVM優先加載默認rt.jar中的java.lang.String。
能夠，但在應用的時候，須要用本身的類加載器去加載，不然，系統的類加載器永遠只是去加載rt.jar包中的那個java.lang.String。因爲在tomcat的web應用程序中，都是由webapp本身的類加載器先本身加載WEB-INF/classess目錄中的類，而後才委託上級的類加載器加載，若是咱們在tomcat的web應用程序中寫一個java.lang.String，這時候Servlet程序加載的就是咱們本身寫的java.lang.String，可是這麼幹就會出不少潛在的問題，原來全部用了java.lang.String類的都將出現問題。
雖然java提供了endorsed技術，能夠覆蓋jdk中的某些類，可是，可以被覆蓋的類是有限制範圍，反正不包括java.lang這樣的包中的類。
（下面的例如主要是便於你們學習理解只用，不要做爲答案的一部分，不然，人家懷疑是題目泄露了）例如，運行下面的程序：
package java.lang;
public class String {
public static void main(String[] args) {
System.out.println("string");
}
}
報告的錯誤以下：
java.lang.NoSuchMethodError:main
Exception inthread "main"
這是由於加載了jre自帶的java.lang.String，而該類中沒有main方法。
83. 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和strictf p，都是非訪問修飾符，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-staticmethods。可改爲"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("Dosomething ...");
}
}
這個好像很明顯。
答案: 正確。歷來沒有人說過Java的Class名字必須和其文件名相同。但public class的名字必須和文件名相同，若是main方法是public，則爲程序的入口方法，而爲private只是普通的靜態方法而已。
10．
interface A {
int x = 0;
}
class D {
int x = 2;
}
class B extends D {
int x = 1;
}
class C extends B implements A {
public void pX() {
System.out.println(super.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());
}
}
這個錯誤不容易發現。
答案: 錯。"interfaceRollable extends Playable, Bounceable"沒有問題。interface可繼承多個interfaces，因此這裏沒錯。問題出在interface Rollable裏的"Ball ball =new Ball("PingPang");"。任何在interface裏聲明的interface variable (接口變量，也可稱成員變量)，默認爲public static final。也就是說"Ball ball = new Ball("PingPang");"其實是"public staticfinal Ball ball = new Ball("PingPang");"。在Ball類的Play()方法中，"ball = newBall("Football");"改變了ball的reference，而這裏的ball來自Rollable interface，Rollable interface裏的ball是public static final的，final的object是不能被改變reference的。所以編譯器將在"ball = newBall("Football");"這裏顯示有錯。
84、SSH集成方式
Spring是一個容器，能夠把Struts的Action對象和Hibernate的SessionFactory對象、事務管理器管理起來，負責這些對象的生命週期，包括對象的建立、裝載、銷燬，從而使開發人員只去實現具體的業務邏輯。具體集成方式以下：
1. 在web.xml中配置struts的servlet或filter入口類，同時在web.xml中配置spring的listener和配置文件路徑
2. 引用SSH所需的jar包放在WEB-INF/lib下，須要有struts-spring-plugin.jar
3. 在struts.xml配置中，把Struts的Action類交由Spring託管
4. 把Hibernate所需的DataSource、SessionFactory、TranscationManager、HibernateTemplate配置在Spring的配置文件中
5. Dao層的類有時須要繼承HiberateDaoSupport類，若是有HibernateTemplate時，能夠不繼承
6. 把Action、Service、Dao等對象註冊到Spring中管理
二.算法與編程
1、編寫一個程序，將a.txt文件中的單詞與b.txt文件中的單詞交替合併到c.txt文件中，a.txt文件中的單詞用回車符分隔，b.txt文件中用回車或空格進行分隔。
package com.bwie.interview;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.util.StringTokenizer;
public class AnswerB01 {
public static void main(String[] args) throws IOException {
StringTokenizer tokenizer1 = getTokenzer("/a.txt");
StringTokenizer tokenizer2 = getTokenzer("/b.txt");
PrintStream out = new PrintStream("C:/c.txt");
while (tokenizer1.hasMoreTokens() && tokenizer2.hasMoreTokens()) {
out.println(tokenizer1.nextToken());
out.println(tokenizer2.nextToken());
}
out.close();
}
private static StringTokenizer getTokenzer(String fileName) throws IOException {
InputStreamReader reader = new InputStreamReader(AnswerB01.class.getResourceAsStream(fileName));
StringBuilder builder = new StringBuilder(1000);
int length = -1;
char[] cs = new char[1024];
while ((length = reader.read(cs)) != -1) {
builder.append(cs, 0, length);
}
reader.close();
return new StringTokenizer(builder.toString());
}
}
2、編寫一個程序，將d:\java目錄下的全部.java文件複製到d:\jad目錄下，並將原來文件的擴展名從.java改成.jad。
答：listFiles方法接受一個FileFilter對象，這個FileFilter對象就是過慮的策略對象，不一樣的人提供不一樣的FileFilter實現，即提供了不一樣的過濾策略。
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FilenameFilter;
import java.io.IOException;
public class AnswerB02 {
public static void main(String[] args) throws IOException {
File sourceFolder = new File("D:/java");
File[] files = sourceFolder.listFiles(new JavaFileFilter());
for (File file : files) {
String absolutePath = file.getName();
String targetFile = "D:/jad/" + absolutePath.substring(0, absolutePath.length() - 5) + ".jad";
copy(file, new File(targetFile));
}
}
private static void copy(File source, File target) throws IOException {
FileInputStream input = new FileInputStream(source);
FileOutputStream out = new FileOutputStream(target);
int length = -1;
byte[] bs = new byte[1024];
while ((length = input.read(bs)) != -1) {
out.write(bs, 0, length);
}
input.close();
out.close();
}
private static final class JavaFileFilter implements FilenameFilter {
@Override
public boolean accept(File dir, String name) {
return name.endsWith(".java");
}
}
}
3、編寫一個截取字符串的函數，輸入爲一個字符串和字節數，輸出爲按字節截取的字符串，但要保證漢字不被截取半個，如「我ABC」，4，應該截取「我AB」，輸入「我ABC漢DEF」，6，應該輸出「我ABC」，而不是「我ABC+漢的半個」。
import java.io.IOException;
public class AnswerB03 {
public static void main(String[] args) throws IOException {
String s = "我ABC漢DEF";
System.out.println(substring(s, 6));
}
public static String substring(String s, int length) {
char[] cs = s.toCharArray();
StringBuilder builder = new StringBuilder();
int count = 0;
for (char c : cs) {
if (isAsc(c)) {
count++;
} else {
count += 2;
}
if (count > length) {
break;
}
builder.append(c);
}
return builder.toString();
}
public static boolean isAsc(char c) {
return c < 128;
}
}
4、有一個字符串，其中包含中文字符、英文字符和數字字符，請統計和打印出各個字符的個數。
答：哈哈，其實包含中文字符、英文字符、數字字符原來是出題者放的煙霧彈。
String content = "中國aadf的111薩bbb菲的zz薩菲";
HashMap<Character, Integer> map = new HashMap<Character, Integer>();
for (int i = 0; i < content.length; i++) {
char c = content.charAt(i);
Integer count = map.get(c);
if (count == null) {
count = 0;
}
count = count + 1;
map.put(c, count);
}
Set<Entry> entries = map.entrySet();
for (Entry entry : entries) {
system.out.println(entry.getkey() + ":" + entry.getValue());
}
若是一串字符如"aaaabbc中國1512"要分別統計英文字符的數量，中文字符的數量，和數字字符的數量，假設字符中沒有中文字符、英文字符、數字字符以外的其餘特殊字符。
int engishCount;
int chineseCount;
int digitCount;
for (int i = 0; i < str.length; i++) {
char ch = str.charAt(i);
if (ch >= '0' && ch <= '9' || ch == '.') {
digitCount++;
} else if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')) {
engishCount++;
} else {
chineseCount++;
}
}
5、說明生活中遇到的二叉樹，用java實現二叉樹
這是組合設計模式。
我有不少個(假設10萬個)數據要保存起來，之後還須要從保存的這些數據中檢索是否存在某個數據，（我想說出二叉樹的好處，該怎麼說呢？那就是說別人的缺點），假如存在數組中，那麼，碰巧要找的數字位於99999那個地方，那查找的速度將很慢，由於要從第1個依次日後取，取出來後進行比較。平衡二叉樹（構建平衡二叉樹須要先排序，咱們這裏就不做考慮了）能夠很好地解決這個問題，但二叉樹的遍歷（前序，中序，後序）效率要比數組低不少，原理以下圖：
代碼以下：
public class AnswerB04 {
public static void main(String[] args) {
Node root = makeupTree();
traverse(root);
}
private static void traverse(Node node) {
if (node == null) {
return;
}
traverse(node.left);
System.out.println(node.value);
traverse(node.right);
}// 11 1 12 0 21 2 22
private static Node makeupTree() {
Node root = new Node(0);
Node node1 = new Node(1);
Node node2 = new Node(2);
Node node11 = new Node(11);
Node node12 = new Node(12);
Node node21 = new Node(21);
Node node22 = new Node(22);
root.left = node1;
root.right = node2;
node1.left = node11;
node1.right = node12;
node2.left = node21;
node2.right = node22;
return root;
}
public static class Node {
public Node left;
public Node right;
public int value;
public Node(int value) {
this.value = value;
}
}
}
6、從相似以下的文本文件中讀取出全部的姓名，並打印出重複的姓名和重複的次數，並按重複次數排序：
1,張三,28
2,李四,35
3,張三,28
4,王五,35
5,張三,28
6,李四,35
7,趙六,28
8,田七,35
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
public class AnswerB06 {
public static void main(String[] args) throws IOException {
BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream("/person.txt")));
Map<String, Integer> nameMap = new HashMap<String, Integer>();
String line = null;
while ((line = reader.readLine()) != null) {
String[] segments = line.split(",", -1);
String name = segments[1];
Integer count = nameMap.get(name);
if (count == null) {
count = 0;
}
count++;
nameMap.put(name, count);
}
reader.close();
List<PersonCount> personCounts = new ArrayList<PersonCount>();
Set<String> names = nameMap.keySet();
for (String name : names) {
PersonCount personCount = new PersonCount();
personCount.name = name;
personCount.count = nameMap.get(name);
personCounts.add(personCount);
}
Collections.sort(personCounts);
for (PersonCount personCount : personCounts) {
System.out.println(personCount.name + "=" + personCount.count);
}
}
static class PersonCount implements Comparable<PersonCount> {
public String name;
public int count;
@Override
public int compareTo(PersonCount o) {
return count - o.count;
}
}
}
7、寫一個Singleton出來。
第一種：飽漢模式
public class SingleTon {
private SingleTon() {
}
// 實例化放在靜態代碼塊裏可提升程序的執行效率，但也可能更佔用空間
private final static SingleTon instance = new SingleTon();
public static SingleTon getInstance() {
return instance;
}
}
第二種：飢漢模式
public class SingleTon {
private SingleTon() {
}
private static SingleTon instance;
public static synchronized SingleTon getInstance() {
if (instance == null) {
instance = new SingleTon();
}
return instance;
}
}
第三種：用枚舉
public enum SingleTon {
ONE;
}
第四種，雙重校驗：
public class SingleTon {
private SingleTon() {
}
private static SingleTon instance;
public static SingleTon getInstance() {
if (instance == null) {
synchronized(SingleTon.class) {
if (instance == null) {
instance = new SingleTon();
}
}
}
return instance;
}
}
其餘形式:
定義一個類，它的構造函數爲private的，全部方法爲static的。
通常認爲第一種形式要更加安全些
8、遞歸算法題1
一個整數，大於0，不用循環和本地變量，按照n，2n，4n，8n的順序遞增，當值大於5000時，把值按照指定順序輸出來。
例：n=1237
則輸出爲：
9896，
4948，
2474，
1237，
提示：寫程序時，先致謝按遞增方式的代碼，寫好遞增的之後，再增長考慮遞減部分。
public static void doubleNum(int n) {
if (n <= 5000)
doubleNum(n * 2);
System.out.println(n);
}
9、遞歸算法題2
第1我的10，第2個比第1我的大2歲，依次遞推，請用遞歸方式計算出第8我的多大？
package cn.itcast;
import java.util.Date;
public class A1 {
public static void main(String[] args) {
System.out.println(computeAge(8));
}
public static int computeAge(int n) {
if (n == 1)
return 10;
return computeAge(n - 1) + 2;
}
}
public static void toBinary(int n, StringBuffer result) {
if (n / 2 != 0)
toBinary(n / 2, result);
result.append(n % 2);
}
10、排序都有哪幾種方法？請列舉。用JAVA實現一個快速排序。
排序算法有：
冒泡排序、插值排序、選擇排序、HASH排序、快速排序
冒泡排序：
public static void bubbleSort(int[] array) {
for (int i = 1; i < array.length; i++) {
for (int j = 0; j < i; j++) {
if (array[i] < array[j]) {
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}
}
}
}
快速排序：
public class QuickSort {
public void quickSort(String[] strDate, int left, int right) {
String middle, tempDate;
int i, j;
i = left;
j = right;
middle = strDate[(i + j) / 2];
do {
while (strDate[i].compareTo(middle) < 0 && i < right)
i++; // 找出左邊比中間值大的數
while (strDate[j].compareTo(middle) > 0 && j > left)
j--; // 找出右邊比中間值小的數
if (i <= j) { // 將左邊大的數和右邊小的數進行替換
tempDate = strDate[i];
strDate[i] = strDate[j];
strDate[j] = tempDate;
i++;
j--;
}
} while (i <= j); // 當二者交錯時中止
if (i < right) {
quickSort(strDate, i, right);
}
if (j > left) {
quickSort(strDate, left, j);
}
}
public static void main(String[] args) {
String[] strVoid = new String[] { "11", "66", "22", "0", "55", "22", "0", "32" };
QuickSort sort = new QuickSort();
sort.quickSort(strVoid, 0, strVoid.length - 1);
for (int i = 0; i < strVoid.length; i++) {
System.out.println(strVoid[i] + " ");
}
}
}
11、有數組a[n]，用java代碼將數組元素順序顛倒
public class AnswerB11 {
public static void main(String[] args) {
int[] array = { 2, 25, 21, 63, 234, 83 };
reverse(array);
System.out.println(Arrays.toString(array));
}
private static void reverse(int[] array) {
for (int i = 0; i < array.length / 2; i++) {
int temp = array[i];
array[i] = array[array.length - 1 - i];
array[array.length - 1 - i] = temp;
}
}
}
12、金額轉換，阿拉伯數字的金額轉換成中國傳統的形式如：（￥1011）－>（一千零一拾一元整）輸出。
public class AnswerB12 {
private static final char[] data = new char[] { '零', '壹', '貳', '叄', '肆', '伍', '陸', '柒', '捌', '玖' };
private static final char[] units = new char[] { '元', '拾', '佰', '仟', '萬', '拾', '佰', '仟', '億' };
public static void main(String[] args) {
System.out.println(toUpcaseMoney(convert(100215)));
}
private static String toUpcaseMoney(String money) {
return new StringBuilder(money).toString().replaceAll("零[拾佰仟]", "零").replaceAll("零+萬", "萬").replaceAll("零+元", "元").replaceAll("零+", "零");
}
public static String convert(int money) {
StringBuffer sbf = new StringBuffer();
int unit = 0;
while (money != 0) {
sbf.insert(0, units[unit++]);
int number = money % 10;
sbf.insert(0, data[number]);
money /= 10;
}
return sbf.toString();
}
}
13、不使用遞歸遍歷二叉樹
import java.util.Stack;
public class AnswerB13 {
// 兩次pop
public static void main(String[] args) {
Node tree = makeupTree();
Stack<Node> stack = new Stack<Node>();
Node currentNode = tree;
while (currentNode != null) {
System.out.println(currentNode.value);
stack.push(currentNode);
currentNode = currentNode.left;
Node parent = stack.pop();
currentNode = parent.right;
if (currentNode == null) {
if (stack.isEmpty()) {
break;
}
Node parentParent = stack.pop();
currentNode = parentParent.right;
}
}
}
// 一次pop
public static void main(String[] args) {
Node tree = makeupTree();
Stack<Node> nodeStack = new Stack<Node>();
Node current = tree;
while (current != null) {
System.out.println(current.value);
Node parent = current;
current = current.left;
if (current == null) {
if (!nodeStack.isEmpty()) {
Node parentNode = nodeStack.pop();
current = parentNode.right;
}
} else {
nodeStack.push(parent);
}
}
}
private static Node makeupTree() {
Node root = new Node(0);
Node node1 = new Node(1);
Node node2 = new Node(2);
Node node11 = new Node(11);
Node node12 = new Node(12);
Node node21 = new Node(21);
Node node22 = new Node(22);
root.left = node1;
root.right = node2;
node1.left = node11;
node1.right = node12;
node2.left = node21;
node2.right = node22;
return root;
}
public static class Node {
public Node left;
public Node right;
public int value;
public Node(int value) {
this.value = value;
}
}
}
14、以最快的效率找出一個數組中第二大的數
public class QuestionB14 {
public static void main(String[] args) {
int[] nums = { 1, 2, 7, 4, 6, 9, 5, 3, 65, 23, 87 };
int max1 = Integer.MIN_VALUE;
int max2 = Integer.MIN_VALUE;
for (int i = 0; i < nums.length; i++) {
int current = nums[i];
if (current < max2) {
continue;
}
if (current > max1) {
max2 = max1;
max1 = current;
continue;
}
max2 = current;
}
System.out.println(max2);
}
}
三. html&JavaScript&ajax部分
1. 判斷第二個日期比第一個日期大
如何用腳本判斷用戶輸入的字符串是下面的時間格式2004-11-21必需要保證用戶的輸入是此格式，而且是時間，好比說月份不大於12等等，另外我須要用戶輸入兩個，而且後一個要比前一個晚，只容許用JAVASCRIPT，請詳細幫助做答，,
//這裏可用正則表達式判斷提早判斷一下格式，而後按下提取各時間字段內容
<script type="text/javascript">
window.onload = function() {
//這麼寫是爲了實現js代碼與html代碼的分離，當我修改js時，不能影響html代碼。
document.getElementById("frm1").onsubmit = function() {
vard1 = this.d1.value;
vard2 = this.d2.value;
if (!verifyDate(d1)) {
alert("第一個日期格式不對");
return false;
}
if (!verifyDate(d2)) {
alert("第二個日期格式不對");
return false;
}
if (!compareDate(d1, d2)) {
alert("第二個日期比第一日期小");
return false;
}
};
}
function compareDate(d1, d2) {
var arrayD1 = d1.split("-");
var date1 = new Date(arrayD1[0], arrayD1[1], arrayD1[2]);
var arrayD2 = d2.split("-");
var date2 = new Date(arrayD2[0], arrayD2[1], arrayD2[2]);
return date1 > date2;
}
function verifyDate(d) {
var datePattern=/^\d{4}-(0?[1-9]|1[0-2])-(0?[1-9]|[1-2]\d|3[0-1])$/;
return datePattern.test(d);
}
</script>
<body>
<form id="frm1" action="xxx.html">
<input type="text" name="d1" />
<input type="text" name="d2" />
<input type="submit" />
</form>
</body>
2. 用table顯示n條記錄，每3行換一次顏色，即1，2，3用紅色字體，4，5，6用綠色字體，7，8，9用紅顏色字體。
<body>
<table id="tbl">
<tr><td>1</td></tr>
<tr><td>2</td></tr>
<tr><td>3</td></tr>
<tr><td>4</td></tr>
<tr><td>5</td></tr>
<tr><td>6</td></tr>
<tr><td>7</td></tr>
<tr><td>8</td></tr>
<tr><td>9</td></tr>
<tr><td>10</td></tr>
</table>
</body><script type="text/javascript">
window.onload = function() {
var tbl = document.getElementById("tbl");
rows = tbl.getElementsByTagName("tr");
for (i = 0; i < rows.length; i++) {
var j = parseInt(i / 3);
if (j % 2 == 0)
rows[i].style.backgroundColor = "#f00";
else
rows[i].style.backgroundColor = "#0f0";
}
}
</script>
3、HTML的 form提交以前如何驗證數值文本框的內容所有爲數字?不然的話提示用戶並終止提交?
<form onsubmit='chkForm(this)'>
<input type="text" name="d1" />
<input type="submit" />
</form>
<script type="text/javascript">
function chkForm(this){
var value1 = this.d1.value;
var len =value1.length;
for(var i=0;i<len;i++){
if(value1.charAt(i)>"9"|| value1.charAt(i)<"0"){
alert("含有非數字字符");
return false;
}
}
return true;
}
</script>
4、請寫出用於校驗HTML文本框中輸入的內容所有爲數字的javascript代碼
<input type="text" id="d1" onblur=" chkNumber(this)"/>
<script type="text/javascript">
function chkNumber(eleText){
var value = eleText.value;
var len = value.length;
for(var i=0;i<len;i++){
if(value.charAt(i)>"9"|| value.charAt(i)<"0"){
alert("含有非數字字符");
eleText.focus();
break;
}
}
}
</script>
除了寫完代碼，還應該在網頁上寫出實驗步驟和在代碼中加入實現思路，讓面試官一看就明白你的意圖和檢查你的結果。
5、說說你用過那些ajax技術和框架，說說它們的區別
jQuery、ExtJs、Dojo、DWR、Pushlet
四. Java web部分
1、Tomcat的優化經驗
1. 內存優化-Xms
2. 增長線程數maxThreads="150"
3. 修正server.xml中的中文編碼
4. BIO改NIO
5.
6.
2、HTTP請求的GET與POST方式的區別
答:
1. URL地址長度不一樣, GET支持的字符少
2. GET的密碼是明文，安全問題，容易受到黑客攻擊
3. GET只傳輸文本，不支持文件傳輸
4. GET方式一般用來查詢，不用來修改數據，是冪等操做，修改數據用POST
3、解釋一下什麼是servlet;
答: 一般Servlet特指HttpServlet，用來接受瀏覽器的訪問請求，瀏覽器最經常使用的請求爲GET和POST方式，還有其它五種，而HttpServlet分別有七個方法(PUT、DELETE、HEADER、TRACE、OPTION)處理這些類型的請求，另有一個是J2EE不支持的，是CONNECT。Servlet是J2EE規範中的重要成員，是構成WEB的重要組件
4、說一說Servlet的生命週期?
1. 加載Servlet類
2. 實例化
3. 初始化init
4. 處理請求 service à 進一步調用doGet/doPost方法
5. 銷燬 destory
5、Servlet的基本架構
1. 定義一個Servlet類，繼承HttpServlet抽象類
2. 在web.xml中定義一個servlet標籤，配置類名和servlet名
3. 配置servlet處理的URL請求鏈接，能夠用模糊匹配
4. 在J2EE生命週期中，一個Servlet只有一個實例
5. 一個Servlet能夠爲多個請求服務，每一個請求在獨立的線程中執行
6、Servlet API中forward()與redirect()的區別？
Forward: 服務器端內部跳轉，URL地址不變，屬於單次請求
Redirect: 服務器通知瀏覽器中轉，URL地址發生改變，是兩次跳轉
Forward不能跨域跳轉
Redirect能夠跨域跳轉
Forward在兩個頁面傳值能夠經過parameter，也能夠經過attribute，能傳遞Java對象
Redirect在兩個頁面傳值只能經過parameter，在URL中傳參
7、什麼狀況下調用doGet()和doPost()？
Jsp頁面中的FORM標籤裏的method屬性爲get時調用doGet()，爲post時調用doPost()。
在地址欄進接輸入URL回車，會調用doGet()方法
8、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)：刪除請求中的一個屬性
9、request.getAttribute()和 request.getParameter()有何區別?
1. getParameter是表單數據或URL參數，不能在server端修改
getAttribute是兩個頁面或servlet之間內部跳轉傳遞對象參數，能夠修改
2. getParameter的類型只能是String
getAttribute的類型能夠是任意Java對象
3. forward跳轉時纔有attribute，redirect時，attribute所有爲null
10. jsp有哪些內置對象?做用分別是什麼?分別有什麼方法？
JSP共有如下9個內置的對象：
request 用戶端請求，此請求會包含來自GET/POST請求的參數
response 網頁傳回用戶端的迴應
pageContext 網頁的屬性是在這裏管理
session 與請求有關的會話期
application servlet 正在執行的內容
out 用來傳送回應的輸出
config servlet的構架部件
page JSP網頁自己
exception 針對錯誤網頁，未捕捉的例外
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實例
12. jsp生命週期?
1. JSP生成.java文件
2. 編譯成.class文件
3. 加載jsp.class類
4. 實例化
5. 初始化_jspInit
6. 處理請求 _jspService
7. 銷燬 _jspDestory
12. jsp有哪些動做?做用分別是什麼?
（這個問題彷佛不重要，不明白爲什麼有此題）
答:JSP共有如下6種基本動做
jsp:include：在頁面被請求的時候引入一個文件。
jsp:useBean：尋找或者實例化一個JavaBean。
jsp:setProperty：設置JavaBean的屬性。
jsp:getProperty：輸出某個JavaBean的屬性。
jsp:forward：把請求轉到一個新的頁面。
jsp:plugin：根據瀏覽器類型爲Java插件生成OBJECT或EMBED標記
13、JSP的經常使用指令
isErrorPage(是否能使用Exception對象)，isELIgnored(是否忽略表達式)
14. JSP中動態INCLUDE與靜態INCLUDE的區別？
<jsp:include page=included.jsp flush=true />它老是會檢查所含文件中的變化，適合用於包含動態頁面，而且能夠帶參數 靜態INCLUDE用include僞碼實現，不會檢查所含文件的變化，適用於包含靜態頁面 <%@include file=included.htm %>
標籤不一樣
執行的時機不一樣，動態include是在運行時把兩個JSP合併，靜態include是在編譯期合併動態include在頁面發生改變時，能及時更新，而靜態頁面，不會再次從新編譯
15、兩種跳轉方式分別是什麼?有什麼區別?
跟6題同
16、頁面間對象傳遞的方法
1. request
2. session
3. application
4. cookie
5. URL地址
17、JSP和Servlet有哪些相同點和不一樣點，他們之間的聯繫是什麼？
1. JSP編譯後就是Servlet，所以本質上講，JSP就是Servlet
2. JSP經常使用來作展現層，Servlet經常使用來作控制層
3. JSP容易編寫，美工也能夠參與修改，但Servlet專業技術要求較高
JSP是Servlet技術的擴展，本質上是Servlet的簡易方式，更強調應用的外表表達。JSP編譯後是"類servlet"。Servlet和JSP最主要的不一樣點在於，Servlet的應用邏輯是在Java文件中，而且徹底從表示層中的HTML裏分離開來。而JSP的狀況是Java和HTML能夠組合成一個擴展名爲.jsp的文件。JSP側重於視圖，Servlet主要用於控制邏輯。
18、MVC的各個部分都有那些技術來實現?如何實現?
MVC是Model－View－Controller的簡寫。
Model表明的是應用的業務邏輯（經過JavaBean，EJB組件實現），一般是數據訪問層。
View是應用的表示層（由JSP頁面產生）或模板框架，如freemarker、velocity
Controller是提供應用的處理過程控制（通常是一個Servlet），負責頁面間跳轉
經過這種設計模型把應用邏輯，處理過程和顯示邏輯分紅不一樣的組件實現。這些組件能夠進行交互和重用。
Model：JDBC、Hibernate、MyBatis
View：JSP、FreeMarker、Struts
Controller：Spring MVC、Struts、Servlet
SpringSide集成Spring、Struts、Hibernate、WebService、View展現框架，做者江南白衣
19、咱們在web應用開發過程當中常常遇到輸出某種編碼的字符，如iso-8859-1等，如何輸出一個某種編碼的字符串？
public String translate(String str) {
try {
return new String(str.getBytes("ISO-8859-1"), "GBK").trim();
} catch (Exception e) {
System.err.println(e.getMessage());
throw new RuntimeException(e);
}
}
20、如今輸入n個數字，以逗號分開；而後可選擇升或者降序排序；按提交鍵就在另外一頁面顯示按什麼排序，結果爲，提供reset
五.數據庫部分
1、根據部門號從高到低，工資從低到高列出每一個員工的信息。
employee: eid, ename, salary, dept_id
select * from employee order by dept_id desc, salary;
2、列出各個部門中工資高於本部門的平均工資的員工數和部門號，並按部門號排序
employee: eid, ename, salary, dept_id
select count(*), a.dept_id
from employee a
where
a.salary > (select avg(b.salary) from employee b where b.dept_id = a.dept_id)
group by a.dept_id
order by a.dept_id
3、存儲過程、函數與觸發器必須講，常常被面試到?
create or replace procedure insert_student (_name varchar, _age int , out _id int)
declear
a varchar;
begin
insert into studentvalue(null,_name,_age);
select max(stuId) into _id from student;
end;
call insert_student('wfz',23,@id);
select @id;
mysql> create trigger update_student BEFORE update on student FOR EACH ROW
-> select * from student;
觸發器不容許返回結果
create trigger update_StudentBEFORE update on student FOR EACH ROW
insert into student value(null,'zxx',28);
mysql的觸發器目前不能對當前表進行操做
create trigger update_StudentBEFORE update on student FOR EACH ROW
delete from articles where id=8;
這個例子不是很好，最好是用刪除一個用戶時，順帶刪除該用戶的全部帖子
這裏要注意使用OLD.id
觸發器用處仍是不少的，好比校內網、開心網、Facebook，你發一個日誌，自動通知好友，其實就是在增長日誌時作一個後觸發，再向通知表中寫入條目。由於觸發器效率高。而UCH沒有用觸發器，效率和數據處理能力都很低。
存儲過程的實驗步驟：
mysql> delimiter |
mysql> create procedure insertArticle_Procedure (pTitle varchar(50),pBid int,out
pId int)
-> begin
-> insert into article1value(null,pTitle,pBid);
-> select max(id) into pId fromarticle1;
-> end;
-> |
Query OK, 0 rows affected (0.05sec)
mysql> callinsertArticle_Procedure('傳智播客',1,@pid);
-> |
Query OK, 0 rows affected (0.00sec)
mysql> delimiter ;
mysql> select @pid;
| @pid |
| 3 |
1 row in set (0.00 sec)
mysql> select * fromarticle1;
| id |
title |
bid |
| 1 |
test |
1 |
| 2 |
chuanzhiboke |
1 |
| 3 |
傳智播客 |
1 |
3 rows in set (0.00 sec)
觸發器的實驗步驟：
create table board1(id intprimary key auto_increment,name varchar(50),ar
ticleCount int);
create table article1(id intprimary key auto_increment,title varchar(50)
,bid int referencesboard1(id));
delimiter |
create triggerinsertArticle_Trigger after insert on article1 for each ro
w begin
-> update board1 setarticleCount=articleCount+1 where id= NEW.bid;
-> end;
-> |
delimiter ;
insert into board1 value(null,'test',0);
insert into article1value(null,'test',1);
還有，每插入一個帖子，都但願將版面表中的最後發帖時間，帖子總數字段進行同步更新，用觸發器作效率就很高。下次課設計這樣一個案例，寫觸發器時，對於最後發帖時間可能須要用declare方式聲明一個變量，或者是用NEW.posttime來生成。
4、數據庫三範式是什麼?
第一範式（1NF）：字段具備原子性,不可再分。全部關係型數據庫系統都知足第一範式。
數據庫表中的字段都是單一屬性的，不可再分。例如，姓名字段，其中的姓和名必須做爲一個總體，沒法區分哪部分是姓，哪部分是名，若是要區分出姓和名，必須設計成兩個獨立的字段。
第二範式（2NF）：在第一範式（1NF）的基礎上創建起來的，即知足第二範式（2NF）必須先知足第一範式（1NF）。
要求數據庫表中的每一個實例或行必須能夠被惟一地區分。一般須要爲表加上一個列，以存儲各個實例的唯一標識。這個唯一屬性列被稱爲主關鍵字或主鍵。
第二範式（2NF）要求實體的屬性徹底依賴於主關鍵字。所謂徹底依賴是指不能存在僅依賴主關鍵字一部分的屬性，若是存在，那麼這個屬性和主關鍵字的這一部分應該分離出來造成一個新的實體，新實體與原實體之間是一對多的關係。爲實現區分一般須要爲表加上一個列，以存儲各個實例的唯一標識。簡而言之，第二範式就是非主屬性非部分依賴於主關鍵字。
第三範式的要求以下：
知足第三範式（3NF）必須先知足第二範式（2NF）。簡而言之，第三範式（3NF）要求一個數據庫表中不包含已在其它表中已包含的非主關鍵字信息。
因此第三範式具備以下特徵：
1，每一列只有一個值
2，每一行都能區分。
3，每個表都不包含其餘表已經包含的非主關鍵字信息。
例如，帖子表中只能出現發帖人的id，而不能出現發帖人的id，還同時出現發帖人姓名，不然，只要出現同一發帖人id的全部記錄，它們中的姓名部分都必須嚴格保持一致，這就是數據冗餘。
5、說出一些數據庫優化方面的經驗?
1. 程序優化，用PrepareedStatement進行增刪改查
2. 程序優化，儘可能批量處理，避免逐條處理，減少IO數
3. 查詢結果不要用*來查詢全部字段，要明確指明結果字段
4. 減小多表鏈接數，儘可能少的表進行鏈接
5. 錶鏈接時，儘可能用主鍵進行鏈接或用惟一索引
6. 表的查詢多時，必定創建索引
7. 根據查詢條件，創建索引，若是查詢條件不止一個時，使用組合索引
8. 在查詢條件表達式的左側儘可能不要使用函數，不然索引失效
9. 若是不得不用函數，則創建函數索引
10. 使用合適的索引，例如時間索引、哈希索引、聚簇索引
11. 若是有like話，儘可能避免%xxx%兩側都有%的條件，單側%能夠使用索引，多側不能夠
12. 儘可能不用數據庫，使用緩存
13. 能夠考慮用nosql數據庫提升效率
14. SQL的條件表達式，在Oracle中，是按倒序使用索引的
15. 若是用DDL改動了數據庫表字段，須要重建索引，否則索引失效
16. SQL儘可能不要有多餘的空格和換行
17. 使用分佈式數據庫
18. 合理建立表分區表空間
19. 創建索引時字段不能有null值
20. 使用數據庫鏈接池
21. 條件中與null比較索引無效
22. 表結構改動時索引所有失效
22. 使用存儲過程
6、union和union all有什麼不一樣?
union和union all都是合併結果集
union的兩個select查詢字段相同，參數類型的順序相同，Hibernate的HQL不支持union。
區別是：
1. union去除兩個結果集的重複記錄，union all不去除重複記錄，是兩個結果集的加和
2. union效率低，union all效率高
6.1、表test中有兩個字段a、b，都爲數值型，若是a大於b，取a列的值，若是a不大於b，取b列的值，寫出你認爲最有效率的SQL，兼容全部數據庫。
select a from test where a > b
union all
select b from test where a <= b
oracle:
select (case when a > b then a else b end) as result from test
7、分頁語句
取出sql表中第31到40的記錄（以自動增加ID爲主鍵）
sql server方案1：
select top 10 * from t where id not in (select top 30 id from t order by id ) orde by id
sql server方案2：
select top 10 * from t where id in (select top 40 id from t order by id) order by id desc
mysql方案：select * from t order by id limit 30,10
oracle方案：select * from (select rownum r,* from t where r<=40) where r>30
8.用一條SQL語句查詢出每門課都大於80分的學生姓名
name kecheng fenshu
張三 語文 81
張三 數學 75
李四 語文 76
李四 數學 90
王五 語文 81
王五 數學 100
王五 英語 90
答案：
A：select distinct name from score where name not in (select distinct name from score where fenshu <=80)
B：select distinct t1.name from score t1 where 80< all (select fenshu from score t2 where name=t1.name);
C：select distinct name from score t1 where not exists (select * from score t2 where t2.name = t1.name and t2.fenshu < 80);
9.全部部門之間的比賽組合
一個叫department的表，裏面只有一個字段name,一共有4條紀錄，分別是a,b,c,d,對應四個球對，如今四個球對進行比賽，用一條sql語句顯示全部可能的比賽組合.
select a.name, b.name
from team a, team b
where a.name > b.name
10.每月份的發生額都比101科目多的科目
請用SQL語句實現：從TestDB數據表中查詢出全部月份的發生額都比101科目相應月份的發生額高的科目。請注意：TestDB中有不少科目，都有1－12月份的發生額。
AccID：科目代碼，Occmonth：發生額月份，DebitOccur：發生額。
數據庫名：JcyAudit，數據集：Select * from TestDB
準備數據的sql代碼：
drop table if exists TestDB;
create table TestDB(id int primary key auto_increment,AccIDvarchar(20), Occmonth date, DebitOccur bigint);
insert into TestDB values
(null,'101','1988-1-1',100),
(null,'101','1988-2-1',110),
(null,'101','1988-3-1',120),
(null,'101','1988-4-1',100),
(null,'101','1988-5-1',100),
(null,'101','1988-6-1',100),
(null,'101','1988-7-1',100),
(null,'101','1988-8-1',100);
--複製上面的數據，故意把第一個月份的發生額數字改小一點
insert into TestDB values
(null,'102','1988-1-1',90),
(null,'102','1988-2-1',110),
(null,'102','1988-3-1',120),
(null,'102','1988-4-1',100),
(null,'102','1988-5-1',100),
(null,'102','1988-6-1',100),
(null,'102','1988-7-1',100),
(null,'102','1988-8-1',100);
--複製最上面的數據，故意把全部發生額數字改大一點
insert into TestDB values
(null,'103','1988-1-1',150),
(null,'103','1988-2-1',160),
(null,'103','1988-3-1',180),
(null,'103','1988-4-1',120),
(null,'103','1988-5-1',120),
(null,'103','1988-6-1',120),
(null,'103','1988-7-1',120),
(null,'103','1988-8-1',120);
--複製最上面的數據，故意把全部發生額數字改大一點
insert into TestDB values
(null,'104','1988-1-1',130),
(null,'104','1988-2-1',130),
(null,'104','1988-3-1',140),
(null,'104','1988-4-1',150),
(null,'104','1988-5-1',160),
(null,'104','1988-6-1',170),
(null,'104','1988-7-1',180),
(null,'104','1988-8-1',140);
--複製最上面的數據，故意把第二個月份的發生額數字改小一點
insert into TestDB values
(null,'105','1988-1-1',100),
(null,'105','1988-2-1',80),
(null,'105','1988-3-1',120),
(null,'105','1988-4-1',100),
(null,'105','1988-5-1',100),
(null,'105','1988-6-1',100),
(null,'105','1988-7-1',100),
(null,'105','1988-8-1',100);
答案：
select distinct AccID from TestDB
where AccID not in
(
select
TestDB.AccID
from
TestDB,
(select * from TestDB where AccID='101') asdb101
where
TestDB.Occmonth=db101.Occmonth
and TestDB.DebitOccur<=db101.DebitOccur
);
11.統計每一年每個月的信息
year month amount
1991 1 1.1
1991 2 1.2
1991 3 1.3
1991 4 1.4
1992 1 2.1
1992 2 2.2
1992 3 2.3
1992 4 2.4
查成這樣一個結果
year m1 m2 m3 m4
1991 1.1 1.2 1.3 1.4
1992 2.1 2.2 2.3 2.4
準備sql語句：
drop table if exists sales;
create table sales(id int auto_increment primary key,year varchar(10), month varchar(10), amount float(2,1));
insert into sales values
(null,'1991','1',1.1),
(null,'1991','2',1.2),
(null,'1991','3',1.3),
(null,'1991','4',1.4),
(null,'1992','1',2.1),
(null,'1992','2',2.2),
(null,'1992','3',2.3),
(null,'1992','4',2.4);
答案一：
select s.year ,
(select t.amount from sales t where t.month='1' and t.year= s.year) m1,
(select t.amount from sales t where t.month='2' and t.year= s.year) m2,
(select t.amount from sales t where t.month='3' and t.year= s.year) m3,
(select t.amount from sales t where t.month='4' and t.year= s.year) m4
from sales s
group by s.year;
答案二：
select
y.year,
(select t.amount from sales t where t.month='1' and t.year= y.year) m1,
(select t.amount from sales t where t.month='2' and t.year= y.year) m2,
(select t.amount from sales t where t.month='3' and t.year= y.year) m3,
(select t.amount from sales t where t.month='4' and t.year= y.year) m4
from
(select distinct year from sales s order by year) y
12.顯示文章標題，發帖人、最後回覆時間
文章表：article_id, title, post_user, post_date
回覆表：reply_id, article_id, reply_time, content
select
a.title, a.post_user, r.reply_time
from reply r
left join article a on a.article_id = r.article_id
where
r.reply_id =
(
select max(re.reply_id)
from reply re
where
re.article_id = r.article_id
)
13.刪除除了id號不一樣,其餘都相同的學生冗餘信息
學生表(student)以下:
id號 學號 姓名 課程編號 課程名稱 分數
id sid name cno cname score
1 2005001 張三 0001 數學 69
2 2005002 李四 0001 數學 89
3 2005001 張三 0001 數學 69
A: delete from student where id not in(select min(id) from student group by sid, name, cno, cname, score)
14.航空網的幾個航班查詢題：
表結構以下：
航班(flight){ID(flight_id),起飛城市ID(start_city_id) ,降落城市ID(end_city_id),起飛時間(start_time)}
城市(city){城市ID(city_id),城市名稱(city_name)}
1、查詢起飛城市是北京的全部航班，按到達城市的名字排序
select *
from flight f
left join city sc on sc.city_id = f.start_city_id
left join city ec on ec.city_id = f.end_city_id
where
sc.city_name = '北京'
order by ec.city_name
2、查詢北京到上海的全部航班紀錄（起飛城市，到達城市，起飛時間，航班號）
select sc.city_name, ec.city_name, f.start_time, flight_id
from flight f
left join city sc on sc.city_id = f.start_city_id
left join city ec on ec.city_id = f.end_city_id
where
sc.city_name = '北京'
and ec.city_name = '上海'
3、查詢具體某一天（2005-5-8）的北京到上海的的航班次數
select count(*)
from flight f
left join city sc on sc.city_id = f.start_city_id
left join city ec on ec.city_id = f.end_city_id
where
sc.city_name = '北京'
and ec.city_name = '上海'
and f.start_time >= to_date('2005-05-08','yyyy-mm-dd')
and f.start_time < to_date('2005-05-08','yyyy-mm-dd') + 1
15.查出比經理薪水還高的員工信息：
employee: id, name, salary, manager_id;
答案：
select *
from employee e
left join employee m on m.id = e.manager_id
where
e.salary > m.salary
16、求出小於45歲的各個老師所帶的大於12歲的學生人數
數據庫中有3個表 teacher表，student表，teacher_student關係表。
teacher表：teacher_id，name，age
student表：student_id，name，age
teacher_student表：teacher_id，student_id
答案一：
select count(*), ts.teacher_id
from teacher_student ts
left join teacher t on t.teacher_id = ts.teacher_id
left join student s on s.student_id = ts.student_id
where
t.age < 45
and s.age > 12
group by ts.teacher_id
答案二：
select count(*), ts.teacher_id
from teacher_student ts, teacher t, student s
where
t.teacher_id = ts.teacher_id
and s.student_id = ts.student_id
and t.age < 45
and s.age > 12
group by ts.teacher_id
17.求出發帖最多的人：
select max(post_count), b.post_user_id, u.name
from
(
select count(*) as post_count, a.post_user_id
from article a
group by a.post_user_id
) b
left join user u on u.user_id = b.post_user_id。
18、一個用戶表中有一個積分字段，假如數據庫中有100多萬個用戶，若要在每一年第一天凌晨將積分清零，你將考慮什麼，你將想什麼辦法解決?
方案一：update user set score=0;
方案二：假設上面的代碼要執行好長時間，超出咱們的容忍範圍，使用alter table：
drop columnscore;alter table user add column score int。
在Oracle中，動了表結構，索引失效
方案三：使用Java程序，for循環，效率最差
方案四：使用存儲過程loop循環，效率其次差
19、一個用戶具備多個角色，請查詢出該表中具備該用戶的全部角色的其餘用戶。(跟第42條SQL語句同)
select distinct user_id
from user_role scx
where
not exists
(
select *
from user_role scy
where
scy.user_id = '張三'
and not exits
(
select *
from user_role scz
where
scz.user_id = scx.user_id
and scz.role_id = scy.role_id
)
)
20. xxx公司的sql面試
EMPLOYEES(employee_id NUMBER, first_name VARCHAR2(25), last_name VARCHAR2(25), salary number(8,2), hired_date DATE, department_id number(2))
Departments(Departmentid number(2),DepartmentName VARCHAR2(25))
(1）基於上述EMPLOYEES表寫出查詢：寫出僱用日期在今年的，或者工資在[1000,2000]之間的，或者員工姓名（last_name）以’Obama’打頭的全部員工，列出這些員工的所有我的信息。
答案1、
select * from employees
where
Year(hired_date) = Year(date())
or (salary between 1000 and 200)
or left(last_name,5)=' Obama’';
答案2、
select * from employees
where
(
hired_date >= to_date(Year(date()) || ‘-01-01’, ‘yyyy-mm-dd’
and hired_date < to_date((Year(date())+1) || ‘-01-01’, ‘yyyy-mm-dd’
)
or (salary between 1000 and 200)
or last_name like ‘ Obama%’
(2) 查出部門平均工資大於1800元的部門的全部員工，列出這些員工的所有我的信息。
答案1、
select * from employee em
where
em.department_id in
(
select department_id
from employee e
group by department_id
having avg(salary) > 1800
)
答案2、
select * from employee em
where
(
select avg(e.salary) from employee e where e.department_id = em. department_id
) > 1800
(3)查出我的工資高於其所在部門平均工資的員工，列出這些員工的所有我的信息及該員工工資高出部門平均工資百分比。
答案1、
select e.*, ((e.salary - as.avg_salary) / as.avg_salary) as salary_percent
from employee e
left join
(
select em.department_id, avg(em.salary) as avg_salary
from employee em
group by em.department_id
) as on e.department_id = as.department_id
where
e.salary > as.avg_salary
答案2、
select employee e.*,(e.salary-t.avg_salary) / as.avg_salary
from employee e,
(
select t.department_id,avg(salary) avg_salary
from employee em
group by t.department_id
) as t
where
e. department_id = t. department_id and e.salary>t.avg_salary
21、註冊Jdbc驅動程序的三種方式
1. Class.forName(driver)
2. ClassLoader.loadClass(driver)
3. new XXXDriver();
22、用JDBC如何調用存儲過程
Class.forName("com.mysql.jdbc.Driver");
String url = "jdbc:mysql:///test";
Connection cn = DriverManager.getConnection(url, "root", "root");
String sql = "{call insert_student(?,?,?)}";
CallableStatement cstmt = cn.prepareCall(sql);
cstmt.registerOutParameter(3, Types.INTEGER);
cstmt.setString(1, "wangwu");
cstmt.setInt(2, 25);
cstmt.execute();
// get第幾個，不一樣的數據庫不同，建議不寫
System.out.println(cstmt.getString(3));
23、JDBC中的PreparedStatement相比Statement的好處
一個sql命令在數據庫執行的步驟爲：語法檢查，語義分析，編譯成內部指令，緩存指令，執行指令等過程。
1. PrepareStatement第一次執行某SQL時能夠把最終結果緩存到數據中，之後再執行同一格式的SQL時，再也不進行優化，直接使用緩存中的優化結果，效率比較高。
2.參數傳值，能夠防止SQL注入
24、Class.forName的做用?爲何要用?
答：按參數中指定的字符串形式的類名去搜索並加載相應的類，若是該類字節碼已經被加載過，則返回表明該字節碼的Class實例對象，不然，按類加載器的委託機制去搜索和加載該類，若是全部的類加載器都沒法加載到該類，則拋出ClassNotFoundException。加載完這個Class字節碼後，接着就能夠使用Class字節碼的newInstance方法去建立該類的實例對象了。
有時候，咱們程序中全部使用的具體類名在設計時（即開發時）沒法肯定，只有程序運行時才能肯定，這時候就須要使用Class.forName去動態加載該類，這個類名一般是在配置文件中配置的，例如，spring的ioc中每次依賴注入的具體類就是這樣配置的，jdbc的驅動類名一般也是經過配置文件來配置的，以便在產品交付使用後不用修改源程序就能夠更換驅動類名。
25、大數據量下的分頁解決方法。
查詢結果集若是記錄數比較多時，服務器內存和瀏覽器內存均可能溢出，另外，數據量太大客戶端的性能會下降，滾動條較小，操做也不方便，須要數據庫分頁查詢。
SQL Server分頁：
select top #pageSize# * from students where id not in
(select top #pageSize# * (#pageNumber#-1) id from students order by id) order by id
My SQL分頁：
select * from students order by id limit #pageSize#*(#pageNumber#-1),#pageSize#
Oracle分頁：
SELECT * FROM
(
SELECT T1.*
FROM
(
SELECT T.*, ROWNUM RN FROM TR_ORDER T ORDER BY T.ORDER_ID DESC
) T1
WHERE
T1.RN<=#{pageSize} * #{pageNumber}
) T
WHERE T.RN>#{pageSize}*(#{pageNumber}-1)
26、用 JDBC查詢學生成績單,把主要代碼寫出來（考試機率極大）.
Connection cn = null;
PreparedStatement pstmt =null;
Resultset rs = null;
try {
Class.forname(driveClassName);
cn = DriverManager.getConnection(url,username,password);
pstmt =cn.prepareStatement(「select score.* fromscore ,student 「 +
「wherescore.stuId = student.id and student.name = ?」);
pstmt.setString(1,studentName);
Resultset rs =pstmt.executeQuery();
while(rs.next()) {
system.out.println(rs.getInt(「subject」) + 「\t」+ rs.getFloat(「score」) );
}
}catch(Exception e){e.printStackTrace();}
finally{
if(rs != null) try{rs.close(); }catch(exception e){}
if(pstmt != null)try{pstmt.close();}catch(exception e){}
if(cn != null) try{cn.close(); }catch(exception e){}
}
27、這段代碼有什麼不足之處?
try {
Connection conn = ...;
Statement stmt = ...;
ResultSet rs =stmt.executeQuery("select * from table1");
while(rs.next()) {
}
} catch(Exception ex) {
}
答：沒有finally語句來關閉各個對象，另外，使用finally以後，要把變量的定義放在try語句塊的外面，以便在try語句塊以外的finally塊中仍能夠訪問這些變量。
28、說出數據鏈接池的工做機制是什麼?
J2EE服務器啓動時會創建必定數量的池鏈接，並一直維持很多於此數目的池鏈接。客戶端程序須要鏈接時，池驅動程序會返回一個未使用的池鏈接並將其表記爲忙。若是當前沒有空閒鏈接，池驅動程序就新建必定數量的鏈接，新建鏈接的數量有配置參數決定。當使用的池鏈接調用完成後，池驅動程序將此鏈接標記爲空閒，其餘調用就能夠使用這個鏈接。
實現方式，返回的Connection是原始Connection的代理，代理Connection的close方法不是真正關鏈接，而是把它代理的Connection對象還回到鏈接池中。
29、爲何要用 ORM? 和 JDBC有何不同?
ORM是對象和關係型數據庫映射，是把Java中的JavaBean對象和數據庫表進行映射，使數據庫表中的記錄和JavaBean對象一一對應，從而大大簡化原來直接使用JDBC時，手工拼寫SQL帶來的不便。
ORM經過配置文件，使數據庫表和JavaBean類對應起來，提供簡便的操做方法，增、刪、改、查記錄，再也不拼寫字符串生成SQL，編程效率大大提升，同時減小程序出錯機率，加強數據庫的移植性，方便測試。可是原生的JDBC具備更強的靈活性，適合複雜多變的SQL應用。
經常使用的ORM框架有：Hibernate、MyBatis、TopLink、OJB
30. 數據庫大數據處理
1. 大數據能夠採用分佈式數據庫和創建分區表(PARTITION)
2. 創建有效索引：主鍵索引、聯合索引、倒序索引、函數索引(INDEX)
3. 使用物化視圖(MATERIALIZED VIEW)
4. 使用存儲過程(PROCDUDER)
5. 讀寫分離(golden gate軟件實現)
6. 歸檔舊數據(新舊數據查詢，保證新數據的效率提升)，程序作調整，舊數據和新數據查詢頁面分離
31. 存儲過程和函數具體的區別：
存儲過程：能夠使得對的管理、以及顯示關於及其用戶信息的工做容易得多。存儲過程是 SQL 語句和可選控制流語句的預編譯集合，以一個名稱存儲並做爲一個單元處理。存儲過程存儲在數據庫內，可由應用程序經過一個調用執行，並且容許用戶聲明變量、有條件執行以及其它強大的編程功能。存儲過程可包含程序流、邏輯以及對數據庫的查詢。它們能夠接受參數、輸出參數、返回單個或多個結果集以及返回值。
能夠出於任何使用 SQL 語句的目的來使用存儲過程，它具備如下優勢：
(1)功能強大，限制少。
(2)能夠在單個存儲過程當中執行一系列 SQL 語句。
(3)能夠從本身的存儲過程內引用其它存儲過程，這能夠簡化一系列複雜語句。
(4)存儲過程在建立時即在上進行編譯，因此執行起來比單個 SQL 語句快。
(5)能夠有多個返回值，即多個輸出參數，而且能夠使用SELECT返回結果集。
函數：是由一個或多個 SQL 語句組成的子程序，可用於封裝代碼以便從新使用。自定義函數諸多限制，有許多語句不能使用，許多功能不能實現。函數能夠直接引用返回值，用表變量返回記錄集。可是，用戶定義函數不能用於執行一組修改全局數據庫狀態的操做。
六. XML部分
1、xml有哪些解析技術?區別是什麼?
答:有DOM,SAX,STAX等
DOM:處理大型文件時其性能降低的很是厲害。這個問題是由DOM的樹結構所形成的，這種結構佔用的內存較多，並且DOM必須在解析文件以前把整個文檔裝入內存,適合對XML的隨機訪問SAX:不現於DOM,SAX是事件驅動型的XML解析方式。它順序讀取XML文件，不須要一次所有裝載整個文件。當遇到像文件開頭，文檔結束，或者標籤開頭與標籤結束時，它會觸發一個事件，用戶經過在其回調事件中寫入處理代碼來處理XML文件，適合對XML的順序訪問
STAX:Streaming API for XML (StAX)
講解這些區別是不須要特別去比較，就像說傳智播客與其餘培訓機構的區別時，咱們只需說清楚傳智播客有什麼特色和優勢就好了，這就已經間接回答了彼此的區別。
2、你在項目中用到了xml技術的哪些方面?如何實現的?
答:用到了數據存貯，信息配置兩方面。在作數據交換平臺時，將不能數據源的數據組裝成XML文件，而後將XML文件壓縮打包加密後經過網絡傳送給接收者，接收解密與解壓縮後再同XML文件中還原相關信息進行處理。在作軟件配置時，利用XML能夠很方便的進行，軟件的各類配置參數都存貯在XML文件中。
3、用jdom解析xml文件時如何解決中文問題?如何解析?
答:看以下代碼,用編碼方式加以解決
package test;
import java.io.*;
public class DOMTest
{
private String inFile = "c:\\people.xml"
private String outFile = "c:\\people.xml"
public static void main(String args[])
{
new DOMTest();
}
public DOMTest()
{
try
{
javax.xml.parsers.DocumentBuilder builder =
javax.xml.parsers.DocumentBuilderFactory.newInstance().newDocumentBuilder();
org.w3c.dom.Document doc = builder.newDocument();
org.w3c.dom.Element root = doc.createElement("老師");
org.w3c.dom.Element wang = doc.createElement("王");
org.w3c.dom.Element liu = doc.createElement("劉");
wang.appendChild(doc.createTextNode("我是王老師"));
root.appendChild(wang);
doc.appendChild(root);
javax.xml.transform.Transformer transformer =
javax.xml.transform.TransformerFactory.newInstance().newTransformer();
transformer.setOutputProperty(javax.xml.transform.OutputKeys.ENCODING,"gb2312");
transformer.setOutputProperty(javax.xml.transform.OutputKeys.INDENT,"yes");
transformer.transform(newjavax.xml.transform.dom.DOMSource(doc),
new
javax.xml.transform.stream.StreamResult(outFile));
}
catch (Exception e)
{
System.out.println (e.getMessage());
}
}
}
4、編程用JAVA解析XML的方式.
答:用SAX方式解析XML，XML文件以下：
<?xml version=1.0 encoding=gb2312?>
<person>
<name>王小明</name>
<college>信息學院</college>
<telephone>6258113</telephone>
<notes>男,1955年生,博士，95年調入海南大學</notes>
</person>
事件回調類SAXHandler.java
import java.io.*;
import java.util.Hashtable;
import org.xml.sax.*;
public class SAXHandler extends HandlerBase
{
private Hashtable table = new Hashtable();
private String currentElement = null;
private String currentValue = null;
public void setTable(Hashtable table)
{
this.table = table;
}
public Hashtable getTable()
{
return table;
}
public void startElement(String tag, AttributeList attrs)
throws SAXException
{
currentElement = tag;
}
public void characters(char[] ch, int start, int length)
throws SAXException
{
currentValue = new String(ch, start, length);
}
public void endElement(String name) throws SAXException
{
if (currentElement.equals(name))
table.put(currentElement, currentValue);
}
}
JSP內容顯示源碼,SaxXml.jsp:
<HTML>
<HEAD>
<TITLE>剖析XML文件people.xml</TITLE>
</HEAD>
<BODY>
<%@ page errorPage=ErrPage.jsp
contentType=text/html;charset=GB2312 %>
<%@ page import=java.io.* %>
<%@ page import=java.util.Hashtable %>
<%@ page import=org.w3c.dom.* %>
<%@ page import=org.xml.sax.* %>
<%@ page import=javax.xml.parsers.SAXParserFactory %>
<%@ page import=javax.xml.parsers.SAXParser %>
<%@ page import=SAXHandler %>
<%
File file = new File(c:\people.xml);
FileReader reader = new FileReader(file);
Parser parser;
SAXParserFactory spf = SAXParserFactory.newInstance();
SAXParser sp = spf.newSAXParser();
SAXHandler handler = new SAXHandler();
sp.parse(new InputSource(reader), handler);
Hashtable hashTable = handler.getTable();
out.println(<TABLE BORDER=2><CAPTION>教師信息表</CAPTION>);
out.println(<TR><TD>姓名</TD> + <TD> +
(String)hashTable.get(new String(name)) +</TD></TR>);
out.println(<TR><TD>學院</TD> + <TD> +
(String)hashTable.get(newString(college))+</TD></TR>);
out.println(<TR><TD>電話</TD> + <TD> +
(String)hashTable.get(new String(telephone)) +</TD></TR>);
out.println(<TR><TD>備註</TD> + <TD> +
(String)hashTable.get(new String(notes)) +</TD></TR>);
out.println(</TABLE>);
%>
</BODY>
</HTML>
5、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 forXML (StAX)
七.流行的框架與新技術
一、 談談你對Struts的理解。
1. struts是一個按MVC模式設計的Web層框架，實質是一個強大的Servlet。負責處理請求轉發和路由。
2. struts的基本配置文件爲struts-config.xml，裏面配置了不少Action、ActionForm及中轉規則，這個文件經過web.xml中的ActionServlet進行加載和初始化。
3. 當用戶請求發送到服務器端時，ActionServlet會接收到此請求，而後根據struts.xml中的配置找到相應的Action，同時根據ActionForm的配置，建立ActionForm的實例並進行賦值，當作參數交給Action進行業務處理，返回ActionMapping對象。
4. ActionServlet根據struts.xml中action的配置，forward到指定的頁面，把結果以JSP處理過的HTML返回給客戶的瀏覽器。
5.能夠繼續談一談struts1和struts2的區別
2、談談你對Hibernate的理解。
它是ORM思想的一個實現，對JDBC進行了很好的封裝，它經過配置使JavaBean對象和數據庫表之間進行映射，並提供對增、刪、改、查便利的操做方法，同時支持事務處理，它對數據庫記錄還提供了緩存機制，提升效率，它能夠使程序員不用書寫SQL，也不用關心數據庫SQL之間的差別，它經過方言對數據庫進行了很好的適配。
1. Hiberante的主配置文件爲hibernate.cfg.xml，其中定義了數據源、鏈接池、緩存、事務、表生成策略等配置
2. 經過*.hbm.xml映射配置文件，定義了JavaBean對象和數據庫表之間的映射關係，還定了對象和對象之間的映射關係，包括：一對1、多對1、一對多、多對多
3. 對於複雜查詢和修改，Hiberante提供了Query對象進行支持，它能夠使用HQL語句處理查詢、修改、刪除和分頁。若是須要處理針對數據庫相關的SQL，能夠SQLQuery對象處理。
4. Hibernate能夠集成到Spring中，經過Spring進行事務處理，事務的配置一般分兩類，一種是AOP方式，一種是註釋方式的聲明式事務。
5. Hiberante從3版本後，支持JPA規範，能夠不使用映射文件配置，而所有采用JPA註解方式進行對象和數據庫表的映射，Hibernate還擴容了JPA規範。
6. Hibernate對經常使用的緩存技術作了封裝，能夠輕鬆的調用各類緩存框架
3、AOP的做用。
AOP是面向切面編程，主要應用在如下領域：
1. 日誌
2. 安全
3. 性能
4. 事務
5. 自定義場景，例如流程控制能夠採用AOP+註解方式完成
4、你對Spring的理解。
Spring實質上講就是一個Bean工廠，主要用來管理Bean的生命週期和框架集成。
Spring分爲兩個部分：
1. IOC控制反轉(也叫DI依賴注入，此名由Mardin Fowler給出)。Spring的頂層容器爲BeanFactory，經常使用的ApplicationContext爲它的子接口，實現了工廠模式。Spring須要加載它的配置文件，一般配置文件名爲applicationContext.xml或spring-config.xml，其中Bean的定義爲<bean id=」beanId」 class=」xxx.class」 />
2. Spring容器負責根據配置文件建立Bean對象並進行對其的裝載。Bean有懶加載，屬性配置，自動裝載，parent Bean，abstract Bean，FactoryBean(一般用於框架集成，須要瞭解BeanFactory和FactoryBean的區別)，scope(singleton單例，prototype多例)。
3. Spring 2.5後提供了對註釋的支持，更加方便，在重構時做用巨大。
4. Spring的IOC解除了模塊間的耦合，能夠使項目多模塊並行開發。
5. Spring還提供了AOP的支持，方便在切面級開發，例如事務控制、日誌、性能、安全等。Spring的AOP有兩種配置方式，都是經過動態代理技術實現的，一種是JDK自帶的Proxy類的實現，一種是CGLIB動態代理實現，經過<aop:aspect target-class-proxy=」true」 />開關進行設置。
6. Spring的重要作用是集成其它框架。Spring官方提供了許多類庫對其它框架進行了封裝，例如經過的事務模塊、JMS框架的調用模塊、Email支持、調試器Scheduler、JNDI等，同時其它框架也提供了針對Spring的集成包，例如Hibernate、MyBatis、Struts等
5、談談Struts中的ActionServlet。
見第一條
6、Struts優缺點
優勢：
1. 實現MVC模式，結構清晰,使開發者只關注業務邏輯的實現.
2．有豐富的tag能夠用 ,Struts的標記庫(Taglib)，如能靈活動用，則能大大提升開發效率
3. 頁面導航
使系統的脈絡更加清晰。經過一個配置文件，便可把握整個系統各部分之間的聯繫，這對於後期的維護有着莫大的好處。尤爲是當另外一批開發者接手這個項目時，這種優點體現得更加明顯。
4. 提供Exception處理機制 .
5. 數據庫連接池管理
6. 支持I18N
缺點
1、轉到展現層時，須要配置forward，若是有十個展現層的jsp，須要配置十次struts，並且還不包括有時候目錄、文件變動，須要從新修改forward，注意，每次修改配置以後，要求從新部署整個項目，而tomcate這樣的服務器，還必須從新啓動服務器
2、Struts的Action必需是thread－safe方式，它僅僅容許一個實例去處理全部的請求。因此action用到的全部的資源都必需統一同步，這個就引發了線程安全的問題。
3、測試不方便. Struts的每一個Action都同Web層耦合在一塊兒，這樣它的測試依賴於Web容器，單元測試也很難實現。不過有一個Junit的擴展工具Struts TestCase能夠實現它的單元測試。
4、類型的轉換. Struts的FormBean把全部的數據都做爲String類型，它能夠使用工具Commons-Beanutils進行類型轉化。但它的轉化都是在Class級別，並且轉化的類型是不可配置的。類型轉化時的錯誤信息返回給用戶也是很是困難的。
5、對Servlet的依賴性過強. Struts處理Action時必須要依賴ServletRequest和ServletResponse，全部它擺脫不了Servlet容器。
6、前端表達式語言方面.Struts集成了JSTL，因此它主要使用JSTL的表達式語言來獲取數據。但是JSTL的表達式語言在Collection和索引屬性方面處理顯得很弱。
7、對Action執行的控制困難. Struts建立一個Action，若是想控制它的執行順序將會很是困難。甚至你要從新去寫Servlet來實現你的這個功能需求。
8、對Action執行前和後的處理. Struts處理Action的時候是基於class的hierarchies，很難在action處理前和後進行操做。
9、對事件支持不夠.在struts中，實際是一個表單Form對應一個Action類(或DispatchAction)，換一句話說：在Struts中實際是一個表單只能對應一個事件，struts這種事件方式稱爲application event，application event和component event相比是一種粗粒度的事件
7、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屬性、國際化的提示和消息。
8、說說struts1與struts2的區別。
1. Struts1是比較老的WEB框架，Struts2比較新，相對於Struts1功能更強
2. struts1的前端控制器是一個Servlet，名稱爲ActionServlet，struts2的前端控制器是一個filter，在struts2.0中叫FilterDispatcher，在struts2.1中叫StrutsPreparedAndExecuteFilter
3. struts1的action須要繼承Action類，struts2的action能夠不繼承任何類；
4. struts1對同一個路徑的全部請求共享一個Action實例，是單例，struts2對同一個路徑的每一個請求分別使用一個獨立Action實例對象，全部對於struts2的Action不用考慮線程安全問題。
5. Struts2還添加了過濾器interceptor，用於攔截請求，比filter功能更強大
6. Struts2能夠對字段進行類型自動轉換。
7. Struts2是從WebWork框架上開發出來的，沒有依賴Struts1，和Struts1區別比較大。
9、hibernate中的update()和saveOrUpdate()的區別，session的load()和get()的區別。
10、簡述 Hibernate和 JDBC的優缺點?如何書寫一個 one to many配置文件.
11、iBatis與Hibernate有什麼不一樣?
相同點：都是ORM框架，對jdbc進行了封裝。
不一樣點：iBatis須要手寫sql，hibernate不須要手寫sql，所以iBatis對程序員的sql功底要求高，對數據庫的操做也更加靈活。
iBatis能夠對sql進行優化，提升性能，hibernate的sql爲自動生成，在sql優化方面會很麻煩。
iBatis的sql是手寫的對多表的查詢更加方便，而hibernate的連表查詢須要拼複雜的HQL語句。
iBatis還能夠使用數據庫特有的特性，hibernate只能用標準的sql。
iBatis數據庫的相關性強，在進行數據庫移植時須要修改大量的sql，hibernate在數據庫移植時與數據庫基本無關。
ibatis的好處：屏蔽jdbc api的底層訪問細節；將sql語句與java代碼進行分離;提供了將結果集自動封裝稱爲實體對象和對象的集合的功能，queryForList返回對象集合，用queryForObject返回單個對象；提供了自動將實體對象的屬性傳遞給sql語句的參數。
Hibernate是一個全自動的orm映射工具，它能夠自動生成sql語句,ibatis須要咱們本身在xml配置文件中寫sql語句，hibernate要比ibatis功能負責和強大不少。由於hibernate自動生成sql語句，咱們沒法控制該語句，咱們就沒法去寫特定的高效率的sql。對於一些不太複雜的sql查詢，hibernate能夠很好幫咱們完成，可是，對於特別複雜的查詢，hibernate就很難適應了，這時候用ibatis就是不錯的選擇，由於ibatis仍是由咱們本身寫sql語句。
12、寫Hibernate的一對多和多對一雙向關聯的orm配置? hibernate的inverse屬性的做用?
多對一，在多的一方配置<many-to-one>
<many-to-one name="propertyName" column="other_column" class="" />
一對多，在一的一方配置<one-to-many>
<set name="propertyName">
<key column="this_column" not-null="true"/>
<one-to-many class="OtherClass"/>
</set>
inverse的做用：若是雙方都有相關配置，讓其一方放棄控制權。
13、在DAO中如何體現DAO設計模式?
把實體對象轉換成數據庫可識別的SQL，並執行，而後把數據庫返回的結果，以對象的形式做爲方法的返回值進行返回。
把對數據庫的增、刪、改、查進行封裝，有關數據庫的操做所有在DAO中執行，其它部分不會涉及數據庫的任何操做。
DAO爲上層的業務邏輯層提供數據操做支持。
14、Spring+Hibernate中委託方案怎麼配置?
方案一：定義DataSource的Bean和hibernate.cfg.xml配置，而後把這兩個配置交由Spring的SessionFactoryBean進行初始化，再定義一個HibernateTemplate的Bean，注入到DAO中。
方案二：不定義DataSource的Bean，把數據庫相關信息和hiberante的相關信息配置到hibernate.cfg.xml中，直接把hibernate.cfg.xml交由Spring的SessionFactoryBean進行初始化，再定義一個HibernateTemplate的Bean，注入到DAO中。
方案三：定義DataSource的Bean，定義SessionFactoryBean，而後把Hibernate的相關信息直接配置到SessionFactoryBean中，再定義一個HibernateTemplate的Bean，注入到DAO中。
15. hibernate進行多表查詢每一個表中各取幾個字段，也就是說查詢出來的結果集沒有一個實體類與之對應如何解決；
解決方案一，按照Object[]數據取出數據，而後本身組bean
解決方案二，對每一個表的bean寫構造函數，好比表一要查出field1,field2兩個字段，那麼有一個構造函數就是Bean(type1 filed1, type2 field2) ，而後在hql裏面就能夠直接生成這個bean了。
對於多表查詢的話，HQL須要進行連表查詢，能夠使用left join等連表語句和where條件。
16.介紹一下Hibernate的二級緩存
按照如下思路來回答：（1）首先說清楚什麼是緩存，（2）再說有了hibernate的Session就是一級緩存，即有了一級緩存，爲何還要有二級緩存（3）最後再說如何配置Hibernate的二級緩存。
（1）緩存就是把之前從數據庫中查詢出來和使用過的對象保存在內存中（一個數據結構中），這個數據結構一般是或相似Hashmap，當之後要使用某個對象時，先查詢緩存中是否有這個對象，若是有則使用緩存中的對象，若是沒有則去查詢數據庫，並將查詢出來的對象保存在緩存中，以便下次使用。下面是緩存的僞代碼：
（2）Hibernate的Session就是一種緩存，咱們一般將之稱爲Hibernate的一級緩存，當想使用session從數據庫中查詢出一個對象時，Session也是先從本身內部查看是否存在這個對象，存在則直接返回，不存在纔去訪問數據庫，並將查詢的結果保存在本身內部。因爲Session表明一次會話過程，一個Session與一個數據庫鏈接相關連，因此Session最好不要長時間保持打開，一般僅用於一個事務當中，在事務結束時就應關閉。而且Session是線程不安全的，被多個線程共享時容易出現問題。一般只有那種全局意義上的緩存纔是真正的緩存應用，纔有較大的緩存價值，所以，Hibernate的Session這一級緩存的緩存做用並不明顯，應用價值不大。Hibernate的二級緩存就是要爲Hibernate配置一種全局緩存，讓多個線程和多個事務均可以共享這個緩存。咱們但願的是一我的使用過，其餘人也能夠使用，session沒有這種效果。
（3）二級緩存是獨立於Hibernate的軟件部件，屬於第三方的產品，多個廠商和組織都提供有緩存產品，例如，EHCache和OSCache等等。在Hibernate中使用二級緩存，首先就要在hibernate.cfg.xml配置文件中配置使用哪一個廠家的緩存產品，接着須要配置該緩存產品本身的配置文件，最後要配置Hibernate中的哪些實體對象要歸入到二級緩存的管理中。明白了二級緩存原理和有了這個思路後，很容易配置起Hibernate的二級緩存。擴展知識：一個SessionFactory能夠關聯一個二級緩存，也即一個二級緩存只能負責緩存一個數據庫中的數據，當使用Hibernate的二級緩存後，注意不要有其餘的應用或SessionFactory來更改當前數據庫中的數據，這樣緩存的數據就會與數據庫中的實際數據不一致。
17、Spring的依賴注入是什麼意思?給一個 Bean 的 message屬性,字符串類型,注入值爲"Hello"的 XML配置文件該怎麼寫?
Spring的依賴注入，又稱爲IOC，還能夠稱爲是DI，其實就是把對象之間的相互依賴由原來的手動寫代碼方式注入，改成由Spring容器進行自動注入，並把Bean的生命週期交由Spring進行管理。Spring支持的注入方式有兩種：屬性注入、構造器注入。Spring不支持接口注入。
<bean id=」myBean」 class=」MyBean」>
<property name=」message」 value=」Hello」 />
</bean>
18、JDO是什麼?
JDO是Java對象持久化的新的規範，爲java data object的簡稱,也是一個用於存取某種數據倉庫中的對象的標準化API。JDO提供了透明的對象存儲，所以對開發人員來講，存儲數據對象徹底不須要額外的代碼（如JDBC API的使用）。這些繁瑣的例行工做已經轉移到JDO產品提供商身上，使開發人員解脫出來，從而集中時間和精力在業務邏輯上。另外，JDO很靈活，由於它能夠在任何數據底層上運行。JDBC只是面向關係數據庫（RDBMS）JDO更通用，提供到任何數據底層的存儲功能，好比關係數據庫、文件、XML以及對象數據庫（ODBMS）等等，使得應用可移植性更強。
19、什麼是spring的AOP
AOP指面向切面編程，是一種特殊的編程方式。對於相似的業務，處理方式基本相同，但只是局部不一樣，這時，須要把類似的地方抽離出來，只是關注業務的不一樣點，這種方式叫作AOP。AOP經常使用術語有XXXX，
AOP經常使用來作安全、日誌、性能、事務、自定義的業務(例如表單重複提交)。
20、Struts的工做流程！
21、Spring與EJB的區別
Spring是輕量級框架，不須要容器支持。
EJB(Enterpise JavaBean)是Java EE中的規範，分爲BMP和CMP兩種，須要容器支持。EJB有實體Bean(Entity Bean)、會話Bean(Session Bean)，狀態Bean(Status Bean)，消息驅動Bean(Message Driving Bean)。EJB須要繼承Remote接口，須要實現local和remote方法。
八.軟件工程與設計模式
1、UML方面
標準建模語言UML。用例圖,靜態圖(包括類圖、對象圖和包圖),行爲圖,交互圖(順序圖,合做圖),實現圖。
2、j2ee經常使用的設計模式？說明工廠模式。
總共23種，分爲三大類：建立型，結構型，行爲型
我只記得其中經常使用的6、7種，分別是：
建立型（工廠、工廠方法、抽象工廠、單例）
結構型（包裝、適配器，組合，代理）
行爲（觀察者，模版，策略）
而後再針對你熟悉的模式談談你的理解便可。
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（責任鏈模式）
工廠模式：工廠模式是一種常常被使用到的模式，根據工廠模式實現的類能夠根據提供的數據生成一組類中某一個類的實例，一般這一組類有一個公共的抽象父類而且實現了相同的方法，可是這些方法針對不一樣的數據進行了不一樣的操做。首先須要定義一個基類，該類的子類經過不一樣的方法實現了基類中的方法。而後須要定義一個工廠類，工廠類能夠根據條件生成不一樣的子類實例。當獲得子類的實例後，開發人員能夠調用基類中的方法而沒必要考慮到底返回的是哪個子類的實例。
3、開發中都用到了那些設計模式?用在什麼場合?
每一個模式都描述了一個在咱們的環境中不斷出現的問題，而後描述了該問題的解決方案的核心。經過這種方式，你能夠無數次地使用那些已有的解決方案，無需在重複相同的工做。主要用到了MVC的設計模式。用來開發JSP/Servlet或者J2EE的相關應用。簡單工廠模式等。
九. j2ee部分
1、BS與CS的聯繫與區別。
C/S是Client/Server的縮寫。服務器一般採用高性能的PC、工做站或小型機，並採用大型數據庫系統，如Oracle、Sybase、InFORMix或 SQL Server。客戶端須要安裝專用的客戶端軟件。
B/Ｓ是Brower/Server的縮寫，客戶機上只要安裝一個瀏覽器（Browser），如Netscape Navigator或Internet Explorer，服務器安裝Oracle、Sybase、InFORMix或 SQL Server等數據庫。在這種結構下，用戶界面徹底經過WWW瀏覽器實現，一部分事務邏輯在前端實現，可是主要事務邏輯在服務器端實現。瀏覽器經過Ｗeb Server同數據庫進行數據交互。
C/S 與 B/S區別：
１．硬件環境不一樣:
C/S 通常創建在專用的網絡上,小範圍裏的網絡環境,局域網之間再經過專門服務器提供鏈接和數據交換服務.
B/S 創建在廣域網之上的,沒必要是專門的網絡硬件環境,例與電話上網,租用設備.信息本身管理.有比C/S更強的適應範圍,通常只要有操做系統和瀏覽器就行
２．對安全要求不一樣
C/S 通常面向相對固定的用戶羣,對信息安全的控制能力很強.通常高度機密的信息系統採用C/S結構適宜.能夠經過B/S發佈部分可公開信息.
B/S 創建在廣域網之上,對安全的控制能力相對弱,可能面向不可知的用戶。
３．對程序架構不一樣
C/S 程序能夠更加註重流程,能夠對權限多層次校驗,對系統運行速度能夠較少考慮.
B/S 對安全以及訪問速度的多重的考慮,創建在須要更加優化的基礎之上.比C/S有更高的要求 B/S結構的程序架構是發展的趨勢,從MS的.Net系列的BizTalk 2000Exchange 2000等,全面支持網絡的構件搭建的系統. SUN和IBM推的JavaBean構件技術等,使 B/S更加成熟.
４．軟件重用不一樣
C/S 程序能夠不可避免的總體性考慮,構件的重用性不如在B/S要求下的構件的重用性好.
B/S 對的多重結構,要求構件相對獨立的功能.可以相對較好的重用.就入買來的餐桌能夠再利用,而不是作在牆上的石頭桌子
５．系統維護不一樣
C/S 程序因爲總體性,必須總體考察,處理出現的問題以及系統升級.升級難.多是再作一個全新的系統
B/S 構件組成,方面構件個別的更換,實現系統的無縫升級.系統維護開銷減到最小.用戶從網上本身下載安裝就能夠實現升級.
６．處理問題不一樣
C/S 程序能夠處理用戶面固定,而且在相同區域,安全要求高需求,與操做系統相關.應該都是相同的系統
B/S 創建在廣域網上,面向不一樣的用戶羣,分散地域,這是C/S沒法做到的.與操做系統平臺關係最小.
７．用戶接口不一樣
C/S 可能是創建的Window平臺上,表現方法有限,對程序員廣泛要求較高
B/S 創建在瀏覽器上,有更加豐富和生動的表現方式與用戶交流.而且大部分難度減低,減低開發成本.
８．信息流不一樣
C/S 程序通常是典型的中央集權的機械式處理,交互性相對低
B/S 信息流向可變化, B-B B-C B-G等信息、流向的變化,更像交易中心。
2、應用服務器與WEB SERVER的區別？
應用服務器：Weblogic、Tomcat、Jboss
WEB SERVER：IIS、 Apache
3、應用服務器有那些？
BEA WebLogic Server，IBM WebSphere Application Server，Oracle9i ApplicationServer，jBoss，Tomcat
4、J2EE是什麼？
答:Je22是Sun公司提出的多層(multi-diered),分佈式(distributed),基於組件(component-base)的企業級應用模型(enterpriese applicationmodel).在這樣的一個應用系統中，可按照功能劃分爲不一樣的組件，這些組件又可在不一樣計算機上，而且處於相應的層次(tier)中。所屬層次包括客戶層(clietn tier)組件,web層和組件,Business層和組件,企業信息系統(EIS)層。
一個另類的回答：j2ee就是增刪改查。
5、J2EE是技術仍是平臺仍是框架？什麼是J2EE
J2EE自己是一個標準，一個爲企業分佈式應用的開發提供的標準平臺。
J2EE也是一個框架，包括JDBC、JNDI、RMI、JMS、EJB、JTA等技術。
6、請對如下在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特有的。
7、如何給weblogic指定大小的內存?
（這個問題不做具體回答，列出來只是告訴讀者可能會遇到什麼問題，你不須要面面俱到，什麼都精通。）
在啓動Weblogic的腳本中（位於所在Domian對應服務器目錄下的startServerName），增長set MEM_ARGS=-Xms32m-Xmx200m，能夠調整最小內存爲32M，最大200M
8、如何設定的weblogic的熱啓動模式(開發模式)與產品發佈模式?
能夠在管理控制檯中修改對應服務器的啓動模式爲開發或產品模式之一。或者修改服務的啓動文件或者commenv文件，增長setPRODUCTION_MODE=true。
9、如何啓動時不需輸入用戶名與密碼?
修改服務啓動文件，增長 WLS_USER和WLS_PW項。也能夠在boot.properties文件中增長加密過的用戶名和密碼.
10、在weblogic管理制臺中對一個應用域(或者說是一個網站,Domain)進行jms及ejb或鏈接池等相關信息進行配置後,實際保存在什麼文件中?
保存在此Domain的config.xml文件中，它是服務器的核心配置文件。
11、說說weblogic中一個Domain的缺省目錄結構?好比要將一個簡單的helloWorld.jsp放入何目錄下,然的在瀏覽器上就可打入http://主機:端口號//helloword.jsp就能夠看到運行結果了?又好比這其中用到了一個本身寫的javaBean該如何辦?
Domain目錄服務器目錄applications，將應用目錄放在此目錄下將能夠做爲應用訪問，若是是Web應用，應用目錄須要知足Web應用目錄要求，jsp文件能夠直接放在應用目錄中，Javabean須要放在應用目錄的WEB-INF目錄的classes目錄中，設置服務器的缺省應用將能夠實如今瀏覽器上無需輸入應用名。
12、在weblogic中發佈ejb需涉及到哪些配置文件
不一樣類型的EJB涉及的配置文件不一樣，都涉及到的配置文件包括ejb-jar.xml,weblogic-ejb-jar.xmlCMP實體Bean通常還須要weblogic-cmp-rdbms-jar.xml
13、如何在weblogic中進行ssl配置與客戶端的認證配置或說說j2ee(標準)進行ssl的配置?
缺省安裝中使用DemoIdentity.jks和DemoTrust.jks KeyStore實現SSL，須要配置服務器使用Enable SSL，配置其端口，在產品模式下須要從CA獲取私有密鑰和數字證書，建立identity和trust keystore，裝載得到的密鑰和數字證書。能夠配置此SSL鏈接是單向仍是雙向的。
14、如何查看在weblogic中已經發布的EJB?
能夠使用管理控制檯，在它的Deployment中能夠查看全部已發佈的EJB
- 1. HTML+CSS+JS面試題
- 2. html。css。js的面試題
- 3. HTML+CSS+JS（面試題）
- 4. web前端面試題【html+css+js+框架】
- 5. html面試題(二)html css js
- 6. Java中的面試題 [2] --- Java框架、SpringMVC、Spring、mybatis、hibernate等
- 7. java 面試-- java框架-spring
- 8. 三大框架面試題(Struts,Spring,Hibernate)
- 9. 2020 前端面試 | 「HTML + CSS + JS」專題
- 10. 前端面試題（html+css+js）
- 更多相關文章...
- • Docker 命令大全 - Docker教程
- • Java Spring框架是什麼？它有哪些好處？ - Spring教程
- • JDK13 GA發佈：5大特性解讀
- • Tomcat學習筆記（史上最全tomcat學習筆記）
-
每一个你不满意的现在，都有一个你没有努力的曾经。