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的区别

	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>的形式存在，故其在运行期不会产生错误。
• 反射机制，经过编译期的检查骗过了咱们。而咱们又能够经过反射骗过了编译器的检查。

实现代码

package com.jue.test;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;

public class TestMain {

    List<Integer> mIntList = new ArrayList<Integer>();

    public static void main(String[] args) throws SecurityException,
            NoSuchFieldException, IllegalArgumentException,
            IllegalAccessException, InvocationTargetException,
            NoSuchMethodException {

        TestMain tm = new TestMain();

        Method addMethod = List.class.getMethod("add",
                new Class[] { Object.class });

        //使用反射，咱们避免了编译期的强制检查
        addMethod.invoke(tm.mIntList, new Object[] { new String("abc") });
        addMethod.invoke(tm.mIntList, new Object[] { new String("123") });
        addMethod.invoke(tm.mIntList, new Object[] { new String("cde") });
        addMethod.invoke(tm.mIntList, new Object[] { new String("fgh") });

        for (Object o : tm.mIntList) {
            System.out.println(o);
        }
    }
}

输出结果：

abc
123
cde
fgh

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

package com.jue.test;

import java.util.List;

public class TestMain {

    public void testList(List<Integer> list) {

    }

    public void testList(List<String> list) {

    }
}

结果：编译失败！

分析：

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

1.short转换相关的

其一，

package com.jue.test;

public class TestMain {
    public static void main(String args[]){
        short s1 = 1;
        s1 = s1 + 1;
    }

}

编译结果

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

分析：

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

 其二，

package com.jue.test;

public class TestMain {
    public static void main(String args[]){
        short s2 = 2;
        s2 += 2;
    }
}

编译结果：成功

分析：

反编译以后

package com.jue.test;

public class TestMain
{
  public static void main(String[] args)
  {
    short s2 = 2;
    s2 = (short)(s2 + 2);
  }
}

故猜想：这多是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的一个面试题

package com.jue.test;

import java.util.ArrayList;
import java.util.List;

public class TestMain {

    public static void main(String[] args) {
        test();
    }

    private static void test() {
        List list = new ArrayList();
        try {
            System.out.println("return!!");
            return;
        } catch (Exception e) {
            System.out.println("catch Exception !!");
        } finally {
            System.out.println("finally!!");
        }
    }

}

结果：

return!!
finally!!

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

4.final,finalize,finally的区别

final:关键字，表不变

修饰：

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

final Object o1 = new Object();
o1 = new Object();

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

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

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

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

工做原理：

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

不肯定性：

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

5.Override,Overload

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

6.Collection Collections

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

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

7.Integer 缓存

package com.jue.test;

public class TestMain {

    public static void main(String[] args) {
        Integer i1 = 1;
        Integer i11 = 1;
        System.out.println(i1 == i11);

        Integer i2 = 200;
        Integer i22 = 200;
        System.out.println(i2 == i22);

    }

}

结果 ：

true

false

分析：反编译结果为

package com.jue.test;

import java.io.PrintStream;

public class TestMain
{
  public static void main(String[] args)
  {
    Integer i1 = Integer.valueOf(1);
    Integer i11 = Integer.valueOf(1);
    System.out.println(i1 == i11);

    Integer i2 = Integer.valueOf(200);
    Integer i22 = Integer.valueOf(200);
    System.out.println(i2 == i22);
  }
}

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

Integer source code

public static Integer valueOf(int i) {
    assert IntegerCache.high >= 127;
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
}

能够看出Integer对于必定 范围内的数字从Cache中取得，对于额外的，调用new建立。

IntegerCache源码以下：

private static class IntegerCache {
    static final int low = -128;
    static final int high;
    static final Integer cache[];
    static {
        // high value may be configured by property
        int h = 127;
        String integerCacheHighPropValue = sun.misc.VM
                .getSavedProperty("java.lang.Integer.IntegerCache.high");
        if (integerCacheHighPropValue != null) {
            int i = parseInt(integerCacheHighPropValue);
            i = Math.max(i, 127);
            // Maximum array size is Integer.MAX_VALUE
            h = Math.min(i, Integer.MAX_VALUE - (-low));
        }
        high = h;
        cache = new Integer[(high - low) + 1];
        int j = low;
        for (int k = 0; k < cache.length; k++)
            cache[k] = new Integer(j++);
    }

    private IntegerCache() {
    }
}

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

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

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