上一篇，我們給出了大概35個題目，都是基礎知識，有童鞋反映題目過時了，其實不然，這些是基礎中的基礎，但是也是必不可少的，面試題目中還是有一些基礎題目的，我們本著先易后難的原則，逐漸給出不同級別的題目，猛料還在后頭呢，繼續關注哦。
這一章我們繼續接下來的35個題目，這些題目也是一些基礎知識，看看你有沒有掌握咯。
36、數組有沒有length()這個方法? String有沒有length()這個方法？
數組沒有length()這個方法，有length的屬性。String有有length()這個方法。
37、下面這條語句一共創建了多少個對象：String s="a"+"b"+"c"+"d";
答：對于如下代碼：
String s1 = "a";
String s2 = s1 + "b";
String s3 = "a" + "b";
System.out.println(s2 == "ab");
System.out.println(s3 == "ab");
第一條語句打印的結果為false，第二條語句打印的結果為true，這說明javac編譯可以對字符串常量直接相加的表達式進行優化，不必要等到運行期去進行加法運算處理，而是在編譯時去掉其中的加號，直接將其編譯成一個這些常量相連的結果。
題目中的第一行代碼被編譯器在編譯時優化后，相當于直接定義了一個”abcd”的字符串，所以，上面的代碼應該只創建了一個String對象。寫如下兩行代碼，
String s ="a" + "b" + "c" + "d";
System.out.println(s== "abcd");
最終打印的結果應該為true。
38、try {}里有一個return語句，那么緊跟在這個try后的finally {}里的code會不會被執行，什么時候被執行，在return前還是后?
也許你的答案是在return之前，但往更細地說，我的答案是在return中間執行，請看下面程序代碼的運行結果：
publicclassTest {
/**
*@paramargs add by zxx ,Dec 9, 2008
*/
public static voidmain(String[] args) {
//TODOAuto-generated method stub
System.out. println (newTest().test());;
}
staticinttest()
{
intx = 1;
try
{
Returnx;
}
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語句后才真正開始返回。
在講解答案時可以用下面的程序來幫助分析：
publicclassTest {
/**
*@paramargs add by zxx ,Dec 9, 2008
*/
public static voidmain(String[] args) {
//TODOAuto-generated method stub
System.out.println(newTest().test());;
}
inttest()
{
try
{
returnfunc1();
}
finally
{
returnfunc2();
}
}
intfunc1()
{
System.out.println("func1");
return1;
}
intfunc2()
{
System.out.println("func2");
return2;
}
}
-----------執行結果-----------------
func1
func2
2
結論：finally中的代碼比return和break語句后執行
40、final, finally, finalize的區別。
final 用于聲明屬性，方法和類，分別表示屬性不可變，方法不可覆蓋，類不可繼承。
內部類要訪問局部變量，局部變量必須定義成final類型，例如，一段代碼……
finally是異常處理語句結構的一部分，表示總是執行。
finalize是Object類的一個方法，在垃圾收集器執行的時候會調用被回收對象的此方法，可以覆蓋此方法提供垃圾收集時的其他資源回收，例如關閉文件等。JVM不保證此方法總被調用
41、運行時異常與一般異常有何異同？
異常表示程序運行過程中可能出現的非正常狀態，運行時異常表示虛擬機的通常操作中可能遇到的異常，是一種常見運行錯誤。java編譯器要求方法必須聲明拋出可能發生的非運行時異常，但是并不要求必須聲明拋出未被捕獲的運行時異常。
42、error和exception有什么區別?
error 表示恢復不是不可能但很困難的情況下的一種嚴重問題。比如說內存溢出。不可能指望程序能處理這樣的情況。 exception表示一種設計或實現問題。也就是說，它表示如果程序運行正常，從不會發生的情況。
43、Java中的異常處理機制的簡單原理和應用。
異常是指java程序運行時（非編譯）所發生的非正常情況或錯誤，與現實生活中的事件很相似，現實生活中的事件可以包含事件發生的時間、地點、人物、情節等信息，可以用一個對象來表示，Java使用面向對象的方式來處理異常，它把程序中發生的每個異常也都分別封裝到一個對象來表示的，該對象中包含有異常的信息。
Java對異常進行了分類，不同類型的異常分別用不同的Java類表示，所有異常的根類為java.lang.Throwable，Throwable下面又派生了兩個子類：Error和Exception，Error表示應用程序本身無法克服和恢復的一種嚴重問題，程序只有死的份了，例如，說內存溢出和線程死鎖等系統問題。Exception表示程序還能夠克服和恢復的問題，其中又分為系統異常和普通異常，系統異常是軟件本身缺陷所導致的問題，也就是軟件開發人員考慮不周所導致的問題，軟件使用者無法克服和恢復這種問題，但在這種問題下還可以讓軟件系統繼續運行或者讓軟件死掉，例如，數組腳本越界（ArrayIndexOutOfBoundsException），空指針異常（NullPointerException）、類轉換異常（ClassCastException）；普通異常是運行環境的變化或異常所導致的問題，是用戶能夠克服的問題，例如，網絡斷線，硬盤空間不夠，發生這樣的異常后，程序不應該死掉。
java為系統異常和普通異常提供了不同的解決方案，編譯器強制普通異常必須try..catch處理或用throws聲明繼續拋給上層調用方法處理，所以普通異常也稱為checked異常，而系統異?？梢蕴幚硪部梢圆惶幚?，所以，編譯器不強制用try..catch處理或用throws聲明，所以系統異常也稱為unchecked異常。
提示答題者：就按照三個級別去思考：虛擬機必須宕機的錯誤，程序可以死掉也可以不死掉的錯誤，程序不應該死掉的錯誤；
44、請寫出你最常見到的5個runtime exception。
這道題主要考你的代碼量到底多大，如果你長期寫代碼的，應該經常都看到過一些系統方面的異常，你不一定真要回答出5個具體的系統異常，但你要能夠說出什么是系統異常，以及幾個系統異常就可以了，當然，這些異常完全用其英文名稱來寫是最好的，如果實在寫不出，那就用中文吧，有總比沒有強！
所謂系統異常，就是…..，它們都是RuntimeException的子類，在jdk
doc中查RuntimeException類，就可以看到其所有的子類列表，也就是看到了所有的系統異常。我比較有印象的系統異常有：NullPointerException、ArrayIndexOutOfBoundsException、ClassCastException。
45、JAVA語言如何進行異常處理，關鍵字：throws,throw,try,catch,finally分別代表什么意義？在try塊中可以拋出異常嗎？
46、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 voidrun(){
}
}
).start();
從java5開始，還有如下一些線程池創建多線程的方式：
ExecutorService pool = Executors.newFixedThreadPool(3)
for(int i=0;i<10;i++)
{
pool.execute(newRunable(){public void run(){}});
}
Executors.newCachedThreadPool().execute(new Runable(){publicvoid run(){}});
Executors.newSingleThreadExecutor().execute(new Runable(){publicvoid run(){}});
有兩種實現方法，分別使用new Thread()和new Thread(runnable)形式，第一種直接調用thread的run方法，所以，我們往往使用Thread子類，即new SubThread()。第二種調用runnable的run方法。
有兩種實現方法，分別是繼承Thread類與實現Runnable接口
用synchronized關鍵字修飾同步方法
反對使用stop()，是因為它不安全。它會解除由線程獲取的所有鎖定，而且如果對象處于一種不連貫狀態，那么其他線程能在那種狀態下檢查和修改它們。結果很難檢查出真正的問題所在。suspend()方法容易發生死鎖。調用suspend()的時候，目標線程會停下來，但卻仍然持有在這之前獲得的鎖定。此時，其他任何線程都不能訪問鎖定的資源，除非被"掛起"的線程恢復運行。對任何線程來說，如果它們想恢復目標線程，同時又試圖使用任何一個鎖定的資源，就會造成死鎖。所以不應該使用suspend()，而應在自己的Thread類中置入一個標志，指出線程應該活動還是掛起。若標志指出線程應該掛起，便用wait()命其進入等待狀態。若標志指出線程應當恢復，則用一個notify()重新啟動線程。
47、sleep()和wait()有什么區別?
（網上的答案：sleep是線程類（Thread）的方法，導致此線程暫停執行指定時間，給執行機會給其他線程，但是監控狀態依然保持，到時后會自動恢復。調用sleep不會釋放對象鎖。
wait是Object類的方法，對此對象調用wait方法導致本線程放棄對象鎖，進入等待此對象的等待鎖定池，只有針對此對象發出notify方法（或notifyAll）后本線程才進入對象鎖定池準備獲得對象鎖進入運行狀態。）
sleep就是正在執行的線程主動讓出cpu，cpu去執行其他線程，在sleep指定的時間過后，cpu才會回到這個線程上繼續往下執行，如果當前線程進入了同步鎖，sleep方法并不會釋放鎖，即使當前線程使用sleep方法讓出了cpu，但其他被同步鎖擋住了的線程也無法得到執行。wait是指在一個已經進入了同步鎖的線程內，讓自己暫時讓出同步鎖，以便其他正在等待此鎖的線程可以得到同步鎖并運行，只有其他線程調用了notify方法（notify并不釋放鎖，只是告訴調用過wait方法的線程可以去參與獲得鎖的競爭了，但不是馬上得到鎖，因為鎖還在別人手里，別人還沒釋放。如果notify方法后面的代碼還有很多，需要這些代碼執行完后才會釋放鎖，可以在notfiy方法后增加一個等待和一些代碼，看看效果），調用wait方法的線程就會解除wait狀態和程序可以再次得到鎖后繼續向下運行。對于wait的講解一定要配合例子代碼來說明，才顯得自己真明白。
packagecom.huawei.interview;
publicclassMultiThread {
/**
*@paramargs
*/
public static voidmain(String[] args) {
//TODOAuto-generated method stub
newThread(newThread1()).start();
try{
Thread.sleep(10);
}catch(InterruptedException e) {
//TODOAuto-generated catchblock
e.printStackTrace();
}
newThread(newThread2()).start();
}
private static classThread1implementsRunnable
{
@Override
public voidrun() {
//TODOAuto-generated methodstub
//由于這里的Thread1和下面的Thread2內部run方法要用同一對象作為監視器，我們這里不能用this，因為在Thread2里面的this和這個Thread1的this不是同一個對象。我們用MultiThread.class這個字節碼對象，當前虛擬機里引用這個變量時，指向的都是同一個對象。
synchronized(MultiThread.class){
System.out.println("enterthread1...");
System.out.println("thread1is waiting");
try{
//釋放鎖有兩種方式，第一種方式是程序自然離開監視器的范圍，也就是離開了synchronized關鍵字管轄的代碼范圍，另一種方式就是在synchronized關鍵字管轄的代碼內部調用監視器對象的wait方法。這里，使用wait方法釋放鎖。
MultiThread.class.wait();
}catch(InterruptedException e) {
//TODOAuto-generatedcatch block
e.printStackTrace();
}
System.out.println("thread1is going on...");
System.out.println("thread1is being over!");
}
}
}
private static classThread2implementsRunnable
{
@Override
public voidrun() {
//TODOAuto-generated methodstub
synchronized(MultiThread.class){
System.out.println("enterthread2...");
System.out.println("thread2notify other thread can release wait status..");
//由于notify方法并不釋放鎖，即使thread2調用下面的sleep方法休息了10毫秒，但thread1仍然不會執行，因為thread2沒有釋放鎖，所以Thread1無法得不到鎖。
MultiThread.class.notify();
System.out.println("thread2is sleeping ten millisecond...");
try{
Thread.sleep(10);
}catch(InterruptedExceptione) {
//TODOAuto-generatedcatch block
e.printStackTrace();
}
System.out.println("thread2is going on...");
System.out.println("thread2is being over!");
}
}
}
}
48、同步和異步有何異同，在什么情況下分別使用他們？舉例說明。
如果數據將在線程間共享。例如正在寫的數據以后可能被另一個線程讀到，或者正在讀的數據可能已經被另一個線程寫過了，那么這些數據就是共享數據，必須進行同步存取。
當應用程序在對象上調用了一個需要花費很長時間來執行的方法，并且不希望讓程序等待方法的返回時，就應該使用異步編程，在很多情況下采用異步途徑往往更有效率。
49.下面兩個方法同步嗎？（自己發明）
class Test
{
synchronizedstatic ?voidsay Hello3()
{
}
synchronizedvoidgetX(){}
}
50、多線程有幾種實現方法?同步有幾種實現方法?
多線程有兩種實現方法，分別是繼承Thread類與實現Runnable接口
同步的實現方面有兩種，分別是synchronized,wait與notify
wait():使一個線程處于等待狀態，并且釋放所持有的對象的lock。
sleep():使一個正在運行的線程處于睡眠狀態，是一個靜態方法，調用此方法要捕捉InterruptedException(中斷異常)異常。
notify():喚醒一個處于等待狀態的線程，注意的是在調用此方法的時候，并不能確切的喚醒某一個等待狀態的線程，而是由JVM確定喚醒哪個線程，而且不是按優先級。
Allnotity():喚醒所有處入等待狀態的線程，注意并不是給所有喚醒線程一個對象的鎖，而是讓它們競爭。
51、啟動一個線程是用run()還是start()? .
啟動一個線程是調用start()方法，使線程就緒狀態，以后可以被調度為運行狀態，一個線程必須關聯一些具體的執行代碼，run()方法是該線程所關聯的執行代碼。
52、當一個線程進入一個對象的一個synchronized方法后，其它線程是否可進入此對象的其它方法?
分幾種情況：
1. 其他方法前是否加了synchronized關鍵字，如果沒加，則能。
2. 如果這個方法內部調用了wait，則可以進入其他synchronized方法。
3. 如果其他個方法都加了synchronized關鍵字，并且內部沒有調用wait，則不能。
4. 如果其他方法是static，它用的同步鎖是當前類的字節碼，與非靜態的方法不能同步，因為非靜態的方法用的是this。
53、線程的基本概念、線程的基本狀態以及狀態之間的關系
一個程序中可以有多條執行線索同時執行，一個線程就是程序中的一條執行線索，每個線程上都關聯有要執行的代碼，即可以有多段程序代碼同時運行，每個程序至少都有一個線程，即main方法執行的那個線程。如果只是一個cpu，它怎么能夠同時執行多段程序呢？這是從宏觀上來看的，cpu一會執行a線索，一會執行b線索，切換時間很快，給人的感覺是a,b在同時執行，好比大家在同一個辦公室上網，只有一條鏈接到外部網線，其實，這條網線一會為a傳數據，一會為b傳數據，由于切換時間很短暫，所以，大家感覺都在同時上網。
狀態：就緒，運行，synchronize阻塞，wait和sleep掛起，結束。wait必須在synchronized內部調用。
調用線程的start方法后線程進入就緒狀態，線程調度系統將就緒狀態的線程轉為運行狀態，遇到synchronized語句時，由運行狀態轉為阻塞，當synchronized獲得鎖后，由阻塞轉為運行，在這種情況可以調用wait方法轉為掛起狀態，當線程關聯的代碼執行完后，線程變為結束狀態。
54、簡述synchronized和java.util.concurrent.locks.Lock的異同？
主要相同點：Lock能完成synchronized所實現的所有功能
主要不同點：Lock有比synchronized更精確的線程語義和更好的性能。synchronized會自動釋放鎖，而Lock一定要求程序員手工釋放，并且必須在finally從句中釋放。Lock還有更強大的功能，例如，它的tryLock方法可以非阻塞方式去拿鎖。
舉例說明（對下面的題用lock進行了改寫）：
packagecom.huawei.interview;
importjava.util.concurrent.locks.Lock;
importjava.util.concurrent.locks.ReentrantLock;
publicclassThreadTest {
/**
*@paramargs
*/
private intj;
privateLock lock =newReentrantLock();
public static voidmain(String[] args) {
//TODOAuto-generated method stub
ThreadTest tt =newThreadTest();
for(inti=0;i<2;i++)
{
newThread(tt.newAdder()).start();
newThread(tt.newSubtractor()).start();
}
}
private classSubtractorimplementsRunnable
{
@Override
public voidrun() {
//TODOAuto-generated methodstub
while(true)
{
/*synchronized (ThreadTest.this) {
System.out.println("j--="+ j--);
//這里拋異常了，鎖能釋放嗎？
}*/
lock.lock();
try
{
System.out.println("j--="+ j--);
}finally
{
lock.unlock();
}
}
}
}
private classAdderimplementsRunnable
{
@Override
public voidrun() {
//TODOAuto-generated methodstub
while(true)
{
/*synchronized (ThreadTest.this) {
System.out.println("j++="+ j++);
}*/
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=newThreadTest1();
Inc inc=tt.new Inc();
Dec dec=tt.new Dec();
for(inti=0;i<2;i++){
Thread t=newThread(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();
}
}
}
}
----------隨手再寫的一個-------------
class A
{
JManger j =new JManager();
main()
{
new A().call();
}
void call
{
for(int i=0;i<2;i++)
{
new Thread(
newRunnable(){ public void run(){while(true){j.accumulate()}}}
).start();
new Thread(newRunnable(){ public void run(){while(true){j.sub()}}}).start();
}
}
}
class JManager
{
private j = 0;
public synchronized voidsubtract()
{
j--
}
public synchronized voidaccumulate()
{
j++;
}
}
56、子線程循環10次，接著主線程循環100，接著又回到子線程循環10次，接著再回到主線程又循環100，如此循環50次，請寫出程序。
最終的程序代碼如下：
publicclassThreadTest {
/**
*@paramargs
*/
public static voidmain(String[] args) {
//TODOAuto-generated method stub
newThreadTest().init();
}
public voidinit()
{
finalBusiness business =newBusiness();
newThread(
newRunnable()
{
public voidrun() {
for(inti=0;i<50;i++)
{
business.SubThread(i);
}
}
}
).start();
for(inti=0;i<50;i++)
{
business.MainThread(i);
}
}
private classBusiness
{
booleanbShouldSub =true;//這里相當于定義了控制該誰執行的一個信號燈
public synchronized voidMainThread(inti)
{
if(bShouldSub)
try{
this.wait();
}catch(InterruptedException e) {
//TODOAuto-generatedcatch block
e.printStackTrace();
}
for(intj=0;j<5;j++)
{
System.out.println(Thread.currentThread().getName()+ ":i=" + i +",j=" + j);
}
bShouldSub =true;
this.notify();
}
public synchronized voidSubThread(inti)
{
if(!bShouldSub)
try{
this.wait();
}catch(InterruptedExceptione) {
//TODOAuto-generatedcatch block
e.printStackTrace();
}
for(intj=0;j<10;j++)
{
System.out.println(Thread.currentThread().getName()+ ":i=" + i +",j=" + j);
}
bShouldSub =false;
this.notify();
}
}
}
備注：不可能一上來就寫出上面的完整代碼，最初寫出來的代碼如下，問題在于兩個線程的代碼要參照同一個變量，即這兩個線程的代碼要共享數據，所以，把這兩個線程的執行代碼搬到同一個類中去：
packagecom.huawei.interview.lym;
publicclassThreadTest {
private static booleanbShouldMain=false;
public staticvoidmain(String[]args) {
//TODOAuto-generated method stub
/*new Thread(){
public void run()
{
for(int i=0;i<50;i++)
{
for(int j=0;j<10;j++)
{
System.out.println("i="+ i + ",j=" + j);
}
}
}
}.start();*/
//final String str = newString("");
newThread(
newRunnable()
{
public voidrun()
{
for(inti=0;i<50;i++)
{
synchronized(ThreadTest.class) {
if(bShouldMain)
{
try{
ThreadTest.class.wait();}
catch(InterruptedException e) {
e.printStackTrace();
}
}
for(intj=0;j<10;j++)
{
System.out.println(
Thread.currentThread().getName()+
"i="+ i + ",j=" + j);
}
bShouldMain=true;
ThreadTest.class.notify();
}
}
}
}
).start();
for(inti=0;i<50;i++)
{
synchronized(ThreadTest.class){
if(!bShouldMain)
{
try{
ThreadTest.class.wait();}
catch(InterruptedException e) {
e.printStackTrace();
}
}
for(intj=0;j<5;j++)
{
System.out.println(
Thread.currentThread().getName()+
"i=" + i +",j=" + j);
}
bShouldMain=false;
ThreadTest.class.notify();
}
}
}
}
下面使用jdk5中的并發庫來實現的：
import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.Condition;
public class ThreadTest
{
private static Locklock = new ReentrantLock();
private staticCondition subThreadCondition = lock.newCondition();
private staticboolean bBhouldSubThread = false;
public static voidmain(String [] args)
{
ExecutorServicethreadPool = Executors.newFixedThreadPool(3);
threadPool.execute(newRunnable(){
publicvoid run()
{
for(inti=0;i<50;i++)
{
lock.lock();
try
{
if(!bBhouldSubThread)
subThreadCondition.await();
for(intj=0;j<10;j++)
{
System.out.println(Thread.currentThread().getName()+ ",j=" + j);
}
bBhouldSubThread= false;
subThreadCondition.signal();
}catch(Exceptione)
{
}
finally
{
lock.unlock();
}
}
}
});
threadPool.shutdown();
for(inti=0;i<50;i++)
{
lock.lock();
try
{
if(bBhouldSubThread)
subThreadCondition.await();
for(intj=0;j<10;j++)
{
System.out.println(Thread.currentThread().getName()+ ",j=" + j);
}
bBhouldSubThread= true;
subThreadCondition.signal();
}catch(Exceptione)
{
}
finally
{
lock.unlock();
}
}
}
}
57、介紹Collection框架的結構
答：隨意發揮題，天南海北誰便談，只要讓別覺得你知識淵博，理解透徹即可。
58、Collection框架中實現比較要實現什么接口
comparable/comparator
59、ArrayList和Vector的區別
答：
這兩個類都實現了List接口（List接口繼承了Collection接口），他們都是有序集合，即存儲在這兩個集合中的元素的位置都是有順序的，相當于一種動態的數組，我們以后可以按位置索引號取出某個元素，，并且其中的數據是允許重復的，這是HashSet之類的集合的最大不同處，HashSet之類的集合不可以按索引號去檢索其中的元素，也不允許有重復的元素（本來題目問的與hashset沒有任何關系，但為了說清楚ArrayList與Vector的功能，我們使用對比方式，更有利于說明問題）。
接著才說ArrayList與Vector的區別，這主要包括兩個方面：.
（1）同步性：
Vector是線程安全的，也就是說是它的方法之間是線程同步的，而ArrayList是線程序不安全的，它的方法之間是線程不同步的。如果只有一個線程會訪問到集合，那最好是使用ArrayList，因為它不考慮線程安全，效率會高些；如果有多個線程會訪問到集合，那最好是使用Vector，因為不需要我們自己再去考慮和編寫線程安全的代碼。
備注：對于Vector&ArrayList、Hashtable&HashMap，要記住線程安全的問題，記住Vector與Hashtable是舊的，是java一誕生就提供了的，它們是線程安全的，ArrayList與HashMap是java2時才提供的，它們是線程不安全的。所以，我們講課時先講老的。
（2）數據增長：
ArrayList與Vector都有一個初始的容量大小，當存儲進它們里面的元素的個數超過了容量時，就需要增加ArrayList與Vector的存儲空間，每次要增加存儲空間時，不是只增加一個存儲單元，而是增加多個存儲單元，每次增加的存儲單元的個數在內存空間利用與程序效率之間要取得一定的平衡。Vector默認增長為原來兩倍，而ArrayList的增長策略在文檔中沒有明確規定（從源代碼看到的是增長為原來的1.5倍）。ArrayList與Vector都可以設置初始的空間大小，Vector還可以設置增長的空間大小，而ArrayList沒有提供設置增長空間的方法。
總結：即Vector增長原來的一倍，ArrayList增加原來的0.5倍。
60、HashMap和Hashtable的區別
（條理上還需要整理，也是先說相同點，再說不同點）
HashMap是Hashtable的輕量級實現（非線程安全的實現），他們都完成了Map接口，主要區別在于HashMap允許空（null）鍵值（key）,由于非線程安全，在只有一個線程訪問的情況下，效率要高于Hashtable。
HashMap允許將null作為一個entry的key或者value，而Hashtable不允許。
HashMap把Hashtable的contains方法去掉了，改成containsvalue和containsKey。因為contains方法容易讓人引起誤解。
Hashtable繼承自Dictionary類，而HashMap是Java1.2引進的Map interface的一個實現。
最大的不同是，Hashtable的方法是Synchronize的，而HashMap不是，在多個線程訪問Hashtable時，不需要自己為它的方法實現同步，而HashMap就必須為之提供外同步。
Hashtable和HashMap采用的hash/rehash算法都大概一樣，所以性能不會有很大的差異。
就HashMap與HashTable主要從三方面來說。
一.歷史原因:Hashtable是基于陳舊的Dictionary類的，HashMap是Java 1.2引進的Map接口的一個實現
二.同步性:Hashtable是線程安全的，也就是說是同步的，而HashMap是線程序不安全的，不是同步的
三.值：只有HashMap可以讓你將空值作為一個表的條目的key或value
61、List和Map區別?
一個是存儲單列數據的集合，另一個是存儲鍵和值這樣的雙列數據的集合，List中存儲的數據是有順序，并且允許重復；Map中存儲的數據是沒有順序的，其鍵是不能重復的，它的值是可以有重復的。
62、List, Set, Map是否繼承自Collection接口?
List，Set是，Map不是
63、List、Map、Set三個接口，存取元素時，各有什么特點？
這樣的題屬于隨意發揮題：這樣的題比較考水平，兩個方面的水平：一是要真正明白這些內容，二是要有較強的總結和表述能力。如果你明白，但表述不清楚，在別人那里則等同于不明白。
首先，List與Set具有相似性，它們都是單列元素的集合，所以，它們有一個功共同的父接口，叫Collection。Set里面不允許有重復的元素，所謂重復，即不能有兩個相等（注意，不是僅僅是相同）的對象，即假設Set集合中有了一個A對象，現在我要向Set集合再存入一個B對象，但B對象與A對象equals相等，則B對象存儲不進去，所以，Set集合的add方法有一個boolean的返回值，當集合中沒有某個元素，此時add方法可成功加入該元素時，則返回true，當集合含有與某個元素equals相等的元素時，此時add方法無法加入該元素，返回結果為false。Set取元素時，沒法說取第幾個，只能以Iterator接口取得所有的元素，再逐一遍歷各個元素。
List表示有先后順序的集合，注意，不是那種按年齡、按大小、按價格之類的排序。當我們多次調用add(Obj
e)方法時，每次加入的對象就像火車站買票有排隊順序一樣，按先來后到的順序排序。有時候，也可以插隊，即調用add(int index,Obj
e)方法，就可以指定當前對象在集合中的存放位置。一個對象可以被反復存儲進List中，每調用一次add方法，這個對象就被插入進集合中一次，其實，并不是把這個對象本身存儲進了集合中，而是在集合中用一個索引變量指向這個對象，當這個對象被add多次時，即相當于集合中有多個索引指向了這個對象，如圖x所示。List除了可以以Iterator接口取得所有的元素，再逐一遍歷各個元素之外，還可以調用get(index
i)來明確說明取第幾個。
Map與List和Set不同，它是雙列的集合，其中有put方法，定義如下：put(obj
key,objvalue)，每次存儲時，要存儲一對key/value，不能存儲重復的key，這個重復的規則也是按equals比較相等。取則可以根據key獲得相應的value，即get(Object
key)返回值為key所對應的value。另外，也可以獲得所有的key的結合，還可以獲得所有的value的結合，還可以獲得key和value組合成的Map.Entry對象的集合。
List 以特定次序來持有元素，可有重復元素。Set無法擁有重復元素,內部排序。Map保存key-value值，value可多值。
HashSet按照hashcode值的某種運算方式進行存儲，而不是直接按hashCode值的大小進行存儲。例如，"abc"--->
78，"def" ---> 62，"xyz" --->
65在hashSet中的存儲順序不是62,65,78，這些問題感謝以前一個叫崔健的學員提出，最后通過查看源代碼給他解釋清楚，看本次培訓學員當中有多少能看懂源碼。LinkedHashSet按插入的順序存儲，那被存儲對象的hashcode方法還有什么作用呢？學員想想!hashset集合比較兩個對象是否相等，首先看hashcode方法是否相等，然后看equals方法是否相等。new兩個Student插入到HashSet中，看HashSet的size，實現hashcode和equals方法后再看size。
同一個對象可以在Vector中加入多次。往集合里面加元素，相當于集合里用一根繩子連接到了目標對象。往HashSet中卻加不了多次的。
64、說出ArrayList,Vector, LinkedList的存儲性能和特性
ArrayList和Vector都是使用數組方式存儲數據，此數組元素數大于實際存儲的數據以便增加和插入元素，它們都允許直接按序號索引元素，但是插入元素要涉及數組元素移動等內存操作，所以索引數據快而插入數據慢，Vector由于使用了synchronized方法（線程安全），通常性能上較ArrayList差，而LinkedList使用雙向鏈表實現存儲，按序號索引數據需要進行前向或后向遍歷，但是插入數據時只需要記錄本項的前后項即可，所以插入速度較快。
LinkedList也是線程不安全的，LinkedList提供了一些方法，使得LinkedList可以被當作堆棧和隊列來使用。
65、去掉一個Vector集合中重復的元素
Vector newVector = new Vector();
For (int i=0;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里的元素是不能重復的，元素重復與否是使用equals()方法進行判斷的。
equals()和==方法決定引用值是否指向同一對象equals()在類中被覆蓋，為的是當兩個分離的對象的內容和類型相配的話，返回真值。
68、你所知道的集合類都有哪些？主要方法
最常用的集合類是 List 和 Map。 List的具體實現包括 ArrayList和 Vector，它們是可變大小的列表，比較適合構建、存儲和操作任何類型對象的元素列表。 List適用于按數值索引訪問元素的情形。
Map 提供了一個更通用的元素存儲方法。 Map集合類用于存儲元素對（稱作"鍵"和"值"），其中每個鍵映射到一個值。
ArrayList/VectoràList
àCollection
HashSet/TreeSetàSet
PropetiesàHashTable
àMap
Treemap/HashMap
我記的不是方法名，而是思想，我知道它們都有增刪改查的方法，但這些方法的具體名稱，我記得不是很清楚，對于set，大概的方法是add,remove,
contains；對于map，大概的方法就是put,remove，contains等，因為，我只要在eclispe下按點操作符，很自然的這些方法就出來了。我記住的一些思想就是List類會有get(int
index)這樣的方法，因為它可以按順序取元素，而set類中沒有get(int
index)這樣的方法。List和set都可以迭代出所有元素，迭代時先要得到一個iterator對象，所以，set和list類都有一個iterator方法，用于返回那個iterator對象。map可以返回三個集合，一個是返回所有的key的集合，另外一個返回的是所有value的集合，再一個返回的key和value組合成的EntrySet對象的集合，map也有get方法，參數是key，返回值是key對應的value。
69、兩個對象值相同(x.equals(y) == true)，但卻可有不同的hash code，這句話對不對?
對。
如果對象要保存在HashSet或HashMap中，它們的equals相等，那么，它們的hashcode值就必須相等。
如果不是要保存在HashSet或HashMap，則與hashcode沒有什么關系了，這時候hashcode不等是可以的，例如arrayList存儲的對象就不用實現hashcode，當然，我們沒有理由不實現，通常都會去實現的。
70、TreeSet里面放對象，如果同時放入了父類和子類的實例對象，那比較時使用的是父類的compareTo方法，還是使用的子類的compareTo方法，還是拋異常！
（應該是沒有針對問題的確切的答案，當前的add方法放入的是哪個對象，就調用哪個對象的compareTo方法，至于這個compareTo方法怎么做，就看當前這個對象的類中是如何編寫這個方法的）
實驗代碼：
publicclassParentimplementsComparable {
private intage = 0;
publicParent(intage){
this.age = age;
}
public intcompareTo(Object o){
//TODOAuto-generated method stub
System.out.println("method ofparent");
Parent o1 = (Parent)o;
returnage>o1.age?1:age
}
}
publicclassChildextendsParent {
publicChild(){
super(3);
}
public intcompareTo(Object o){
//TODOAuto-generated methodstub
System.out.println("methodof child");
//???????? Child o1 = (Child)o;
return1;
}
}
publicclassTreeSetTest {
/**
*@paramargs
*/
public static voidmain(String[] args) {
//TODOAuto-generated method stub
TreeSet set =newTreeSet();
set.add(newParent(3));
set.add(newChild());
set.add(newParent(4));
System.out.println(set.size());
}
}
