java android面试题分析总结

本文参考多处，一并感谢！

http://www.blogjava.net/fanyingjie/archive/2007/06/27/126467.aspx

http://baike.baidu.com/view/1788559.htm

http://honda418.iteye.com/blog/315893

http://jeff-tang.blog.163.com/blog/static/141686909201022010522906/

http://www.cnblogs.com/mgod/archive/2007/08/05/844011.html

参考过的书籍

《深入理解Java虚拟机:JVM高级特性与最佳实践》

12.ArrayList,Vector,LinkedList的区别

	ArrayList	Vector	LinkedList
实现原理	数组	数组	双向链表
线程安全	否	是	否
优点	1.数组实现优于遍历 2.非线程安全，效率较高	1.数组实现优于遍历 2.线程安全	1.节点的增删无需对象的重建 2.空间利用毫无浪费
缺点	1.非线程安全 2.数组中未使用元素照成了空间的浪费 3.扩容可能引起对象的重建 4.增删有可能引起数组元素的移动	1.数组中未使用的元素造成空间的浪费 2.扩容可能引起对象的重建 3.线程安全，效率相对低 4.增删有可能引起数组元素的移动	1.遍历效率较低 2.非线程安全
扩容	0.5倍增量	1倍增量	按需增删
使用场景	1.无线程的要求。 2.遍历较多，增删较少	1.有线程安全的要求 2.遍历场景较多，增删场景较少	增删场景较多的时候

11.int与Integer的区别

扫描二维码关注公众号，回复： 269921 查看本文章

	int	Integer
类型	基本类型	复合类型
默认值	0	null
存储	栈（局部变量） 堆（成员变量，有待进一步确认）	堆上（只能通过new创建）
方法	基本类型无方法	有
速度	快（栈上 的操作相对快）	慢
泛型支持	否（java中的泛型不支持，C++中的模板支持）	支持
容器类支持	否（直接使用通常会进行装箱操作）	支持
存在意义	1.历史原因（顺延C/C++中存在） 2.方便快速（无需new）	基本类型int的包装类 提供了对泛型，容器类的支持

9.向一个List<Integer>的容器里放入String对象

需要了解的一些知识

