31、String s = "Hello";s = s + " world!";这两行代码执行后,原始的String对象中的内容到底变了没有?


没有。因为String被设计成不可变(immutable)类,所以它的所有对象都是不可变对象。在这段代码中,s原先指向一个String对象,内容是 "Hello",然后我们对s进行了+操作,那么s所指向的那个对象是否发生了改变呢?

答案是没有。这时,s不指向原来那个对象了,而指向了另一个 String对象,内容为"Hello world!",原来那个对象还存在于内存之中,只是s这个引用变量不再指向它了。


通过上面的说明,我们很容易导出另一个结论,如果经常对字符串进行各种各样的修改,或者说,不可预见的修改,那么使用String来代表字符串的话会引起很大的内存开销。因为 String对象建立之后不能再改变,所以对于每一个不同的字符串,都需要一个String对象来表示。

这时,应该考虑使用StringBuffer类,它允许修改,而不是每个不同的字符串都要生成一个新的对象。并且,这两种类的对象转换十分容易。

同时,我们还可以知道,如果要使用内容相同的字符串,不必每次都new一个String。例如我们要在构造器中对一个名叫s的String引用变量进行初始化,把它设置为初始值,应当这样做:

public class Demo {

private String s;

...

public Demo {

s = "Initial Value";

}

...

}

而非

s = new String("Initial Value");

后者每次都会调用构造器,生成新对象,性能低下且内存开销大,并且没有意义,因为String对象不可改变,所以对于内容相同的字符串,只要一个String对象来表示就可以了。也就说,多次调用上面的构造器创建多个对象,他们的String类型属性s都指向同一个对象。

上面的结论还基于这样一个事实:对于字符串常量,如果内容相同,Java认为它们代表同一个String对象。而用关键字new调用构造器,总是会创建一个新的对象,无论内容是否相同。

至于为什么要把String类设计成不可变类,是它的用途决定的。其实不只String,很多Java标准类库中的类都是不可变的。在开发一个系统的时候,我们有时候也需要设计不可变类,来传递一组相关的值,这也是面向对象思想的体现。不可变类有一些优点,比如因为它的对象是只读的,所以多线程并发访问也不会有任何问题。当然也有一些缺点,比如每个不同的状态都要一个对象来代表,可能会造成性能上的问题。所以Java标准类库还提供了一个可变版本,即 StringBuffer。




32、是否可以继承String类?


String类是final类故不可以继承。




33、String s = new String("xyz");创建了几个String Object?二者之间有什么区别?


两个或一个,”xyz”对应一个对象,这个对象放在字符串常量缓冲区,常量”xyz”不管出现多少遍,都是缓冲区中的那一个。New String每写一遍,就创建一个新的对象,它一句那个常量”xyz”对象的内容来创建出一个新String对象。如果以前就用过’xyz’,这句代表就不会创建”xyz”自己了,直接从缓冲区拿。


34、String和StringBuffer的区别


