企業(yè)面試筆試題總匯v15

企業(yè)面試題總匯Java基礎(chǔ)部分請列舉至少3個JDK安裝目錄下的可執(zhí)行程序(javac)，并列舉幾個常用的命令行參數(shù)javac將Java源代碼換成字節(jié)代javac<選項><源文件>可能的選項包括：-g生成所有調(diào)試信息-g:none生成無調(diào)試信息-g:{lines,vars,source}生成只有部分調(diào)試信息-O優(yōu)化；可能妨礙調(diào)試或者增大類文件-nowarn生成無警告-verbose輸出關(guān)于編譯器正在做的信息-deprecation輸出使用了不鼓勵使用的API的源程序位置-classpath<路徑>指定用戶類文件的位置-sourcepath<路徑>指定輸入源文件的位置-bootclasspath<路徑>覆蓋自舉類文件的位置-extdirs<目錄(多個)>覆蓋安裝的擴展類的位置-d<目錄>指定輸出類文件的位置用法：2.jar打架包，查看架包jar{ctxu}[vfm0M][jar-文件][manifest-文件][-C目錄]文件名...選項：-c創(chuàng)建新的存檔-t列出存檔內(nèi)容的列表-x展開存檔中的命名的（或所有的）文件-u更新已存在的存檔-v生成詳細輸出到標準輸出上-f指定存檔文件名-m包含來自標明文件的標明信息-0只存儲方式；未用ZIP壓縮格式-M不產(chǎn)生所有項的清單（manifest）文件-i為指定的jar文件產(chǎn)生索引信息用法：3.javadoc：根據(jù)Java源代碼及其說明語句生成的HTML文檔javadoc[options][packagenames][sourcefiles][classnames][@files]-overview<file>讀取HTML格式的概述文檔-public僅顯示public類和成員-protected顯示protected/public類和成員（缺省）-package顯示package/protected/public類和成員-private顯示所有類和成員-help顯示命令行選項-doclet<class>通過候選doclet生成輸出-docletpath<path>指定doclet類文件的查找位置-sourcepath<pathlist>指定源文件的查找位置-classpath<pathlist>指定用戶類文件的查找位置用法：4.javah：產(chǎn)生可以調(diào)用Java過程的C過程，或建立能被Java程序調(diào)用的C過程的頭文件javah[options]<classes>其中[options]包括：-help打印該幫助信息-classpath<path>類的加載路徑-bootclasspath<path>自舉類的加載路徑-d<dir>輸出目錄-o<file>輸出文件（僅能使用-d或-o之一）-jni生成JNI風格的頭文件（缺?。?old生成JDK1.0風格的頭文件-stubs生成stubs文件-version打印版本信息-verbose輸出有關(guān)本命令所做工作的信息-force始終寫輸出文件用法：請分析命題：“Java采用自動垃圾回收技術(shù)（GC），因此不會出現(xiàn)內(nèi)存泄露”對象的建立和放置都是在內(nèi)存堆棧上面進行的。程序或者其他的對象可以鎖定一塊堆棧地址來進行其他對象的引用。當一個對象沒有任何引用的時候，Java的自動垃圾回收機制就發(fā)揮作用，自動刪除這個對象所占用的空間，釋放內(nèi)存以避免內(nèi)存泄漏。但是內(nèi)存泄漏并不是就此而完全避免了，當程序員疏忽大意地忘記解除一個對象不應(yīng)該有的引用的時候，內(nèi)存泄漏仍然不可避免，不過發(fā)生的幾率要比不啟用垃圾回收機制的C++程序少很多。但總體來講，自動垃圾回收機制要安全和簡單許多。簡單描述單子模式(單例模式)的各種不同實現(xiàn)方式，極其各自優(yōu)缺點。請列舉至少2種其他的設(shè)計模式及應(yīng)用場景。/*單例設(shè)計模式主要有2種實現(xiàn)方式：懶漢式、餓漢式。

他們分別有如下實現(xiàn)：

餓漢式：

//餓漢式單例類.在類初始化時，已經(jīng)自行實例化

*/

public

class

Singleton1

{

//私有的默認構(gòu)造子

private

Singleton1()

{}

//已經(jīng)自行實例化

private

static

final

Singleton1

single

=

new

Singleton1();

//靜態(tài)工廠方法

public

static

Singleton1

getInstance()

{

return

single;

}

}

懶漢式：

//懶漢式單例類.在第一次調(diào)用的時候?qū)嵗?/p>

public

class

Singleton2

{

//私有的默認構(gòu)造子

private

Singleton2()

{}

//注意，這里沒有final

private

static

Singleton2

single=null;

//靜態(tài)工廠方法

public

synchronized

static

Singleton2

getInstance()

{

if

(single

==

null)

{

single

=

new

Singleton2();

}

return

single;

}

}

/*其他設(shè)計模式：

1.適配器模式

應(yīng)用場景：比如說在朋友聚會上遇到一個德國人sarsh，可以我不會德語，她不會中文，我只好求助于我的朋友mary了，他作為我和sarsh之間的adapt，讓我和sarsh可以交流了。

2.裝飾模式

應(yīng)用場景：想要自己做禮物送給朋友，拿出去年在華山頂上的照片，在背面寫上“最好的禮物”再到街上禮品店買個相框，在找隔壁學美術(shù)的朋友設(shè)計一個漂亮的盒子裝起來，我們都是Decorator。*/

輸出結(jié)果public

static

void

main(String[]

args)throws

