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必須持有當前對象鎖的狀況下調用	無特別
拋出異常	否	是
靜態方法	否	是