JAVA面试精选【Java基础第二部分】
本文内容纲要：
上一篇，我们给出了大概35个题目，都是基础知识，有童鞋反映题目过时了，其实不然，这些是基础中的基础，但是也是必不可少的，面试题目中还是有一些基础题目的，我们本着先易后难的原则，逐渐给出不同级别的题目，猛料还在后头呢，继续关注哦。
这一章我们继续接下来的35个题目，这些题目也是一些基础知识，看看你有没有掌握咯。
36**、数组有没有length()这个方法?String有没有****length()**这个方法？
数组没有length()这个方法，有length的属性。String有有length()这个方法。
**37****、下面这条语句一共创建了多少个对象：**Strings="a"+"b"+"c"+"d";
答：对于如下代码：
Strings1="a";
Strings2=s1+"b";
Strings3="a"+"b";
System.out.println(s2=="ab");
System.out.println(s3=="ab");
第一条语句打印的结果为false，第二条语句打印的结果为true，这说明javac编译可以对字符串常量直接相加的表达式进行优化，不必要等到运行期去进行加法运算处理，而是在编译时去掉其中的加号，直接将其编译成一个这些常量相连的结果。
题目中的第一行代码被编译器在编译时优化后，相当于直接定义了一个”abcd”的字符串，所以，上面的代码应该只创建了一个String对象。写如下两行代码，
Strings="a"+"b"+"c"+"d";
System.out.println(s=="abcd");
最终打印的结果应该为true。
**38****、try{}里有一个return语句，那么紧跟在这个try后的finally{}里的code会不会被执行，什么时候被执行，在return前还是后?**
也许你的答案是在return之前，但往更细地说，我的答案是在return中间执行，请看下面程序代码的运行结果：
publicclassTest{
/**
*@paramargsaddbyzxx,Dec9,2008
*/
publicstaticvoidmain(String[]args){
//TODOAuto-generatedmethodstub
System.out.println(newTest().test());;
}
staticinttest()
{
intx=1;
try
{
Returnx;
}
finally
{
++x;
}
}
}
---------执行结果---------
1
运行结果是1，为什么呢？主函数调用子函数并得到结果的过程，好比主函数准备一个空罐子，当子函数要返回结果时，先把结果放在罐子里，然后再将程序逻辑返回到主函数。所谓返回，就是子函数说，我不运行了，你主函数继续运行吧，这没什么结果可言，结果是在说这话之前放进罐子里的。
**39****、下面的程序代码输出的结果是多少？**
publicclasssmallT
{
publicstaticvoidmain(Stringargs[])
{
smallTt=newsmallT();
intb=t.get();
System.out.println(b);
}
publicintget()
{
try
{
Return1;
}
finally
{
Return2;
}
}
}
返回的结果是2。
我可以通过下面一个例子程序来帮助我解释这个答案，从下面例子的运行结果中可以发现，try中的return语句调用的函数先于finally中调用的函数执行，也就是说return语句先执行，finally语句后执行，所以，返回的结果是2。Return并不是让函数马上返回，而是return语句执行后，将把返回结果放置进函数栈中，此时函数并不是马上返回，它要执行finally语句后才真正开始返回。
在讲解答案时可以用下面的程序来帮助分析：
publicclassTest{
/**
*@paramargsaddbyzxx,Dec9,2008
*/
publicstaticvoidmain(String[]args){
//TODOAuto-generatedmethodstub
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个runtimeexception。**
这道题主要考你的代码量到底多大，如果你长期写代码的，应该经常都看到过一些系统方面的异常，你不一定真要回答出5个具体的系统异常，但你要能够说出什么是系统异常，以及几个系统异常就可以了，当然，这些异常完全用其英文名称来写是最好的，如果实在写不出，那就用中文吧，有总比没有强！
所谓系统异常，就是…..，它们都是RuntimeException的子类，在jdkdoc中查RuntimeException类，就可以看到其所有的子类列表，也就是看到了所有的系统异常。我比较有印象的系统异常有：NullPointerException、ArrayIndexOutOfBoundsException、ClassCastException。
**45****、JAVA语言如何进行异常处理，关键字：throws,throw,try,catch,finally分别代表什么意义？在try块中可以抛出异常吗？**
**46****、java中有几种方法可以实现一个线程？用什么关键字修饰同步方法****?stop()和suspend()**方法为何不推荐使用？
java5以前，有如下两种：
第一种：
newThread(){}.start();这表示调用Thread子类对象的run方法，newThread(){}表示一个Thread的匿名子类的实例对象，子类加上run方法后的代码如下：
newThread(){
publicvoidrun(){
}
}.start();
第二种：
newThread(newRunnable(){}).start();这表示调用Thread对象接受的Runnable对象的run方法，newRunnable(){}表示一个Runnable的匿名子类的实例对象,runnable的子类加上run方法后的代码如下：
newThread(newRunnable(){
publicvoidrun(){
}
}
).start();
从java5开始，还有如下一些线程池创建多线程的方式：
ExecutorServicepool=Executors.newFixedThreadPool(3)
for(inti=0;i<10;i++)
{
pool.execute(newRunable(){publicvoidrun(){}});
}
Executors.newCachedThreadPool().execute(newRunable(){publicvoidrun(){}});
Executors.newSingleThreadExecutor().execute(newRunable(){publicvoidrun(){}});
有两种实现方法，分别使用newThread()和newThread(runnable)形式，第一种直接调用thread的run方法，所以，我们往往使用Thread子类，即newSubThread()。第二种调用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
*/
publicstaticvoidmain(String[]args){
//TODOAuto-generatedmethodstub
newThread(newThread1()).start();
try{
Thread.sleep(10);
}catch(InterruptedExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}
newThread(newThread2()).start();
}
privatestaticclassThread1implementsRunnable
{
@Override
publicvoidrun(){
//TODOAuto-generatedmethodstub
//由于这里的Thread1和下面的Thread2内部run方法要用同一对象作为监视器，我们这里不能用this，因为在Thread2里面的this和这个Thread1的this不是同一个对象。我们用MultiThread.class这个字节码对象，当前虚拟机里引用这个变量时，指向的都是同一个对象。
synchronized(MultiThread.class){
System.out.println("enterthread1...");
System.out.println("thread1iswaiting");
try{
//释放锁有两种方式，第一种方式是程序自然离开监视器的范围，也就是离开了synchronized关键字管辖的代码范围，另一种方式就是在synchronized关键字管辖的代码内部调用监视器对象的wait方法。这里，使用wait方法释放锁。
MultiThread.class.wait();
}catch(InterruptedExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}
System.out.println("thread1isgoingon...");
System.out.println("thread1isbeingover!");
}
}
}
privatestaticclassThread2implementsRunnable
{
@Override
publicvoidrun(){
//TODOAuto-generatedmethodstub
synchronized(MultiThread.class){
System.out.println("enterthread2...");
System.out.println("thread2notifyotherthreadcanreleasewaitstatus..");
//由于notify方法并不释放锁，即使thread2调用下面的sleep方法休息了10毫秒，但thread1仍然不会执行，因为thread2没有释放锁，所以Thread1无法得不到锁。
MultiThread.class.notify();
System.out.println("thread2issleepingtenmillisecond...");
try{
Thread.sleep(10);
}catch(InterruptedExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}
System.out.println("thread2isgoingon...");
System.out.println("thread2isbeingover!");
}
}
}
}
**48****、同步和异步有何异同，在什么情况下分别使用他们？举例说明。**
如果数据将在线程间共享。例如正在写的数据以后可能被另一个线程读到，或者正在读的数据可能已经被另一个线程写过了，那么这些数据就是共享数据，必须进行同步存取。
当应用程序在对象上调用了一个需要花费很长时间来执行的方法，并且不希望让程序等待方法的返回时，就应该使用异步编程，在很多情况下采用异步途径往往更有效率。
**49.**下面两个方法同步吗？（自己发明）
classTest
{
synchronizedstaticvoidsayHello3()
{
}
synchronizedvoidgetX(){}
}
**50****、多线程有几种实现方法****?同步有几种实现方法?**
多线程有两种实现方法，分别是继承Thread类与实现Runnable接口
同步的实现方面有两种，分别是synchronized,wait与notify
wait():使一个线程处于等待状态，并且释放所持有的对象的lock。
sleep():使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要捕捉InterruptedException(中断异常)异常。
notify():唤醒一个处于等待状态的线程，注意的是在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由JVM确定唤醒哪个线程，而且不是按优先级。
Allnotity():唤醒所有处入等待状态的线程，注意并不是给所有唤醒线程一个对象的锁，而是让它们竞争。
**51****、启动一个线程是用****run()还是start()?.**
启动一个线程是调用start()方法，使线程就绪状态，以后可以被调度为运行状态，一个线程必须关联一些具体的执行代码，run()方法是该线程所关联的执行代码。
**52****、当一个线程进入一个对象的一个synchronized方法后，其它线程是否可进入此对象的其它方法****?**
分几种情况：
-
其他方法前是否加了synchronized关键字，如果没加，则能。
-
如果这个方法内部调用了wait，则可以进入其他synchronized方法。
-
如果其他个方法都加了synchronized关键字，并且内部没有调用wait，则不能。
-
如果其他方法是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
*/
privateintj;
privateLocklock=newReentrantLock();
publicstaticvoidmain(String[]args){
//TODOAuto-generatedmethodstub
ThreadTesttt=newThreadTest();
for(inti=0;i<2;i++)
{
newThread(tt.newAdder()).start();
newThread(tt.newSubtractor()).start();
}
}
privateclassSubtractorimplementsRunnable
{
@Override
publicvoidrun(){
//TODOAuto-generatedmethodstub
while(true)
{
/*synchronized(ThreadTest.this){
System.out.println("j--="+j--);
//这里抛异常了，锁能释放吗？
}*/
lock.lock();
try
{
System.out.println("j--="+j--);
}finally
{
lock.unlock();
}
}
}
}
privateclassAdderimplementsRunnable
{
@Override
publicvoidrun(){
//TODOAuto-generatedmethodstub
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增减的时候没有考虑顺序问题。
publicclassThreadTest1
{
privateintj;
publicstaticvoidmain(Stringargs[]){
ThreadTest1tt=newThreadTest1();
Incinc=tt.newInc();
Decdec=tt.newDec();
for(inti=0;i<2;i++){
Threadt=newThread(inc);
t.start();
t=newThread(dec);
t.start();
}
}
privatesynchronizedvoidinc(){
j++;
System.out.println(Thread.currentThread().getName()+"-inc:"+j);
}
privatesynchronizedvoiddec(){
j--;
System.out.println(Thread.currentThread().getName()+"-dec:"+j);
}
classIncimplementsRunnable{
publicvoidrun(){
for(inti=0;i<100;i++){
inc();
}
}
}
classDecimplementsRunnable{
publicvoidrun(){
for(inti=0;i<100;i++){
dec();
}
}
}
}
----------随手再写的一个-------------
classA
{
JMangerj=newJManager();
main()
{
newA().call();
}
voidcall
{
for(inti=0;i<2;i++)
{
newThread(
newRunnable(){publicvoidrun(){while(true){j.accumulate()}}}
).start();
newThread(newRunnable(){publicvoidrun(){while(true){j.sub()}}}).start();
}
}
}
classJManager
{
privatej=0;
publicsynchronizedvoidsubtract()
{
j--
}
publicsynchronizedvoidaccumulate()
{
j++;
}
}
**56****、子线程循环10次，接着主线程循环100，接着又回到子线程循环10次，接着再回到主线程又循环100，如此循环50次，请写出程序。**
最终的程序代码如下：
publicclassThreadTest{
/**
*@paramargs
*/
publicstaticvoidmain(String[]args){
//TODOAuto-generatedmethodstub
newThreadTest().init();
}
publicvoidinit()
{
finalBusinessbusiness=newBusiness();
newThread(
newRunnable()
{
publicvoidrun(){
for(inti=0;i<50;i++)
{
business.SubThread(i);
}
}
}
).start();
for(inti=0;i<50;i++)
{
business.MainThread(i);
}
}
privateclassBusiness
{
booleanbShouldSub=true;//这里相当于定义了控制该谁执行的一个信号灯
publicsynchronizedvoidMainThread(inti)
{
if(bShouldSub)
try{
this.wait();
}catch(InterruptedExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}
for(intj=0;j<5;j++)
{
System.out.println(Thread.currentThread().getName()+":i="+i+",j="+j);
}
bShouldSub=true;
this.notify();
}
publicsynchronizedvoidSubThread(inti)
{
if(!bShouldSub)
try{
this.wait();
}catch(InterruptedExceptione){
//TODOAuto-generatedcatchblock
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{
privatestaticbooleanbShouldMain=false;
publicstaticvoidmain(String[]args){
//TODOAuto-generatedmethodstub
/*newThread(){
publicvoidrun()
{
for(inti=0;i<50;i++)
{
for(intj=0;j<10;j++)
{
System.out.println("i="+i+",j="+j);
}
}
}
}.start();*/
//finalStringstr=newString("");
newThread(
newRunnable()
{
publicvoidrun()
{
for(inti=0;i<50;i++)
{
synchronized(ThreadTest.class){
if(bShouldMain)
{
try{
ThreadTest.class.wait();}
catch(InterruptedExceptione){
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(InterruptedExceptione){
e.printStackTrace();
}
}
for(intj=0;j<5;j++)
{
System.out.println(
Thread.currentThread().getName()+
"i="+i+",j="+j);
}
bShouldMain=false;
ThreadTest.class.notify();
}
}
}
}
下面使用jdk5中的并发库来实现的：
importjava.util.concurrent.Executors;
importjava.util.concurrent.ExecutorService;
importjava.util.concurrent.locks.Lock;
importjava.util.concurrent.locks.ReentrantLock;
importjava.util.concurrent.locks.Condition;
publicclassThreadTest
{
privatestaticLocklock=newReentrantLock();
privatestaticConditionsubThreadCondition=lock.newCondition();
privatestaticbooleanbBhouldSubThread=false;
publicstaticvoidmain(String[]args)
{
ExecutorServicethreadPool=Executors.newFixedThreadPool(3);
threadPool.execute(newRunnable(){
publicvoidrun()
{
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引进的Mapinterface的一个实现。
最大的不同是，Hashtable的方法是Synchronize的，而HashMap不是，在多个线程访问Hashtable时，不需要自己为它的方法实现同步，而HashMap就必须为之提供外同步。
Hashtable和HashMap采用的hash/rehash算法都大概一样，所以性能不会有很大的差异。
就HashMap与HashTable主要从三方面来说。
一.历史原因:Hashtable是基于陈旧的Dictionary类的，HashMap是Java1.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(Obje)方法时，每次加入的对象就像火车站买票有排队顺序一样，按先来后到的顺序排序。有时候，也可以插队，即调用add(intindex,Obje)方法，就可以指定当前对象在集合中的存放位置。一个对象可以被反复存储进List中，每调用一次add方法，这个对象就被插入进集合中一次，其实，并不是把这个对象本身存储进了集合中，而是在集合中用一个索引变量指向这个对象，当这个对象被add多次时，即相当于集合中有多个索引指向了这个对象，如图x所示。List除了可以以Iterator接口取得所有的元素，再逐一遍历各个元素之外，还可以调用get(indexi)来明确说明取第几个。
Map与List和Set不同，它是双列的集合，其中有put方法，定义如下：put(objkey,objvalue)，每次存储时，要存储一对key/value，不能存储重复的key，这个重复的规则也是按equals比较相等。取则可以根据key获得相应的value，即get(Objectkey)返回值为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集合中重复的元素**
VectornewVector=newVector();
For(inti=0;i<vector.size();i++)
{
Objectobj=vector.get(i);
if(!newVector.contains(obj);
newVector.add(obj);
}
还有一种简单的方式，HashSetset=newHashSet(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(intindex)这样的方法，因为它可以按顺序取元素，而set类中没有get(intindex)这样的方法。List和set都可以迭代出所有元素，迭代时先要得到一个iterator对象，所以，set和list类都有一个iterator方法，用于返回那个iterator对象。map可以返回三个集合，一个是返回所有的key的集合，另外一个返回的是所有value的集合，再一个返回的key和value组合成的EntrySet对象的集合，map也有get方法，参数是key，返回值是key对应的value。
**69****、两个对象值相同****(x.equals(y)==true)，但却可有不同的hashcode****，这句话对不对****?**
对。
如果对象要保存在HashSet或HashMap中，它们的equals相等，那么，它们的hashcode值就必须相等。
如果不是要保存在HashSet或HashMap，则与hashcode没有什么关系了，这时候hashcode不等是可以的，例如arrayList存储的对象就不用实现hashcode，当然，我们没有理由不实现，通常都会去实现的。
**70****、TreeSet里面放对象，如果同时放入了父类和子类的实例对象，那比较时使用的是父类的compareTo方法，还是使用的子类的compareTo方法，还是抛异常！**
（应该是没有针对问题的确切的答案，当前的add方法放入的是哪个对象，就调用哪个对象的compareTo方法，至于这个compareTo方法怎么做，就看当前这个对象的类中是如何编写这个方法的）
实验代码：
publicclassParentimplementsComparable{
privateintage=0;
publicParent(intage){
this.age=age;
}
publicintcompareTo(Objecto){
//TODOAuto-generatedmethodstub
System.out.println("methodofparent");
Parento1=(Parent)o;
returnage>o1.age?1:age<o1.age?-1:0;
}
}
publicclassChildextendsParent{
publicChild(){
super(3);
}
publicintcompareTo(Objecto){
//TODOAuto-generatedmethodstub
System.out.println("methodofchild");
//Childo1=(Child)o;
return1;
}
}
publicclassTreeSetTest{
/**
*@paramargs
*/
publicstaticvoidmain(String[]args){
//TODOAuto-generatedmethodstub
TreeSetset=newTreeSet();
set.add(newParent(3));
set.add(newChild());
set.add(newParent(4));
System.out.println(set.size());
}
}
本文内容总结：
原文链接：https://www.cnblogs.com/hnlshzx/p/3492197.html