Exception{

String

str

=

"中國";

System.out.println(str.getBytes("UTF-8").length);

System.out.println(str.getBytes("GBK").length);

System.out.println(str.getBytes("ISO-8859-1").length);

System.out.println(new

String(str.getBytes("ISO-8859-1"),("ISO-8859-1"));

System.out.println(new

String(str.getBytes("UTF-8"),("UTF-8"));

System.out.println(new

String(str.getBytes("GBK"),("GBK"));

}

輸出結(jié)果：642??中國中國使用二分查找法找字符串數(shù)組{"a","b","c","d","e","f","g","h"}中"g"元素public

class

Query4Half

{

static

int

bsearch(

String[]

a,

String

v

)

{

int

l,

r;

l

=

0;

r

=

a.length-1;

while

(

l

<=

r

)

{

int

m

=

(l+r)/2;

if

(

a[m].compareTo(v)==0

)

return

m;

else

if

(

a[m].compareTo(v)>0

)

r

=

m-1;

else

if

(

a[m].compareTo(v)<0

)

l

=

m+1;

}

return

-1;

}

public

static

void

main(String[]

args)

{

String

str[]

=

{"a","b","c","d","e","f","g","h"};

int

bsearch

=

bsearch(str,

"g");

System.out.println(bsearch);

}

Java代碼實現(xiàn)一個鏈表結(jié)構(gòu)public

class

MyList<AnyType>

{

private

class

Node<AnyType>{

public

Node<AnyType>

pre;

public

Node<AnyType>

next;

public

AnyType

data;

public

Node(AnyType

d,

Node<AnyType>p,

Node<AnyType>

n){}

public

Node(){}

}

private

int

theSize;

private

Node<AnyType>

Header;

private

Node<AnyType>

Tail;

public

MyList(){}

public

void

add(AnyType

item){}

public

boolean

isEmpty(){}

public

int

size(){}

public

AnyType

get(

int

idx){}

public

void

print(){}

}

/*Node<AnyType>類定義了雙向鏈表中節(jié)點的結(jié)構(gòu)，它是一個私有類，而其屬性和構(gòu)造函數(shù)都是公有的，這樣，其父類可以直接訪問其屬性，而外部類根本不知道Node類的存在。Data是節(jié)點中的數(shù)據(jù)與，pre指向前一個Node節(jié)點，next指向后一個Node節(jié)點。其構(gòu)造函數(shù)的實現(xiàn)如下，不解釋：

View

Code*/

public

Node(AnyType

d,

Node<AnyType>p,

Node<AnyType>

n){

this.data

=

d;

this.pre

=

p;

this.next

=

n;

}

public

Node(){

this.data

=

null;

this.pre

=

null;

this.next

=

null;

}

/*下面我們看一下鏈表的構(gòu)造函數(shù)實現(xiàn)：

View

Code*/

public

MyList(){

theSize

=

0;

Header

=

new

Node<AnyType>(null,null,null);

Tail

=

new

Node<AnyType>(null,Header,null);

Header.next

=

Tail;

}

/*我們構(gòu)造了一個帶有頭、尾節(jié)點的雙向鏈表，頭節(jié)點的Next指向尾節(jié)點，為節(jié)點的pre指向頭節(jié)點。鏈表長度起始為0。

繼續(xù)貼上鏈表類其它方法的實現(xiàn)，不解釋了，應(yīng)該比較清楚：*/

//View

Code

public

void

add(AnyType

item){

Node<AnyType>

aNode

=

new

Node<AnyType>(item,null,null);

Tail.pre.next

=

aNode;

aNode.pre

=

Tail.pre;

aNode.next

=

Tail;

Tail.pre

=

aNode;

theSize++;

}

public

boolean

isEmpty(){

return

(

theSize

==

0);

}

public

int

size(){

return

theSize;

}

public

AnyType

get(

int

idx){

if(idx

>

theSize-1

||

idx

<

0)

throw

new

IndexOutOfBoundsException();

Node<AnyType>

current

=

new

Node<AnyType>(null,Header,null);

for(int

i

=

0;

i<idx;

i++)

current

=

current.next;

return

current.data;

}

public

void

print(){

Node<AnyType>

current

=

Header.next;

while(current.next

!=

null){

//如果AnyType是你自己定義

//的數(shù)據(jù)類型，那么請務(wù)必提供

//一個toString方法，要么就不

//要在鏈表里實現(xiàn)print方法。

System.out.println(current.data.toString());

current

=

current.next;

}

}

Object類（或子類）的finalize()方法在什么情況下被調(diào)用？當某個對象被系統(tǒng)收集為無用信息的時候,finalize()將被自動調(diào)用,但是jvm不保證finalize()一定被調(diào)用,也就是說,finalize()的調(diào)用是不確定的...請列出你所了解的若干個不同類型的runtimeexceptionNullPointerException-空指針引用異常ClassCastException-類型強制轉(zhuǎn)換異常。IllegalArgumentException-傳遞非法參數(shù)異常。ArithmeticException-算術(shù)運算異常ArrayStoreException-向數(shù)組中存放與聲明類型不兼容對象異常IndexOutOfBoundsException-下標越界異常NegativeArraySizeException-創(chuàng)建一個大小為負數(shù)的數(shù)組錯誤異常NumberFormatException-數(shù)字格式異常SecurityException-安全異常UnsupportedOperationException-不支持的操作異常數(shù)組String[]str和Stringstr分別怎么獲取長度？size和length()JAVA實現(xiàn)快速排序算法public

class

QuickSort

{

public

static

int

Partition(int

a[],int

p,int

r){

int

x=a[r-1];

int

i=p-1;

int

temp;

for(int

j=p;j<=r-1;j++){

if(a[j-1]<=x){

//

swap(a[j-1],a[i-1]);

i++;

temp=a[j-1];

a[j-1]=a[i-1];

a[i-1]=temp;

}

}

//swap(a[r-1,a[i+1-1]);

temp=a[r-1];

a[r-1]=a[i+1-1];

a[i+1-1]=temp;

return

i+1;

}

public

static

void

QuickSort(int

a[],int

p,int

r){

if(p<r){

int

q=Partition(a,p,r);

QuickSort(a,p,q-1);

QuickSort(a,q+1,r);

}

}

public

static

void

main(String[]

args){

int

a[]={23,53,77,36,84,76,93,13,45,23};

QuickSort(a,1,10);

for

(int

i=1;i<=10;i++)

System.out.println(a[i-1]);

}

}

請簡單闡述一下Socket通訊原理，以及Socket基于TCP和UDP協(xié)議實現(xiàn)的優(yōu)缺點Socket通信的原理大致分為以下幾個步驟。服務(wù)器端的步驟如下。（1）建立服務(wù)器端的Socket，開始偵聽整個網(wǎng)絡(luò)中的連接請求。（2）當檢測到來自客戶端的連接請求時，向客戶端發(fā)送收到連接請求的信息，建立與客戶端之間的連接。（3）當完成通信后，服務(wù)器關(guān)閉與客戶端的Socket連接?？蛻舳说牟襟E如下。（1）建立客戶端的Socket，確定要連接的服務(wù)器的主機名和端口。（2）發(fā)送連接請求到服務(wù)器，并等待服務(wù)器的回饋信息。（3）連接成功后，與服務(wù)器進行數(shù)據(jù)的交互。（4）數(shù)據(jù)處理完畢后，關(guān)閉自身的Socket連接。TCP：面向連接、傳輸可靠(保證數(shù)據(jù)正確性,保證數(shù)據(jù)順序)、用于傳輸大量數(shù)據(jù)(流模式)、速度慢，建立連接需要開銷較多(時間，系統(tǒng)資源)。UDP：面向非連接、傳輸不可靠、用于傳輸少量數(shù)據(jù)(數(shù)據(jù)包模式)、速度快。對象封裝的原則是什么？封裝原則：隱藏對象的屬性和實現(xiàn)細節(jié)，僅對外公開接口，并且控制訪問級別在OOP（面向?qū)ο螅┚幊讨?，用類來實現(xiàn)上面的要求。用類實現(xiàn)封裝，用封裝來實現(xiàn)高內(nèi)聚，低耦合高聚合是說一個對象的功能都在內(nèi)部搞定，緊緊地結(jié)合在一起低耦合是說對象之間的依賴要松散，不要牽一發(fā)動全身只有這樣，當系統(tǒng)規(guī)模擴大時，才能比較方便什么是java序列化，如何實現(xiàn)java序列化？我們有時候?qū)⒁粋€java對象變成字節(jié)流的形式傳出去或者從一個字節(jié)流中恢復成一個java對象，例如，要將java對象存儲到硬盤或者傳送給網(wǎng)絡(luò)上的其他計算機，這個過程我們可以自己寫代碼去把一個java對象變成某個格式的字節(jié)流再傳輸，但是，jre本身就提供了這種支持，我們可以調(diào)用OutputStream的writeObject方法來做，如果要讓java幫我們做，要被傳輸?shù)膶ο蟊仨殞崿F(xiàn)serializable接口，這樣，javac編譯時就會進行特殊處理，編譯的類才可以被writeObject方法操作，這就是所謂的序列化。需要被序列化的類必須實現(xiàn)Serializable接口，該接口是一個mini接口，其中沒有需要實現(xiàn)的方法，implementsSerializable只是為了標注該對象是可被序列化的。例如，在web開發(fā)中，如果對象被保存在了Session中，tomcat在重啟時要把Session對象序列化到硬盤，這個對象就必須實現(xiàn)Serializable接口。如果對象要經(jīng)過分布式系統(tǒng)進行網(wǎng)絡(luò)傳輸或通過rmi等遠程調(diào)用，這就需要在網(wǎng)絡(luò)上傳輸對象，被傳輸?shù)膶ο缶捅仨殞崿F(xiàn)Serializable接口。序列化的作用，應(yīng)用場景所謂java對象序列化就是將對象的狀態(tài)轉(zhuǎn)換成字節(jié)流，以后可以通過這些值再生成相同狀態(tài)的對象！對象序列化是對象持久化的一種實現(xiàn)方法,它是將一個對象的屬性和方法轉(zhuǎn)化為一種序列化的格式以用于存儲和傳輸,反序列化就是根據(jù)這些保存的信息重建對象的過程。運用場景1：Java的JavaBeans：Bean的狀態(tài)信息通常是在設(shè)計時配置的，Bean的狀態(tài)信息必須被存起來，以便當程序運行時能恢復這些狀態(tài)信息，這需要將對象的狀態(tài)保存到文件中，而后能夠通過讀入對象狀態(tài)來重新構(gòu)造對象，恢復程序狀態(tài)。例如Java.io包有兩個序列化對象的類。ObjectOutputStream負責將對象寫入字節(jié)流，ObjectInputStream從字節(jié)流重構(gòu)對象。運用場景2：activiti工作流設(shè)置流程變量Collection和Collections有什么區(qū)別？Collection是集合類的上級接口，繼承與他的接口主要有Set和List.Collections是針對集合類的一個幫助類，他提供一系列靜態(tài)方法實現(xiàn)對各種集合的搜索、排序、線程安全化等操作Strings=newString("abc")；請問有幾個String對象？分別是兩個或一個，“xyz”對應(yīng)一個對象，這個對象放在字符串常量緩沖區(qū)，常量“xyz”不管出現(xiàn)多少遍，都是緩沖區(qū)中的那一個。如果以前就用過‘xyz’直接從緩沖區(qū)拿。如果沒有就在字符串緩沖區(qū)創(chuàng)建這個“xyz”字符串對象，NewString每寫一遍，就創(chuàng)建一個新的對象。try{}里有一個return語句，那么緊跟在這個try后的finally{}里德code會不會被執(zhí)行？什么時候被執(zhí)行，在return之前還是后？public

