public static void main(String[] args) {
    int a = 5;
    System.out.println(a < 5 ? 10.9 : 9);
}

A．編譯錯誤　　B．10.9　　C．9　　D．以上答案都不對

4.以下代碼的輸出結(jié)果是____

public static void main(String[] args) {
    int a = 1;
    int b = 2;
    System.out.println(a & b);
    System.out.println(a | b);
}

5.以下代碼的輸出結(jié)果是____

public static void main(String[] args) {
    int a = 1;
    int b = 2;
    System.out.println(b << a);
    System.out.println(b >> a);
}

6.以下代碼的輸出結(jié)果是____

public static void main(String[] args) {
    int a = 1;
    int b = 2;
    System.out.println(b << a << a);
    System.out.println(b >> a >> a);
    System.out.println(b >> 32);
    System.out.println(b << 33);
}

1.編程，輸出數(shù)組里的全部數(shù)值。(假設(shè)int[] array = new int[]{1, 2, 3, 4})

2.編程，輸出99乘法口訣表

3.編程，輸出字符串中出現(xiàn)次數(shù)最多的字符，如果有多個則都輸出。(假設(shè)字符串String str = "abcdefaaaccc"。);

4.編程，有一個整數(shù)n，寫一個函數(shù)f(n)，返回0~n之間出現(xiàn)“1”的個數(shù)。比如f(1)=1,f(13)=6(1、10、11、12、13)

5.編程，獲取斐波那契數(shù)列的第n項值。
(斐波那契數(shù)列指的是這樣一個數(shù)列：1、1、2、3、5、8、13、21……這個數(shù)列從第3項開始，每一項都等于前兩項之和。F[n]=F[n-1]+F[n-2] (n>2,F[1]=1,F[2]=1,F[3]=2,F[4]=3))

　　　　　　　　　　　　　　　　　　類和對象　　　　　　　　　　

1.下面哪個不是Object類所定義的public method？ 答案：
這題看起來很簡單，但是仔細一想沒那么容易。
Object類定義的公用方法有以下7種：

toString();    //
equals(Object object);
getClass();
hashCode();
wait();
notify();
notifyAll();

wait();方法有三種重載方法
wait(long timeout);
wait(long timeout, int nanos);
再加兩個一共是9種public方法。
所以這題的正確答案是A、B、D, 四個選項里只有wait()是公用方法
clone()和finalize()是protected方法。sleep()不是Object類的方法。
《Java程序員面試寶典》給的答案是D，顯然錯了。
　　　　　　　　　　　　　　　　　　JVM　　　　　　　　　　

1.答案：
A．選項錯誤，ClassLoader具備層次關(guān)系。
B．選項錯誤，ClassLoader不止一種。
D．選項錯誤，ClassLoader具備層次關(guān)系。
正確答案：C

2.答案：
JVM的設(shè)計者為了解決編碼問題實現(xiàn)Java的跨平臺，沒有使用任何特定的編碼格式，而是使用Unicode（萬國碼）字符集來表示字符。
所以正確答案是B。

　　　　　　　　　　　　　　　　　　i++　　　　　　　　　　

1.答案：
0
2
6

2.答案：
j=j++;//這一步j(luò)等于0,循環(huán)100次依然是0。
所以正確答案是A。

3.答案：
!(a == b)為true,還需執(zhí)行后面的(a == 1 + b++),執(zhí)行后a,b的值分別為5,4。
所以正確答案是D

4.答案：

public static void main(String[] args) {
    int i = 0;
    i = i++ + ++i;    //0 + (1 + 1) = 2
    int j = 0;
    j = ++j + j++ + j++ + j++;    //(1 + 0) + 1 + 2 + 3 = 7
    int  k = 0;
    k = k++ + k++ + k++ + ++k;    //0 + 1 + 2 + (1 + 3) = 7
    int h = 0;
    h = ++h + ++h;    //(1 + 0) + (1 + 1) = 3
    int p1 = 0, p2 = 0, q1 = 0, q2 = 0;
    q1 = ++p1;    //q1 = 1, p1 = 1
    q2 = p2++;    //q2 = 0, p2 = 1
    System.out.println(i);    //2
    System.out.println(j);    //7
    System.out.println(k);    //7
    System.out.println(h);    //3
    System.out.println(p1);    //1
    System.out.println(p2);    //1
    System.out.println(q1);    //1
    System.out.println(q2);    //0
}

5.答案：