JAVA平台提供了两个类:String和StringBuffer,它们可以储存和操作字符串,即包含多个字符的字符数据。这个String类提供了数值不可改变的字符串。而这个StringBuffer类提供的字符串进行修改。当你知道字符数据要改变的时候你就可以使用StringBuffer。典型地,你可以使用StringBuffers来动态构造字符数据。另外,String实现了equals方法,new String(“abc”).equals(newString(“abc”)的结果为true,而StringBuffer没有实现equals方法,所以,new StringBuffer(“abc”).equals(newStringBuffer(“abc”)的结果为false。




接着要举一个具体的例子来说明,我们要把1到100的所有数字拼起来,组成一个串。


StringBuffer sbf = new StringBuffer();


for(int i=0;i<100;i++)


{


sbf.append(i);


}


上面的代码效率很高,因为只创建了一个StringBuffer对象,而下面的代码效率很低,因为创建了101个对象。


String str = new String();


for(int i=0;i<100;i++)


{


str = str + i;


}


在讲两者区别时,应把循环的次数搞成10000,然后用endTime-beginTime来比较两者执行的时间差异,最后还要讲讲StringBuilder与StringBuffer的区别。




String覆盖了equals方法和hashCode方法,而StringBuffer没有覆盖equals方法和hashCode方法,所以,将StringBuffer对象存储进Java集合类中时会出现问题。


35、如何把一段逗号分割的字符串转换成一个数组?


如果不查jdk api,我很难写出来!我可以说说我的思路:


1 用正则表达式,代码大概为:String [] result = orgStr.split(“,”);


2 用 StingTokenizer ,代码为:StringTokenizer tokener = StringTokenizer(orgStr,”,”);


String [] result =new String[tokener .countTokens()];


Int i=0;


while(tokener.hasNext(){result[i++]=toker.nextToken();}




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中间执行,请看下面程序代码的运行结果:


public classTest {




/**


 * @paramargs add by zxx ,Dec 9, 2008


 */


public static voidmain(String[] args) {


// TODO Auto-generated method stub


System.out.println(newTest().test());;


}




static int test()


{


int x = 1;


try


{


returnx;


}


finally


{


++x;


}


}




}




---------执行结果 ---------


1




运行结果是1,为什么呢?主函数调用子函数并得到结果的过程,好比主函数准备一个空罐子,当子函数要返回结果时,先把结果放在罐子里,然后再将程序逻辑返回到主函数。所谓返回,就是子函数说,我不运行了,你主函数继续运行吧,这没什么结果可言,结果是在说这话之前放进罐子里的。


39、下面的程序代码输出的结果是多少?


public class smallT


{


public staticvoid main(String args[])


{


smallT t = new smallT();


int b = t.get();


System.out.println(b);


}




public int get()


{


try


{


return1 ;


}


finally


{


return2 ;


}


}


}




返回的结果是2。


我可以通过下面一个例子程序来帮助我解释这个答案,从下面例子的运行结果中可以发现,try中的return语句调用的函数先于finally中调用的函数执行,也就是说return语句先执行,finally语句后执行,所以,返回的结果是2。Return并不是让函数马上返回,而是return语句执行后,将把返回结果放置进函数栈中,此时函数并不是马上返回,它要执行finally语句后才真正开始返回。


在讲解答案时可以用下面的程序来帮助分析:


public classTest {




/**


 * @paramargs add by zxx ,Dec 9, 2008


 */


public static voidmain(String[] args) {


// TODO Auto-generated method stub


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类型,例如,一段代码……




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的讲解一定要配合例子代码来说明,才显得自己真明白。


package com.huawei.interview;




publicclass MultiThread {




/**


 * @paramargs


 */


public static voidmain(String[] args) {


// TODO Auto-generated method stub


new Thread(newThread1()).start();


try {


Thread.sleep(10);


} catch (InterruptedException e) {


// TODO Auto-generated catchblock


e.printStackTrace();


}


new Thread(newThread2()).start();


}






private static classThread1implements Runnable


{




@Override


public void run() {


// TODO Auto-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) {


// TODO Auto-generatedcatch block


e.printStackTrace();


}




System.out.println("thread1is going on...");


System.out.println("thread1is being over!");


}


}




}




private static classThread2implements Runnable


{




@Override


public void run() {


// TODO Auto-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) {


// TODO Auto-generatedcatch block


e.printStackTrace();


}




System.out.println("thread2is going on...");


System.out.println("thread2is being over!");




}


}




}




}






48、同步和异步有何异同,在什么情况下分别使用他们?举例说明。


如果数据将在线程间共享。例如正在写的数据以后可能被另一个线程读到,或者正在读的数据可能已经被另一个线程写过了,那么这些数据就是共享数据,必须进行同步存取。


当应用程序在对象上调用了一个需要花费很长时间来执行的方法,并且不希望让程序等待方法的返回时,就应该使用异步编程,在很多情况下采用异步途径往往更有效率。




49. 下面两个方法同步吗?(自己发明)


class Test


{


synchronizedstatic voidsayHello3()


 {




 }




 synchronizedvoid getX(){}


}


50、多线程有几种实现方法?同步有几种实现方法?


多线程有两种实现方法,分别是继承Thread类与实现Runnable接口


同步的实现方面有两种,分别是synchronized,wait与notify


wait():使一个线程处于等待状态,并且释放所持有的对象的lock。


sleep():使一个正在运行的线程处于睡眠状态,是一个静态方法,调用此方法要捕捉InterruptedException异常。


notify():唤醒一个处于等待状态的线程,注意的是在调用此方法的时候,并不能确切的唤醒某一个等待状态的线程,而是由JVM确定唤醒哪个线程,而且不是按优先级。


Allnotity():唤醒所有处入等待状态的线程,注意并不是给所有唤醒线程一个对象的锁,而是让它们竞争。