class

Test

{

public

static

void

main(String[]

args)

{

System.out.println(new

Test().test());;

}

static

int

test(){

int

x

=

1;

try{

return

x;

}finally{

++x;

}

}

}

/*執(zhí)行結(jié)果

*/

1

/*運行結(jié)果是1，為什么呢？主函數(shù)調(diào)用子函數(shù)并得到結(jié)果的過程，好比主函數(shù)準備一個空罐子，當子函數(shù)要返回結(jié)果時，先把結(jié)果放在罐子里，然后再將程序邏輯返回到主函數(shù)。所謂返回，就是子函數(shù)說，我不運行了，你主函數(shù)繼續(xù)運行吧，這沒什么結(jié)果可言，結(jié)果是在說這話之前放進罐子里的。

*/java中可見的訪問修飾符的含義public：訪問不受限制。protected：訪問僅限于包含類或從包含類派生的類型。只有包含該成員的類以及繼承的類可以存取.Internal：訪問僅限于當前程序集。只有當前工程可以存取.protectedinternal：訪問僅限于當前程序集或從包含類派生的類型。private：訪問僅限于包含類型。只有包含該成員的類可以存取.java用什么來判斷對象是否是屬于某個類或借口的事例？InstanceofJava中，int和Integer有什么區(qū)別int是java提供的8種原始數(shù)據(jù)類型之一。Java為每個原始類型提供了封裝類，Integer是java為int提供的封裝類。int的默認值為0，而Integer的默認值為null，即Integer可以區(qū)分出未賦值和值為0的區(qū)別，int則無法表達出未賦值的情況，例如，要想表達出沒有參加考試和考試成績?yōu)?的區(qū)別，則只能使用Integer。在JSP開發(fā)中，Integer的默認為null，所以用el表達式在文本框中顯示時，值為空白字符串，而int默認的默認值為0，所以用el表達式在文本框中顯示時，結(jié)果為0，所以，int不適合作為web層的表單數(shù)據(jù)的類型。在Hibernate中，如果將OID定義為Integer類型，那么Hibernate就可以根據(jù)其值是否為null而判斷一個對象是否是臨時的，如果將OID定義為了int類型，還需要在hbm映射文件中設(shè)置其unsaved-value屬性為0。另外，Integer提供了多個與整數(shù)相關(guān)的操作方法，例如，將一個字符串轉(zhuǎn)換成整數(shù)，Integer中還定義了表示整數(shù)的最大值和最小值的常量Java中，HashMap和Hashtable的區(qū)別？HashMap把Hashtable的contains方法去掉了，改成containsvalue和containsKey。因為contains方法容易讓人引起誤解。Hashtable繼承自Dictionary類，而HashMap是Java1.2引進的Mapinterface的一個實現(xiàn)。最大的不同是，Hashtable的方法是Synchronize的，而HashMap不是，在多個線程訪問Hashtable時，不需要自己為它的方法實現(xiàn)同步，而HashMap就必須為之提供外同步。Hashtable和HashMap采用的hash/rehash算法都大概一樣，所以性能不會有很大的差異。就HashMap與HashTable主要從三方面來說。1.歷史原因:Hashtable是基于陳舊的Dictionary類的，HashMap是Java1.2引進的Map接口的一個實現(xiàn)2.同步性:Hashtable是線程安全的，也就是說是同步的，而HashMap是線程序不安全的，不是同步3.值：只有HashMap可以讓你將空值作為一個表的條目的key或valueJava中，String和StringBuffer的區(qū)別？1,String:字符串常量,字符串長度不可變!!!2,StringBuffer:字符串變量(Synchronized，即線程安全),如果要頻繁對字符串內(nèi)容進行修改，出于效率考慮最好使用StringBuffer，如果想轉(zhuǎn)成String類型，可以調(diào)用StringBuffer的toString()；StringBuffer上的主要操作是append和insert方法，可重載這些方法，以接受任意類型的數(shù)據(jù)。append方法始終將這些字符添加到緩沖區(qū)的末端；而insert方法則在指定的點添加字符。3,(*延伸)StringBuilder字符串變量（非線程安全）,這是在JDK5.0新增加的!!!,該對象是一個線程不安全的字符串容器,在單線程操作的情況下此對象可以用于取代StringBuffer!!!4，(String和StringBuffer)兩者者之間的區(qū)別:這兩者之間的區(qū)別主要區(qū)別在性能上,String,每次對存放進String當中的字符串進行更改的時候,都會生成一個新的String對象,然后指針指向該對象(雖然Java不承認自己有指針這回事),而一旦當產(chǎn)生的沒有引用指向?qū)ο筮^多的時候,這個時候GC就會出動,對其進行清理,這個時候,性能就會有所降低!!!而使用StringBuffer的時候,每次都會對該對象本身進行操作,而不是去創(chuàng)建一個新的對象,所以在多數(shù)情況下還是推薦使用該對象!!!但是某些特殊的情況下,使用String并不會比StringBuffer慢!!!例如:Stringstr="String1"+"String2"；&&StringBuffersb=newStringBuffer();sb.append("String1").append("String2");在這里的Stringstr="String1"+"String2"實際上被翻譯成了str="String1String2";Thread和Runnable有什么不同？首先,Java中Thread和Runnable是實現(xiàn)并發(fā)線程的兩種方式!!!,通過兩者中的任意一個都可以達到線程并發(fā)的目的!!!區(qū)別: 0,Thread是一個Class,Runnable是一個interface!!! 1,通過extendsThread，可獲得start(),sleep(),并覆蓋run(),使用時直接用start()，但有時不太方便通過繼承(extends)而進行多線程，例如已繼承了其它Class(Java不允許多重繼承)時，就應(yīng)該實現(xiàn)(implements)Runnable寫多線程程序。 2,注意，implementsRunnable創(chuàng)建的只有run()方法而沒有start()，因此要利用其它機制來啟動。這要創(chuàng)建兩個對象，第一個是Runnable的， 第二個是Thread的，然后把第一個當成參數(shù)傳給第二個!!! 3,由下面的程序可以看出,實現(xiàn)Runnable的多線程程序要比,繼承Thread的多線程程序靈活的多!!! 4,這里還有一點,就是說使用Runnable實現(xiàn)多線程可以達到資源共享目的,讓多個Thread對象接收同一個Runnable實現(xiàn)類的參數(shù),這樣就是多個線程操作同一塊資源!!! 例如://Runnable