• Java中的泛型是伪泛型。(可参见周志明的《深入理解Java虚拟机:JVM高级特性与最佳实践》）
  • 泛型是编译器的语法糖，并非产生了实际类型List<Integer>。
  • 对于List<Integer>和List<String>都是在编译之后，都是作为List<Object>类型来使用的。
  • 在Java虚拟机中，没有泛型的概念。
• 通过反射可以把一些强制性的检查推迟到运行期。
  • 如果直接向List<Integer>中插入String对象，肯定会得到编译器的检查，并提示错误。
  • 而反射机制可以把这种错误的检查延迟到运行期。(这是反射的一个缺点，会把编译期能够检查到的问题，推迟到了运行期发现）
• 由于List<Integer>对象在运行期，本身就是以List<Object>的形式存在，故其在运行期不会产生错误。
• 反射机制，通过编译期的检查骗过了我们。而我们又可以通过反射骗过了编译器的检查。

实现代码

[java] view plain copy

1. packagecom.jue.test;
3. importjava.lang.reflect.InvocationTargetException;
4. importjava.lang.reflect.Method;
5. importjava.util.ArrayList;
6. importjava.util.List;
8. publicclassTestMain{
10. List<Integer>mIntList=newArrayList<Integer>();
12. publicstaticvoidmain(String[]args)throwsSecurityException,
13. NoSuchFieldException,IllegalArgumentException,
14. IllegalAccessException,InvocationTargetException,
15. NoSuchMethodException{
17. TestMaintm=newTestMain();
19. MethodaddMethod=List.class.getMethod("add",
20. newClass[]{Object.class});
22. //使用反射，我们避免了编译期的强制检查
23. addMethod.invoke(tm.mIntList,newObject[]{newString("abc")});
24. addMethod.invoke(tm.mIntList,newObject[]{newString("123")});
25. addMethod.invoke(tm.mIntList,newObject[]{newString("cde")});
26. addMethod.invoke(tm.mIntList,newObject[]{newString("fgh")});
28. for(Objecto:tm.mIntList){
29. System.out.println(o);
30. }
31. }
32. }

输出结果：

abc
123
cde
fgh

10.List<Integer>与List<String>在编译后都是List<Object>形式存在

[java] view plain copy

1. packagecom.jue.test;
3. importjava.util.List;
5. publicclassTestMain{
7. publicvoidtestList(List<Integer>list){
9. }
11. publicvoidtestList(List<String>list){
13. }
14. }

结果：编译失败！

分析：

• 如上所述，Java的泛型是编译器的语法糖，在编译后，统一使用List<Object>代替。
• 对于重载，方面名相同，而签名不同，由于参数都将是List<Object>，故编译失败，因为不可能产生签名一样的两个方法。

1.short转换相关的

其一，

[java] view plain copy

1. packagecom.jue.test;
3. publicclassTestMain{
4. publicstaticvoidmain(Stringargs[]){
5. shorts1=1;
6. s1=s1+1;
7. }
9. }

编译结果

DescriptionResourcePathLocationType
Type mismatch: cannot convert from int to short TestMain.java/TestShort/src/com/jue/testline 6Java Problem

分析：

s1+1会自动转换成int类型，导致s1= s1+1;损失精度。

其二，

[java] view plain copy

1. packagecom.jue.test;
3. publicclassTestMain{
4. publicstaticvoidmain(Stringargs[]){
5. shorts2=2;
6. s2+=2;
7. }
8. }

编译结果：成功

分析：

反编译之后

[java] view plain copy

1. packagecom.jue.test;
3. publicclassTestMain
4. {
5. publicstaticvoidmain(String[]args)
6. {
7. shorts2=2;
8. s2=(short)(s2+2);
9. }
10. }

故猜测：这可能是java编译器的语法糖。

2.RuntimeException与普通异常，error的区别。

Checked Exception：在编译时就能够被Java编译器所检测到的。

UncheckedException：则是编译时，java编译器不能检查到。

	RuntimeException	普通Exception	Error
受控异常	否	是	否
产生原因	开发者的编程错误	由于外界环境所限， 本身潜在的一些问题	Java运行时的系统错误，资源耗尽，是一种严重的， 程序无法修复的问题
例子	NullPointerException ArrayOutOfIndexException ClassCastException ArithmeticException UnsupportedOperationException	ClassNotFoundException IOException FileNotFoundException	VirtualMachineError StackOverflowError OutOfMemoryError

3.finally的一个面试题

[java] view plain copy

1. packagecom.jue.test;
3. importjava.util.ArrayList;
4. importjava.util.List;
6. publicclassTestMain{
8. publicstaticvoidmain(String[]args){
9. test();
10. }
12. privatestaticvoidtest(){
13. Listlist=newArrayList();
14. try{
15. System.out.println("return!!");
16. return;
17. }catch(Exceptione){
18. System.out.println("catchException!!");
19. }finally{
20. System.out.println("finally!!");
21. }
22. }
24. }

结果：

return!!
finally!!

分析：即便在try中return；finally总会被执行的意义不变，仍然会执行。

4.final,finalize,finally的区别

final:关键字，表不变

修饰：

• 方法：方法不可Override
• 类：不可被继承
• 基本类型量：常量，值不可变
• 符合类型量：引用不可变，即引用的值不可变

[java] view plain copy

1. finalObjecto1=newObject();
2. o1=newObject();

finally:关键字，Java异常处理机制的一部分，在异常发生时，用来提供一个必要的清理的机会。

finalize：Object类的方法（参考自百度百科）

意义：Java技术允许使用finalize()方法在垃圾回收器将对象回收之前，做一些必要的清理操作。

调用前提：这个对象确定没有被引用到。

工作原理：

• 垃圾收集器准备好释放对象占用的空间。
• 首先调用其finalize方法。
• 下一次垃圾收集过程中，真正回收内存。

不确定性：

• finalize的执行时间是不缺定的。
• 一个对象引用另一个对象，并不能保证finalize的方法按照特定的执行顺序。

5.Override,Overload

	Override	Overload
签名+返回值	相同	方法名相同，签名不同
关系	父子类继承关系	通常是同一类层次中
识别	运行时多态 根据具体的对象， 查询对象的虚方法表，确定调用关系	编译时多态 由对象的外观类型（即声明类型）决定
修饰符限制	非private 非static 非final	无特别
异常关系	子类方法不能抛出被父类方法更多的异常	无特别
可见性关系	子类不能比父类访问权限更窄 （里氏替换原则决定）	无特别

6.Collection Collections

Collection:接口，集合类的接口，一个契约，提供了集合基本的大小，添加，清除，遍历方法等。

Collections:工具类，提供了很多静态方法，给集合提供一些查询，比较，排序，交换，线程安全化等方法。

7.Integer 缓存

[java] view plain copy

1. packagecom.jue.test;
3. publicclassTestMain{
5. publicstaticvoidmain(String[]args){
6. Integeri1=1;
7. Integeri11=1;
8. System.out.println(i1==i11);
10. Integeri2=200;
11. Integeri22=200;
12. System.out.println(i2==i22);
14. }
16. }

结果 ：

true

false

分析：反编译结果为

[java] view plain copy

1. packagecom.jue.test;
3. importjava.io.PrintStream;
5. publicclassTestMain
6. {
7. publicstaticvoidmain(String[]args)
8. {
9. Integeri1=Integer.valueOf(1);
10. Integeri11=Integer.valueOf(1);
11. System.out.println(i1==i11);
13. Integeri2=Integer.valueOf(200);
14. Integeri22=Integer.valueOf(200);
15. System.out.println(i2==i22);
16. }
17. }

可以看出，对于Integer i = 1;编译器做了额外的处理，即Integer.valueof();

Integer source code

[java] view plain copy

1. publicstaticIntegervalueOf(inti){
2. assertIntegerCache.high>=127;
3. if(i>=IntegerCache.low&&i<=IntegerCache.high)
4. returnIntegerCache.cache[i+(-IntegerCache.low)];
5. returnnewInteger(i);
6. }

可以看出Integer对于一定 范围内的数字从Cache中取得，对于额外的，调用new创建。

IntegerCache源码如下：

[java] view plain copy

1. privatestaticclassIntegerCache{
2. staticfinalintlow=-128;
3. staticfinalinthigh;
4. staticfinalIntegercache[];
5. static{
6. //highvaluemaybeconfiguredbyproperty
7. inth=127;
8. StringintegerCacheHighPropValue=sun.misc.VM
9. .getSavedProperty("java.lang.Integer.IntegerCache.high");
10. if(integerCacheHighPropValue!=null){
11. inti=parseInt(integerCacheHighPropValue);
12. i=Math.max(i,127);
13. //MaximumarraysizeisInteger.MAX_VALUE
14. h=Math.min(i,Integer.MAX_VALUE-(-low));
15. }
16. high=h;
17. cache=newInteger[(high-low)+1];
18. intj=low;
19. for(intk=0;k<cache.length;k++)
20. cache[k]=newInteger(j++);
21. }
23. privateIntegerCache(){
24. }
25. }

故可以知道Integer的大小，默认是从-128到127,对于这个范围内的数组做了缓存的处理。

8.sleep方法和wait方法的区别

	wait	sleep
所属类	Object	Thread
意义	让线程挂起	让线程休眠指定的时间
释放锁	是	否（这个跟锁本来就没有关系）
恢复	1.有参：wait指定时间 2.无参：等待其他线程notify	1.根据参数长度自动恢复。 2.异常打断
使用限制	wait，notify必须持有当前对象锁的情况下调用	无特别
抛出异常	否	是
静态方法	否	是