public static void main(String[] args) {
    int m = 5, n = 5;
    if((m != 5) && (n++ == 5)){}
    System.out.println(n);    //5
    
    m = n = 5;
    if((m != 5) & (n++ == 6)){}
    System.out.println(n);    //6
    
    m = n = 5;
    if((m == 5) || (n++ == 5)){}
    System.out.println(n);    //5
    
    m = n = 5;
    if((m == 5) | (n++ == 6)){}
    System.out.println(n);    //6
    
    int a = 1, b =2;
    int c = a & b;
    System.out.println(c);    //0
}

所以正確答案是：
5
6
5
6
0

　　　　　　　　　　　　　　　　　　類型轉(zhuǎn)換　　　　　　　　　　

1.答案：
A選項錯誤。short類型賦值時不需要在數(shù)值后加s，加s會報錯。
B選項錯誤。float類型賦值時需要在數(shù)值后加f，不加f默認會轉(zhuǎn)成double類型，編譯報錯“不能從double轉(zhuǎn)換為float”。
D選項錯誤。char類型賦值時不需要在后面加c，加c會報錯。
正確答案為C。

2.答案：
在java中以0開頭的數(shù)字代表8進制，數(shù)字范圍0~7，以0x開頭的數(shù)字代表16進制數(shù)字范圍0~F。