接口的多線程程序舉例!!!

private

class

RunnableThread

implements

Runnable{

/*這個方法中寫,多線程執(zhí)行的程序!!!,因為這里是實現(xiàn)了Runnable所以就算再去繼承其他的class也不會違反java成不能多繼承的規(guī)定!!!*/

public

void

run(){

}

}

/*通過將Runnable的實現(xiàn)類作為參數(shù)傳遞給一個Thread對象,然后通過開啟Thread對象,就能讓其執(zhí)行自己復寫的方法,并且是并發(fā)操作!!!*/

Thread

runnThread

=

new

Thread(new

RunnableThread());

RunnThread.start();

/*1，繼承自Thread類的多線程程序

private

class

GenThread

extends

Thread

{

//這個方法中寫,多線程需要執(zhí)行的方法!!!

public

void

run()

{

}

}

Thread

theGenThread

=

new

GenThread();

theGenThread.start();

GC是什么，為什么要有GC?1,GC:垃圾回收(GarbageCollection),Java的內(nèi)存管理,其內(nèi)置的垃圾回收,是Java語言的優(yōu)秀成果,它允許開發(fā)者創(chuàng)建新的對象不需要明確內(nèi)存分配和釋放,因為垃圾回收器自動回收內(nèi)存當中的對象。2,垃圾收集釋放從手工處理內(nèi)存釋放的程序員。其結(jié)果是，某些類別的缺陷被消除或顯著減少：這也正是Java的特點(相對于C++來說,程序員不再需要通過痛苦的記憶哪里的內(nèi)存是釋放掉的,而哪一些是沒有釋放掉的)內(nèi)存不安全釋放的問題:1,當一塊內(nèi)存被釋放，同時還存在著指向它，而那些指針中的一個被廢棄發(fā)生。屆時內(nèi)存可能已被重新分配到其他使用，具有不可預(yù)知的結(jié)果。2,當程序試圖發(fā)生釋放的內(nèi)存已被釋放，并可能已經(jīng)被再次分配的區(qū)域。3,某些種類的內(nèi)存泄漏，其中一個程序無法釋放由已成為對象占用的內(nèi)存可達，從而導致內(nèi)存消耗殆盡。（垃圾收集通常不處理的數(shù)據(jù)是可到達的無界積累，但實際上將不被使用的程序）……是否可以從一個static方法內(nèi)部發(fā)出對非static方法的調(diào)用？不可以。因為非static方法是要與對象關(guān)聯(lián)在一起的，必須創(chuàng)建一個對象后，才可以在該對象上進行方法調(diào)用，而static方法調(diào)用時不需要創(chuàng)建對象，可以直接調(diào)用。也就是說，當一個static方法被調(diào)用時，可能還沒有創(chuàng)建任何實例對象，如果從一個static方法中發(fā)出對非static方法的調(diào)用，那個非static方法是關(guān)聯(lián)到哪個對象上的呢？這個邏輯無法成立，所以，一個static方法內(nèi)部發(fā)出對非static方法的調(diào)用。如何把一段逗號分隔的字符串轉(zhuǎn)換成一個數(shù)組？//方式一：使用String的split

方法

public

static

String[]

convertStrToArray(String

str){

String[]

strArray

=

null;

strArray

=

str.split(",");

return

strArray;

}

//方式二：使用StringTokenizer實現(xiàn)

//api說明：StringTokenizer

是出于兼容性的原因而被保留的遺留類

//（雖然在新代碼中并不鼓勵使用它）。建議所有尋求此功能的人使用

//String

的

split

方法或

java.util.regex

包

public

static

String[]

convertStrToArray2(String

str){

StringTokenizer

st

=

new

StringTokenizer(str,",");

String[]

strArray

=

new

String[st.countTokens()];

int

i=0;

while(st.hasMoreTokens()){

strArray[i++]

=

st.nextToken();

}

return

strArray;

}

HashMap和Hashtable的區(qū)別1、同步或線程安全：這是兩者最重要的區(qū)別。HashMap的是不同步的，不是線程安全的，另一方面，Hashtable是線程安全的，同步的。1-1、何時使用HashMap：答案是，如果您的應(yīng)用程序不需要任何多線程任務(wù)，換句話說HashMap的是對于非線程安全應(yīng)用程序的更好的選擇。哈希表應(yīng)當在多線程應(yīng)用中使用。2、null鍵和空值：HashMap是允許空鍵空值的,而Hashtable是不允許空鍵空值的。3、迭代器類型：HashTable使用Enumeration，HashMap使用Iterator。4、性能：HashMap因為是線程不安全的,效率要比Hashtable高。5、Hashtable是Dictionary類現(xiàn)在是在JDK1.7過時的子類，因此，它已不再使用。（hashmap與hashtable

Hashtable繼承自Dictionary類，而HashMap是Java1.2引進的Map

interface的一個實現(xiàn)

HashMap允許將null作為一個entry的key或者value，而Hashtable不允許

還有就是，HashMap把Hashtable的contains方法去掉了，改成containsvalue和containsKey。因為contains方法容易讓人引起誤解。

最大的不同是，Hashtable的方法是Synchronize的，而HashMap不是，在

多個線程訪問Hashtable時，不需要自己為它的方法實現(xiàn)同步，而HashMap

就必須為之提供外同步）java堆和棧的區(qū)別Java棧是與每一個線程關(guān)聯(lián)的，JVM在創(chuàng)建每一個線程的時候，會分配一定的?？臻g給線程，主要存放線程執(zhí)行過程中的局部變量，方法的返回值，基本類型的變量（,int,short,long,byte,float,double,boolean,char）以及方法調(diào)用的上下文。?？臻g隨著線程的終止而釋放，棧的優(yōu)勢是，存取速度比堆要快，棧數(shù)據(jù)可以共享。但缺點是，存在棧中的數(shù)據(jù)大小與生存期必須是確定的，缺乏靈活性。棧有一個很重要的特殊性，就是存在棧中的數(shù)據(jù)可以共享。Java中堆是由所有的線程共享的一塊內(nèi)存區(qū)域，堆用來保存各種JAVA對象，比如數(shù)組，線程對象等,java的堆是一個運行時數(shù)據(jù)區(qū),類的(對象從中分配空間。這些對象通過new、newarray、anewarray和multianewarray等指令建立，它們不需要程序代碼來顯式的釋放。堆是由垃圾回收來負責的，堆的優(yōu)勢是可以動態(tài)地分配內(nèi)存大小，生存期也不必事先告訴編譯器，因為它是在運行時動態(tài)分配內(nèi)存的，Java的垃圾收集器會自動收走這些不再使用的數(shù)據(jù)。但缺點是，由于要在運行時動態(tài)分配內(nèi)存，存取速度較慢。當一個線程進入一個對象的synchronized方法后，其他線程是否可進入此對象的其他方法？為什么？分情況而定：1.其他方法前是否加了synchronized關(guān)鍵字，如果沒加，則能。2.如果這個方法內(nèi)部調(diào)用了wait，則可以進入其他synchronized方法。3.如果其他個方法都加了synchronized關(guān)鍵字，并且內(nèi)部沒有調(diào)用wait，則能。4.如果其他方法是static，它用的同步鎖是當前類的字節(jié)碼，與非靜態(tài)的方法不能同步，因為非靜態(tài)的方法用的是this99乘法表/*主要是利用雙層for循環(huán)來實現(xiàn)，外層循環(huán)9次，內(nèi)層每次循環(huán)的次數(shù)與外層是第幾次循環(huán)有關(guān)，還要考慮字符串的拼接及換行和制表符的問題，具體代碼如下：*/