public static void main(String[] args) {
    public static void main(String[] args){
    int i = 012;    //(1x8) + 2 = 10
    int j = 034;    //(3x8) + 4 = 28
    int k = (int)056L;//(5x8) + 6 = 46
    int l = 078;    //編譯報錯“類型 int 的文字 078 超出了范圍”
    System.out.println(i);
    System.out.println(j);
    System.out.println(k);
}

所以正確答案是D

3.答案：
short s=1;s=s+1; //s+1為int型,編譯報錯“類型不匹配：不能從 int 轉(zhuǎn)換為 short”
short s=1;s+=1; //編譯正常
所以正確答案是A。

4.答案：
在Java中，整型、實型、字符型被視為簡單數(shù)據(jù)類型，簡單數(shù)據(jù)類型之間會轉(zhuǎn)換，這些類型由低級到高級分別為：
(byte short char) int long float double （7種 不包括boolean）
簡單數(shù)據(jù)類型之間的轉(zhuǎn)換又可以分為：
(1)低級到高級的自動類型轉(zhuǎn)換。
(2)高級到低級的強制類型轉(zhuǎn)換。
(1)包裝類型過渡類型能夠轉(zhuǎn)換。

注意表達式中的精度轉(zhuǎn)換。當表達式中有高精度和低精度類型同時存在時，低精度類型會自動轉(zhuǎn)換為高精度類型，輸出結(jié)果會發(fā)生變化，這點要特別注意。

false?i:x中i是整型，x是字符型，整型比字符型的精度高，所以x會自動轉(zhuǎn)換為整型。結(jié)果為120
false?10:x中10是整型, 但是是常量表達式。Java編程規(guī)范中提到：當后兩個表達式有一個是常量表達式時(10)，兩外一個類型是T(char)，而常量表達式可以被T表示時，輸出結(jié)果是T類型(char類型可以被int表示，所以輸出結(jié)果依然是char類型)。結(jié)果為x
所以正確答案是A．120 x

　　　　　　　　　　　　　　　　　　程序結(jié)構(gòu)　　　　　　　　　　

1.答案：
java中對于main方法有嚴格的定義,必須是
public static void main(String[] x)或
public static void main(String x[])形式的。
修飾符必須是public static，返回類型必須是void(不需要返回類型)，參數(shù)必須是String[] 不能沒有參數(shù)也不能是其他參數(shù)。
標準格式如下：
public static void main(String[] args){}或
public static void main(String args[]){}
可以修改參數(shù)的名字或添加拋出異常?；臼撬烙浻脖车囊环N格式，遇到此類問題可以和標準格式進行比對。
實際上不寫public或參數(shù)并不會在編譯期間報錯但會在運行時報錯。
所以這道題不簡單，坑挺深的，編譯期間4個選項的寫法都不會報錯，但運行時A、D都會出錯。
A、D選項會在運行時報出找不到main方法的錯誤：
“錯誤：在類 Test 中找不到 main 方法，請將 main 方法定義為
public static void main(String[] args) 否則 JavaFX 應(yīng)用程序類必須擴展javafx.application.Application”
所以正確答案是A、D。 如果只能選一個選項的話，選D，《Java程序員面試寶典》一書中給的答案是D,如果恰好考官出的是此書中的題，那就中了。

2.答案：
這道題看起來很簡單，如果你選D就錯了。
這題考驗的是你對構(gòu)造方法的理解。
構(gòu)造方法的定義是：與類名完全相同。沒有返回值，也不能用void來修飾。
注意的是無返回類型而不是void返回類型。
在java中普通方法可以和構(gòu)造方法同名，但是必須帶有返回值。
實際上這題由于public void Penguin(){}方法寫了void返回類型，所以他沒有符合構(gòu)造方法的條件，而是被當作普通方法了。程序執(zhí)行了默認的構(gòu)造方法并沒有執(zhí)行public void Penguin{}這個方法，變量沒有被初始化，所以結(jié)果是C。

　　　　　　　　　　　　　　　　　　運算符　　　　　　　　　　

1.答案：
a?b:c;是三目運算符，相當于：

if(a){
    b;
}else{
    c;
}

boolean b = true ? false : true == true ? false : true;相當于：
boolean b = true ? false : (true == true ? false : true);相當于：

boolean b;
if(true){
    b = false;
}else{
    if(true == true){
        b = false;
    }else{
        b = true;
    }
}

所以正確答案是B。

2.答案：
String s = (i < 40) ? "life" : (i > 50) ? "universe" : "everything";相當于：
String s = (i < 40) ? "life" : ((i > 50) ? "universe" : "everything");相當于：

String s;
if(i < 40){
    s = "life";
}else{
    if(i > 50){
        s = "universe";
    }else{
        s = "everything";
    }
}

所以正確答案是C。

3.答案：
注意10.9：9這里Java會根據(jù)運算符的精度自動進行類型轉(zhuǎn)換。10.9的精度是double型，后面的9也自動轉(zhuǎn)成double型了，
因此代碼執(zhí)行后結(jié)果為9.0。
所以答案是D。

4.答案：
&、|是位運算符，是操作二進制數(shù)的，所以要先把a、b轉(zhuǎn)換為二進制數(shù)進行位運算后再轉(zhuǎn)換為整型輸出結(jié)果。
1的二進制是01，2的進制是10
a&b = 1 & 2 =
01
10
__
00 = 0;

a|b = 1 | 2 =
01
10
__
11 = 3;
所以輸出結(jié)果為：
0
3

5.答案：
<<、>>是位移運算符，是操作二進制數(shù)的，所以要先把a、b轉(zhuǎn)換為二進制數(shù)進行位移運算后再轉(zhuǎn)換為整型輸出結(jié)果。

public static void main(String[] args) {
    int a = 1;
    int b = 2;
    System.out.println(b << a);    //(b << a) = (0010 << 1) = 0100 = 4
    System.out.println(b >> a);    //(b >> a) = (0010 >> 1) = 0001 = 1
}

所以輸出結(jié)果為：
4
1

6.答案：
注意當位移溢出時的計算結(jié)果。

public static void main(String[] args) {
    int a = 1;
    int b = 2;
    System.out.println(b << a << a);    //(b << a << a) = (b << 2) = (0010 << 2) = 1000 = 8  
    System.out.println(b >> a >> a);    //(b >> a >> a) = (b >> 2) = (0010 >> 2) = 0000 = 0
    System.out.println(b >> 32);    //(b >> 32) = (b >> (32%32)) = (b >> 0) = b = 2;    數(shù)據(jù)溢出時，位移數(shù)%數(shù)據(jù)最大范圍，求余后重新計算
    System.out.println(b << 33);    //(b << 33) = (b << (33%32)) = (b << 1) = (0010 << 1) = 0100 = 4;    數(shù)據(jù)溢出時，位移數(shù)%數(shù)據(jù)最大范圍，求余后重新計算
}

所以輸出結(jié)果為：
8
0
2
4

　　　　　　　　　　　　　　　　　　算法　　　　　　　　　　

1.輸出數(shù)組里的所有值 答案：

//方法1 Arrays.toString(array)
public static void main(String[] args) {
    int[] array = new int[]{1, 2, 3, 4};
    System.out.println(Arrays.toString(array));    //[1, 2, 3, 4]
}

//方法2 for循環(huán)
public static void main(String[] args) {
    int[] array = new int[]{1, 2, 3, 4};
    int length = array.length;
    for (int i = 0; i < length; i++) {
        System.out.print(array[i] + " ");    //1 2 3 4
    }
}

//方法3 foreach循環(huán)
public static void main(String[] args) {
    int[] array = new int[]{1, 2, 3, 4};
    for(int v : array){
        System.out.print(v + " ");    //1 2 3 4
    }
}

2.輸出99乘法口訣表 答案：

//方法1 用String
public static void NineNine(){
    String str = "";
    for (int i = 1; i <= 9; i++) {
        for (int j = 1; j <= i; j++) {
            str += j + "*" + i + "=" + j*i + "	";
        }
        str += "
";
    }
    System.out.println(str);
}

循環(huán)10W次時間：1180ms

//方法2 用StringBuilder
public static void NineNine(){
    StringBuilder sb = new StringBuilder();
    for (int i = 1; i <= 9; i++) {
        for (int j = 1; j <= i; j++) {
            sb.append(j);
            sb.append("*");
            sb.append(i);
            sb.append("=");
            sb.append(j*i);
            sb.append("	");
        }
        sb.append("
");
    }
    System.out.println(sb);
}

循環(huán)10W次時間：367ms

//方法3 一次循環(huán)完成
public static void NineNine(){
    int i = 1;  
    int j = 1;
    String str = "";
    while (i <= 9) {
        str += j + "*" + i + "=" + j*i + "	";
        j++;
        if(j > i){
            i++;
            j = 1;
            str += "
";
        }
    }
    System.out.println(str);
}

循環(huán)10W次時間：1197ms

//測試代碼
public static void main(String[] args){
    long t1 = System.currentTimeMillis();
    for (int i = 0; i < 100000; i++) {
        //循環(huán)時注釋掉System.out.println(str)
        NineNine();
    }
    long t2 = System.currentTimeMillis();
    System.out.println(t2 - t1);
}

3.輸出字符串中出現(xiàn)次數(shù)最多的字符 答案：

//方法1
public static void printMaxChars(String str){
    HashMap map = new HashMap();
    int length = str.length();
    int max = 0;
    //循環(huán)字符串中的所有字符，記錄每個字符出現(xiàn)的次數(shù)并獲取最大次數(shù)
    for (int i = 0; i < length; i++) {
        int count = 0;
        char c = str.charAt(i);
        if(map.containsKey(c)){
            count = map.get(c);
        }
        count++;
        if(count > max){
            max = count;
        }
        map.put(c, count);
    }
    System.out.println("最大次數(shù)：" + max);
    //遍歷map中的鍵，如果其值等于最大次數(shù)，則列出
    for (Character c : map.keySet()) {
        if(map.get(c).equals(max)){
            System.out.print(c + " ");
        }
    }
}

輸出結(jié)果：
最大次數(shù)：4
c a
(輸出結(jié)果還可以放進數(shù)組里排個序)

4.編寫函數(shù)f(n), 獲取0~n中“1”出現(xiàn)的次數(shù) 答案：

//獲取0~n中1的數(shù)量
public static int get1Count(int n){
    String str = "";
    for (int i = 1; i <= n; i++) {
        str += i;
    }
    int count = 0;
    int length = str.length();
    for (int i = 0; i < length; i++) {
        char c = str.charAt(i);
        if(c == "1"){
            count++;
        }
    }
    return count;
}

5.獲取斐波那契數(shù)列的第n項值 答案：

//方法1 for循環(huán)
public static int feiBo(int n) {
    int a = 0;
    int b = 1;
    for (int i = 0; i < n; i++) {
        int c = a + b;
        a = b;
        b = c;
    }
    return a;
}

feiBo(40)循環(huán)1000萬次時間：440ms

//方法2 for循環(huán)簡化
public static int feiBo(int n){
    int a = 0;
    int b = 1;
    for (int i = 0; i < n; i++) {
        b = a + b;
        a = b - a;
    }
    return a;
}

feiBo(40)循環(huán)1000萬次時間：325ms

//方法3 遞歸
public static int feiBo(int n){
    return n < 2 ? n : feiBo(n - 1) + feiBo(n - 2);
}

feiBo(40)只計算一次時間：401ms
以上測試可以看出。雖然遞歸很優(yōu)美，但是效率太差，老老實實用for循環(huán)寫吧。很意外的是for循環(huán)簡化后效率提升了這么多。

//測試代碼
public static void main(String[] args) {
    long t1 = System.currentTimeMillis();
    for (int i = 0; i < 10000000; i++) {
        feiBo(40);    //遞歸效率極低，不能循環(huán)這么多次，只能循環(huán)一次
    }
    long t2 = System.currentTimeMillis();
    System.out.println(t2 - t1);
}