public

class

s99{

public

static

void

main(String[]

args){

for

(int

i=1;i<=9;i++)

{

for

(int

j=1;j<=i;j++){

System.out.print(i+"*"+j+"="+(i*j)+"\t");

}

System.out.print("\n");

}

}

}

常用的字符轉(zhuǎn)碼方式什么？舉例說明1.escape方法對String對象編碼,escape方法返回一個包含了"轉(zhuǎn)義序列"的字符串值。除了ASCII字母和數(shù)字，以及這幾個符號*+-/.@_外(共有10+52+7=69個字符不會被編碼)，其他所有的字符都會被轉(zhuǎn)義序列替換，標準ASCII碼內(nèi)的字符(0-127)和擴展的ASCII碼內(nèi)的字符(128-255)都用%xx編碼形式代替。字符值大于255的以unicode%uxxxx格式存儲。注意:escape方法不能夠用來對統(tǒng)一資源標示符URI進行編碼,因為=&?#等會被編碼.對URI編碼應(yīng)使用encodeURI,對URI參數(shù)用encodeURIComponent方法。2.encodeURI除了ASCII字母和數(shù)字，以及這幾個符號*+-/.@_!#$&\'(),:=?~外(共有10+52+20=82個字符不會被編碼)，其他所有的字符都會被轉(zhuǎn)義序列替換，標準ASCII碼內(nèi)的字符(0-127)和擴展的ASCII碼內(nèi)的字符(128-255)都用%xx編碼形式代替。字符值大于255的以utf-8多字節(jié)%xx格式存儲。在URI中有特殊意義的字符如?=&等不會被編碼。3.encodeURIComponent除了ASCII字母和數(shù)字，以及這幾個符號*-_.~!'()外(共有10+52+9=71個字符不會被編碼)，其他所有的字符都會被轉(zhuǎn)義序列替換，標準ASCII碼內(nèi)的字符(0-127)和擴展的ASCII碼內(nèi)的字符(128-255)都用%xx編碼形式代替。字符值大于255的以utf-8多字節(jié)%xx格式存儲。可以看到?=&等在URI中有特殊意義的字符也會被編碼。encodeURIComponent方法在編碼單個URIComponent（指請求參數(shù)）應(yīng)當是最常用的，它可以將參數(shù)中的中文、特殊字符進行轉(zhuǎn)義，而不會影響整個URL。如何給tomcat指定大小的內(nèi)存Tomcat默認可以使用的內(nèi)存為128MB，在較大型的應(yīng)用項目中，這點內(nèi)存是不夠的，需要調(diào)大。有以下幾種方法可以選用：第一種方法：Windows下，在文件/bin/catalina.bat，Unix下，在文件/bin/catalina.sh的前面，增加如下設(shè)置：JAVA_OPTS='-Xms【初始化內(nèi)存大小】-Xmx【可以使用的最大內(nèi)存】'需要把這個兩個參數(shù)值調(diào)大。例如：JAVA_OPTS='-Xms256m-Xmx512m'表示初始化內(nèi)存為256MB，可以使用的最大內(nèi)存為512MB。第二種方法：環(huán)境變量中設(shè)變量名：JAVA_OPTS變量值：-Xms512m-Xmx512m第三種方法：前兩種方法針對的是bin目錄下有catalina.bat的情況（比如直接解壓的Tomcat等），但是有些安裝版的Tomcat下沒有catalina.bat，這個時候可以采用如下方法，當然這個方法也是最通用的方法：打開tomcatHome/\bin/\tomcat5w.exe，點擊Java選項卡，然后將會發(fā)現(xiàn)其中有這么兩項：Initialmemorypool和Maximummemorypool.Initialmemorypool這個就是初始化設(shè)置的內(nèi)存的大小。Maximummemorypool這個是最大JVM內(nèi)存的大小設(shè)置完了就按確定然后再重啟TOMCAT你就會發(fā)現(xiàn)tomcat中jvm可用的內(nèi)存改變了。final，finally，finalize的區(qū)別1.final為關(guān)鍵字，final定義基本類型變量時，要求變量初始化必須在聲明時或者構(gòu)造函數(shù)中，不能用于其它地方。該關(guān)鍵字定義的常量，除了初始化階段，不能更改常量的值；final定義對象的引用，該引用的初始化與定義常量時的要求一致；該關(guān)鍵字定義的對象內(nèi)容可以改變，但是引用指向的地址不能改變；final修飾類時無法被其他任何類繼承。2.finalize()方法在Object中進行了定義，用于在對象“消失”時，由JVM進行調(diào)用用于對對象進行垃圾回收。3.finally為區(qū)塊標志，用于try語句中，表示必須運行的區(qū)塊部分。Collection和Collections的區(qū)別Collection是集合類的上級接口，繼承與他的接口主要有Set和List.Collections是針對集合類的一個幫助類，他提供一系列靜態(tài)方法實現(xiàn)對各種集合的搜索、排序、線程安全化等操作組合和聚合的區(qū)別聚合：表示兩個對象之間是整體和部分的弱關(guān)系，部分的生命周期可以超越整體。電腦和鼠標的關(guān)系組合：表示兩個對象之間是整體和部分的強關(guān)系，部分的生命周期不能超越整體，或者說不能脫離整體而存在。組合的關(guān)系“部分”是不能再整體之間進行共享的。如人跟眼睛關(guān)聯(lián)和依賴的區(qū)別關(guān)聯(lián)：簡單而言，如果一個類作為了另外一個類的屬性，那一定是關(guān)聯(lián)關(guān)系。但是聚合是一種特殊的關(guān)聯(lián)，而組合又是一種特殊的聚合。一般的關(guān)聯(lián)我們認為是平級、無整體部分關(guān)系的，如朋友關(guān)系。依賴：對象之間的臨時關(guān)系，臨時性體現(xiàn)在不超越方法的周期。簡單地說，在方法使用到的，如參數(shù)類，就一定是依賴關(guān)系JDK中用到的設(shè)計模式1、創(chuàng)建模式 Singleton（單例）：只允許創(chuàng)建一個實例Runtime.getRuntime();

java.awt.Toolkit.getDefaultToolkit();

java.awt.GraphicsEnvironment.getLocalGraphicsEnvironment();

java.awt.Desktop.getDesktop();

Abstractfactory(抽象工廠):創(chuàng)建一組有關(guān)聯(lián)的對象實例java.util.Calendar.getInstance();

java.util.Arrays.asList();

java.util.ResourceBundle.getBundle(String

baseName);

java.sql.DriverManager.getConnection(String

url);

java.sql.Connection.createStatement();

java.sql.Statement.executeQuery(String

sql);

java.text.NumberFormat.getInstance();

javax.xml.transform.TransformerFactory.newInstance();

Factory(工廠方法):按照需求返回一個類型的實例java.lang.Proxy.newProxyInstance();

java.lang.Object.toString();

java.lang.Class.newInstance();

java.lang.reflect.Array.newInstance();

java.lang.reflect.Constructor.newInstance();

java.lang.Boolean.valueOf(String

s);

java.lang.Class.forName(String

className);

Builder(建造者):主要用來簡化一個復雜的對象的創(chuàng)建java.lang.StringBuilder.append(Object

obj);

java.lang.StringBuffer.append(Object

obj);

java.sql.PreparedStatement

javax.swing.GroupLayout.Group.addComponent();

Prototype(原型):使用自己的實例創(chuàng)建另一個實例java.lang.Object.clone();

java.lang.Cloneable;

結(jié)構(gòu)模式Adapter(適配器):個接口或是類變成另外一種java.util.Arrays.asList();

javax.swing.JTable(TableModel)

java.io.InputStreamReader(InputStream)

java.io.OutputStreamWriter(OutputStream)

javax.xml.bind.annotation.adapters.XmlAdapter.marshal();

javax.xml.bind.annotation.adapters.XmlAdapter.unmarshal();

Composite(組合):讓使用者把單獨的對象和組合對象混用javax.swing.JComponent.add(Component

comp);

java.awt.Container.add(Component

comp);

java.util.Map.putAll(Map

m);

java.util.List.addAll(Collection

c);

java.util.Set.addAll(Collection

c);

Decorator(裝飾器):為一個對象動態(tài)的加上一系列的動作，而不需要因為這些動作的不同而產(chǎn)生大量的繼承類java.io.BufferedInputStream(InputStream);

java.io.DataInputStream(InputStream);

java.io.BufferedOutputStream(OutputStream);

java.util.zip.ZipOutputStream(OutputStream);

java.util.Collections.checkedList(List

list,

Class

type)

;

Facade(門面):一個簡單的接口包狀一組組件，接口，抽象或是子系統(tǒng)。java.lang.Class

javax.faces.webapp.FacesServlet

Flyweight(共享元):有效率地存儲大量的小的對象java.lang.Integer.valueOf(int)

java.lang.Boolean.valueOf(boolean)

java.lang.Byte.valueOf(byte)

java.lang.Character.valueOf(char)

Proxy(代理):用一個簡單的對象來代替一個復雜的對象java.lang.reflect.Proxy

行為模式ChainofResponsibility(責任鏈):一個對象在一個鏈接傳遞直到被處理java.util.logging.Logger.log()

javax.servlet.Filter.doFilter()

Command(命令):將一系列的命令封裝成在一個類中java.lang.Runnable

javax.swing.Action

Interpreter(解釋器):定義語言的文法,并且建立一個解釋器來解釋該語言中的句子java.util.Pattern

java.text.Normalizer

java.text.Format

Iterator(迭代器):對象遍歷java.util.Iterator

java.util.Enumeration

Mediator(中介):用一個中介對象來封裝一系列關(guān)于對象交互行為java.util.Timer

java.util.concurrent.Executor.execute()

java.util.concurrent.ExecutorService#submit()

java.lang.reflect.Method.invoke()

Memento(快照):保存另外一個對象內(nèi)部狀態(tài)拷貝的對象java.util.Date

java.io.Serializable

額Observer(觀察者):事件監(jiān)聽器java.util.EventListener

javax.servlet.http.HttpSessionBindingListener

javax.servlet.http.HttpSessionAttributeListener

javax.faces.event.PhaseListener

State(狀態(tài)):不同的狀態(tài),不同的行為;或者說,每個狀態(tài)有著相應(yīng)的行為.java.util.Iterator

javax.faces.lifecycle.LifeCycle.execute()

Strategy(策略):定義一系列的算法,把這些算法一個個封裝成單獨的類java.util.Cpare()

javax.servlet.http.HttpServlet

javax.servlet.Filter.doFilter()

Template(模板):定義一個操作中算法的骨架,將一些步驟的執(zhí)行延遲到其子類中java.util.Collections.sort()

java.io.InputStream.skip()

java.io.InputStream.read()

java.util.AbstractList.indexOf()

Visitor(訪問者):作用于某個對象群中各個對象的操作.它可以使你在不改變這些對象本身的情況下,定義作用于這些對象的新操作.javax.lang.model.element.Elementjavax.lang.model.element.ElementVisitor

javax.lang.model.type.TypeMirrorjavax.lang.model.type.TypeVisitor

在Java中，什么是interface，abstractclass？Interface和abstractclass有何區(qū)別？interface:java中的接口是，程序的規(guī)范,當中可以定義常量和抽象方法(它允許使用者確定方法名，參數(shù)列表和返回值,但是沒有方法體)，接口提供了形式,但是沒有提供具體的實現(xiàn)。abstractClass：抽象類，抽象類是接口和普通類之間的一種實現(xiàn)方式，因為不能總是使用純接口，但是又必須使用抽象方法的時候，抽象類就成了用于此目的的重要工具。abstractmethod：僅有聲明而沒有方法體的方法，就成為抽象方法，包含抽象方法的類就叫抽象類，這個時候的類就不需要加上abstract的限定，否則編譯錯誤。Interface和abstractclass的區(qū)別：接口中不允許有方法實現(xiàn)，抽象類中，可以存在抽象或者非抽象方法。接口中只能有靜態(tài)的不可修改的成員(staticfinal)。因為java只允許單集成，所以抽象作為類型定義，受到了極大的限制，但是接口可以多實現(xiàn)。設(shè)計理念不同，abstractclass表示的是“is-a”關(guān)系，而interface表示“l(fā)ike-a”關(guān)系。抽象類中的變量默認是friendly型，其值可以在子類中重新定義，也可以重新賦值。接口中的方法默認都是publicabstract類型的。String和StringBuffer有什么區(qū)別？String是字符串常量，字符串長度不可變！StringBuffer字符串變量(Synchronized,線程安全)，如果要頻繁對字符串內(nèi)容進行修改，處于效率考慮最好使用StringBuffer，如果想轉(zhuǎn)換成String類型，可以調(diào)用StringBuffer的toString();StringBuffer上的主要操作是append和insert方法，可重載這些方法，已接受任意類型的數(shù)據(jù)。（*延伸）StringBuilder字符串變量（非現(xiàn)場安全），這是JDK5.0新增，該對象是一個線程不安全的字符串容器，在單線程操作的情況下此對象可以用于取代StringBuffer。兩者區(qū)別：主要體現(xiàn)在性能上，每次對存放進String當中的字符串進行更改的時候，都會生成一個新的String對象，然后指針指向該對象，而一旦當產(chǎn)生的沒有引用指向?qū)ο筮^多的時候，GC就會回收，降低性能；而使用StringBuffer的時候，每次都會對該對象本身進行操作，而不是去創(chuàng)建一個新的對象，所以在多數(shù)情況下還是推薦使用。String某些情況下不比StringBuffer慢；如：String

str

=

"string1"+"string2";

StringBuffer

sb

=

new

StringBuffer();

sb.append("string1").append("string2");

在這里Stringstr="string1"+"string2";<==>str="string1string2";說明鏈表、哈希表、數(shù)組的特點（靖城遠景公司）鏈表是一種物理存儲單元上非連續(xù)，非順序的存儲結(jié)構(gòu)，數(shù)據(jù)元素的邏輯順序是通過鏈表中的指針鏈接次序?qū)崿F(xiàn)的。鏈表的存儲在內(nèi)存中可以是非連續(xù)性的，因為鏈表結(jié)構(gòu)可以通過自身節(jié)點中的數(shù)據(jù)域指針域來找到下一個節(jié)點。對鏈表進行刪除插入操作時，只需要將其指針域進行修改即可（相對于數(shù)組來說內(nèi)部操作更便捷）鏈表本身不存在下標，所有查詢效率略低。*：一般而言進行刪除修改等操作的時候使用的是鏈表結(jié)構(gòu)，而查詢的時候則使用數(shù)組結(jié)構(gòu)*：Java中由于linked*的內(nèi)部實現(xiàn)是采用鏈表結(jié)構(gòu)。散列表（Hashtable，也叫哈希表），是根據(jù)關(guān)鍵碼值（KeyValue）而直接進行訪問的數(shù)據(jù)結(jié)構(gòu)哈希表最大的優(yōu)勢，就是把數(shù)據(jù)的存儲和查詢消耗的時間大大降低，幾乎可以看成是常數(shù)時間。損失的代價僅僅是消耗比較多的內(nèi)存，然而在當前可利用內(nèi)存越來越多的情況下，用空間換時間的做法是相當值得的。而且編碼也比較容易。散列表查詢速度快的原因：將鍵值保存在某處，以便于能很快找到（數(shù)組中，這里保存的不是鍵本身而是鍵的信息，數(shù)組的下標就是這個對象的hashCode）查詢的過程就變成了，首先生產(chǎn)該對象的HashCode，然后查詢數(shù)組，，然后再去保存值的list當中查詢數(shù)組是一種物理存儲單元上連續(xù)，順序的存儲結(jié)構(gòu)，可以通過下標訪問數(shù)組元素。數(shù)組的保存效率高并且具備保存基本類型的能力。數(shù)組是一種簡單的線性序列，這使得訪問速度非常快。數(shù)組在定義時其大小被固定，并且在其聲明周期中不可改變。數(shù)組的查詢速度，相對來說是比較快的，因為可以對其索引進行快速便利。ArrayList、LinkedList和Vector的區(qū)別ArrayList：底層數(shù)據(jù)結(jié)構(gòu)是數(shù)組，運行所有元素，包括null，查詢快，增刪慢，線程不安全(非同步)，效率高！Vector：底層數(shù)據(jù)結(jié)構(gòu)是數(shù)組，查詢快，增刪慢，線程安全（同步）,效率低~！LinkedList：底層數(shù)據(jù)結(jié)構(gòu)是鏈表，允許null元素，查詢慢，增刪快，線程不安全（非同步），效率高！多線程有幾種實現(xiàn)方法，都是什么？啟動一個線程調(diào)用的是哪個方法？Java中Thread和Runnable是實現(xiàn)并發(fā)線程的兩種方式！區(qū)別：Thread是一個Class，Runnable是一個interface通過extendsThread，可獲得start(),sleep(),并覆蓋run()，使用時直接調(diào)用start()方法即可，但是有時不方便通過繼承而進行多線程，如已經(jīng)繼承其他的class時，就需要實現(xiàn)實現(xiàn)Runnable接口了，因為Java是不允許多繼承形式的出現(xiàn)，但是可以使用多實現(xiàn)。而implementRunnable接口的時候，創(chuàng)建的只有run()方法，而沒有start()方法，因此要利用其他機制來啟動。這就要創(chuàng)建兩個對象，第一個是Runnable的，第二個是Thread的，然后把第一個當成參數(shù)傳遞給第二個；*：使用Runnable實現(xiàn)多線程可以到達資源共享的目的，讓多個Thread對象接收同一個Runnable實現(xiàn)類的參數(shù)，這樣就是多個線程同時操作同一塊資源。private

class

RunnableThread

implements

Runnable

{

//這個方法中寫,多線程執(zhí)行的程序!!!,因為這里是實現(xiàn)了Runnable所以就算再去繼承其他的class也不會違反java成不能多繼承的規(guī)定!!!

public

void

run(){

}

}

//通過將Runnable的實現(xiàn)類作為參數(shù)傳遞給一個Thread對象,然后通過開啟Thread對象,就能讓其執(zhí)行自己復寫的方法,并且是并發(fā)操作!!!

Thread

runnThread

=

new

Thread(new

RunnableThread());

RunnThread.start();

//1,繼承自

Thread類的多線程程序!!!

private

class

GenThread

extends

Thread{

//這個方法中寫,多線程需要執(zhí)行的方法!!!

public

void

run()

{

}

}

Thread

theGenThread

=

new

GenThread();

theGenThread.start();

Class.forName()的作用？裝載一個類并且對其進行實例化的操作。裝載過程中使用到的類加載器是當前類。*：為了詳細描述，Class.forName()方法，這里使用classLoader.loadClass()進行對比描述Class.forName(StringclassName)使用裝載當前類的類裝載器來裝載制定的類，因為class.forName(Stringname)方法內(nèi)部調(diào)用了Class.forName(className,true,this.getClass().getClassLoader())方法。classLoader.loadClass(StringclassName,booleanresolve);需要手動制定裝載器的實例。Class.forName(className)裝載的class已經(jīng)被實例化，classLoader.loadClass().則只是將信息裝載給JVM。在JDBC中Class.forName(“com.mysql.jdbc.Driver”)，如果換成getClass().getClassLoader().loadClass(“com.mysql.jdbc.Driver”)，就不可以，因為它只是想JVM裝載了Driver的類信息，但是沒有實例化，也就不能執(zhí)行相應(yīng)的操作，因為Driver是需要被初始化才能被使用的。請列出最少3中J2EE 體系內(nèi)組件、服務(wù)或API請列出至少5中使用過關(guān)的開源軟件tomcat–Apache極具影響力的開源軟件strutsjdbcmavenactivitijfreechartjxl完成一個Map的toString()方法，要求輸出該Map中所有鍵-值信息publicclassMyMap<K,V>extendsAbstractMap<K,V>{ privateList<K>keys=newArrayList<K>(); privateList<V>values=newArrayList<V>(); //put操作. publicVput(Kkey,Vvalue){ VoldValue=get(key); if(!keys.contains(key)){ keys.add(key); values.add(value); }else values.set(keys.indexOf(key),value); returnoldValue; } //get操作,進行鍵值輸出的必要方法. publicVget(Objectkey){ if(!keys.contains(key)) returnnull; returnvalues.get(keys.indexOf(key)); } @Override publicStringtoString(){ return"MyMap[keys="+keys+",values="+values+"]"; } @Override publicSet<java.util.Map.Entry<K,V>>entrySet(){ thrownewRuntimeOperationsException(null,"不可操作異常."); } publicstaticvoidmain(String[]args){ MyMap<String,String>myMap=newMyMap<String,String>(); myMap.put("信息1","大"); myMap.put("信息2","大"); myMap.put("信息3","大"); myMap.put("信息4","大"); myMap.put("信息5","大"); myMap.put("信息6","大"); System.out.println(myMap); }}一個類是否可以繼承多個接口？1、在Java中接口是允許多實現(xiàn)的，接口和接口之間可以進行多實現(xiàn)，大部分的類也都是實現(xiàn)多個接口。一個類是否可以繼承多個超類？1、類的繼承，同一層次結(jié)構(gòu)只能繼承一個類。接口是否可繼承接口？1、接口之間不能實現(xiàn)，因為接口本身就是抽象的，但是接口可以繼承接口的，并且可以進行多繼承（因為抽象，所以不擔心方法的沖突）抽象類是否可以實現(xiàn)（implement）接口？1、可以，抽象類也是類，類是可以實現(xiàn)接口的。如何將字符串轉(zhuǎn)換為Integer？1、IntegerparseInt=Integer.parseInt(“123”);如何將日期類型轉(zhuǎn)換為”xxxx年xx月xx日“格式的字符串？@Test publicvoidformatDate(){ Datetime=newDate(); DateFormatdf=newSimpleDateFormat("yyyy年MM月dd日-hh:mm:ss"); System.err.println(df.format(time));}如何將字符串bbbwlirbbb轉(zhuǎn)換為bbbhhtccc?@Test publicvoidchange(){ Stringstr="bbbwlirbbb"; Stringstr1=str.replaceAll(str,"bbbhhtccc"); System.err.println(str1); }文件拷貝，把一個文件的內(nèi)容拷貝到另外一個文件里項目中使用過哪些JSTL標簽導入庫：<%@tagliburi="/jsp/jstl/core"prefix="c"%><