Java基礎知識常見面試題彙總

阿新 • • 發佈：2022-04-13

1. 前言

參加過社招的同學都瞭解，進入一家公司面試開發崗位時，填寫完個人資訊後，一般都會讓先做一份筆試題，然後公司會根據筆試題的回答結果，確定要不要繼續此次面試，如果答的不好，有些公司可能會直接說“技術經理或者總監在忙，你先回去等通知吧”，有些公司可能會繼續面試，瞭解下你的專案經驗等情況。

至少在工作的前5年甚至更久，面試一般不會跳過筆試題這個環節（大牛，個別公司除外），我自己也記不清自己面試過多少家公司，做過多少份面試題了，導致現在有時逛街，總感覺很多地方似曾相識，感覺自己多年前曾經來面過試，一度自嘲，一度也懷疑，自己當年是靠什麼在上海堅持下來的，所以說面試題對於求職來說，還是非常重要的。

網上搜索“Java面試題”幾個關鍵字也是有很多很多的文章講解，為什麼我還要自己總結呢？主要有以下幾個原因：

文章太多，反倒不知道該看哪個（就如一本書中所說太多的資訊等於沒有資訊）
文章的準確性不高（曾多次發現描述不正確或程式碼跑不起來的情況）
可以加深自己的理解和記憶
一勞永逸，下次不用再從網上慢慢篩選，看自己整理的就好了

本篇主要整理下Java基礎知識的面試題，主要包含以下幾點：

Integer和int的區別
==和equals的區別
String,StringBuilder,StringBuffer的區別
裝箱和拆箱
Java中的值傳遞和引用傳遞

接下來一一講解。

2. Integer和int的區別

2.1 基本概念區分

Integer是int的包裝類(引用型別)，int是Java的一種基本資料型別(值型別)。
Integer變數必須例項化後才能使用，而int變數不需要。
Integer實際是物件的引用，當new一個Integer時，實際上是生成一個指標指向此物件，而int則是直接儲存資料值。
Integer的預設值是null，int的預設值是0。

2.2 Integer與int常見的幾種比較場景

1)兩個new Integer()變數相比較，永遠返回false

Integer i = new Integer(100);
Integer j = new Integer(100);
System.out.println(i == j); // false

兩個通過new生成的Integer變數生成的是兩個物件，其記憶體地址不同

2)非new生成的Integer變數和new Integer()生成的變數相比較，永遠返回false

Integer i = new Integer(100);
Integer j = 100;
System.out.println(i == j); // false

非new生成的Integer變數指向的是Java常量池中的物件，而new Integer()生成的變數指向堆中新建的物件，兩者在記憶體中的地址不同

3)兩個非new生成的Integer變數比較，如果兩個變數的值在區間-128到127 之間，則比較結果為true，如果兩個變數的值不在此區間，則比較結果為 false。

Integer i = 100;
Integer j = 100;
System.out.println(i == j); //true

Integer i1 = 128;
Integer j1 = 128;
System.out.println(i1 == j1); //false

為什麼會這樣呢，我們來分析下原因：

Integer i = 100; 在編譯時，會翻譯成 Integer i = Integer.valueOf(100); ，而Java中Integer類的valueOf方法的原始碼如下：

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

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) {
              try {
                  int i = parseInt(integerCacheHighPropValue);
                  i = Math.max(i, 127);
                  // Maximum array size is Integer.MAX_VALUE
                  h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
              } catch( NumberFormatException nfe) {
                  // If the property cannot be parsed into an int, ignore it.
              }
            }
            high = h;

            cache = new Integer[(high - low) + 1];
            int j = low;
            for(int k = 0; k < cache.length; k++)
                cache[k] = new Integer(j++);

            // range [-128, 127] must be interned (JLS7 5.1.7)
            assert IntegerCache.high >= 127;
    }

    private IntegerCache() {}
}

從原始碼可以看出：

Java中的Integer對於-128到127之間的數，會進行快取。
所以 Integer i = 100 時，會將100進行快取，下次再寫Integer j = 100時，就會直接從快取中取，而不會new了。

4)Integer變數和int變數比較時，只要兩個變數的值是向等的，則結果為true

Integer i = new Integer(100);
int j = 100;
System.out.print(i == j); //true

因為包裝類Integer和基本資料型別int比較時，Java會自動拆箱為int，然後進行比較，實際上就變為兩個int變數的比較

3. ==和equals的區別

3.1 基本概念區分

1)對於==，比較的是值是否相等

如果作用於基本資料型別的變數，則直接比較其儲存的值是否相等，

如果作用於引用型別的變數，則比較的是所指向的物件的地址是否相等。

其實==比較的不管是基本資料型別，還是引用資料型別的變數，比較的都是值，只是引用型別變數存的值是物件的地址

2)對於equals方法，比較的是是否是同一個物件

首先，equals()方法不能作用於基本資料型別的變數，

另外，equals()方法存在於Object類中，而Object類是所有類的直接或間接父類，所以說所有類中的equals()方法都繼承自Object類，在沒有重寫equals()方法的類中，呼叫equals()方法其實和使用==的效果一樣，也是比較的是引用型別的變數所指向的物件的地址，不過，Java提供的類中，有些類都重寫了equals()方法，重寫後的equals()方法一般都是比較兩個物件的值，比如String類。

Object類equals()方法原始碼：

public boolean equals(Object obj) {
     return (this == obj);
}

String類equals()方法原始碼：

public boolean equals(Object anObject) {
    if (this == anObject) {
        return true;
    }
    if (anObject instanceof String) {
        String anotherString = (String)anObject;
        int n = value.length;
        if (n == anotherString.value.length) {
            char v1[] = value;
            char v2[] = anotherString.value;
            int i = 0;
            while (n-- != 0) {
                if (v1[i] != v2[i])
                    return false;
                i++;
            }
            return true;
        }
    }
    return false;
}

3.2 示例

示例1：

int x = 10;
int y = 10;
String str1 = new String("abc");
String str2 = new String("abc");
System.out.println(x == y); // true
System.out.println(str1 == str2); // false
System.out.println(str1.equals(str2)); // true

示例2：

String str3 = "abc";
String str4 = "abc";
System.out.println(str3 == str4); // true

str3與str4相等的原因是用到了記憶體中的常量池，當執行到str3建立物件時，如果常量池中沒有，就在常量池中建立一個物件"abc"，第二次建立的時候，就直接使用，所以兩次建立的物件其實是同一個物件，它們的地址值相等。

示例3：

先定義學生Student類

package com.zwwhnly.springbootaction;

public class Student {
    private int age;

    public Student(int age) {
        this.age = age;
    }
}

然後建立兩個Student例項來比較

Student student1 = new Student(23);
Student student2 = new Student(23);

System.out.println(student1.equals(student2)); // false

此時equals方法呼叫的是基類Object類的equals()方法，也就是==比較，所以返回false。

然後我們重寫下equals()方法，只要兩個學生的年齡相同，就認為是同一個學生。

package com.zwwhnly.springbootaction;

public class Student {
    private int age;

    public Student(int age) {
        this.age = age;
    }

    @Override
    public boolean equals(Object obj) {
        Student student = (Student) obj;
        return this.age == student.age;
    }
}

此時再比較剛剛的兩個例項，返回true。

Student student1 = new Student(23);
Student student2 = new Student(23);

System.out.println(student1.equals(student2)); // true

4. String,StringBuilder,StringBuffer的區別

4.1 區別講解

1)執行速度

執行速度快慢順序為：StringBuilder > StringBuffer > String

String最慢的原因：

String為字串常量，而StringBuilder和StringBuffer均為字串變數，即String物件一旦建立之後該物件是不可以更改的，但後兩者的物件是變數，是可以更改的。

2)執行緒安全

線上程安全上，StringBuilder是執行緒不安全的，而StringBuffer是執行緒安全的(很多方法帶有synchronized關鍵字)。

3)使用場景

String：適用於少量的字串操作的情況。

StringBuilder：適用於單執行緒下在字元緩衝區進行大量操作的情況。

StringBuffer：適用於多執行緒下在字元緩衝區進行大量操作的情況。

4.2 示例

以拼接10000次字串為例，我們看下三者各自需要的時間：

String str = "";
long startTime = System.currentTimeMillis();
for (int i = 0; i < 10000; i++) {
    str = str + i;
}
long endTime = System.currentTimeMillis();
long time = endTime - startTime;
System.out.println("String消耗時間：" + time);

StringBuilder builder = new StringBuilder("");
startTime = System.currentTimeMillis();
for (int j = 0; j < 10000; j++) {
    builder.append(j);
}
endTime = System.currentTimeMillis();
time = endTime - startTime;
System.out.println("StringBuilder消耗時間：" + time);

StringBuffer buffer = new StringBuffer("");
startTime = System.currentTimeMillis();
for (int k = 0; k < 10000; k++) {
    buffer.append(k);
}
endTime = System.currentTimeMillis();
time = endTime - startTime;
System.out.println("StringBuffer消耗時間：" + time);

執行結果：

String消耗時間：258

StringBuilder消耗時間：0

StringBuffer消耗時間：1

也驗證了上面所說的StringBuilder > StringBuffer > String。

5. 裝箱和拆箱

5.1 什麼是裝箱？什麼是拆箱？

裝箱：自動將基本資料型別轉換為包裝器型別。

拆箱：自動將包裝器型別轉換為基本資料型別。

Integer i = 10; // 裝箱
int j = i; // 拆箱

5.2 裝箱和拆箱是如何實現的？

裝箱過程是通過呼叫包裝器的valueOf方法實現的，

而拆箱過程是通過呼叫包裝器例項的xxxValue方法實現的（xxx代表對應的基本資料型別）。

怎麼證明這個結論呢，我們新建個Main類,在主方法中新增如下程式碼：

package com.zwwhnly.springbootaction;

public class Main {
    public static void main(String[] args) {
        Integer i = 100;        
        int j = i;
    }
}

然後開啟cmd視窗，切換到Main類所在路徑，執行命令：javac Main.java，會發現該目錄會生成一個Main.class檔案，用IDEA開啟，會發現編譯後的程式碼如下：

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package com.zwwhnly.springbootaction;

public class Main {
    public Main() {
    }

    public static void main(String[] var0) {
        Integer var1 = Integer.valueOf(100);
        int var2 = var1.intValue();
    }
}

注意事項：以上所講使用的是IDEA 2017.2

而在較新版本的IDEA（2018.3.3或者2019.1.3），看到的Main.class是下面這樣的：

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package com.zwwhnly.springbootaction;

public class Main {
    public Main() {
    }

    public static void main(String[] var0) {
        Integer var1 = 100;
        int var2 = var1;
    }
}

5.3 示例

示例1：

Double i1 = 100.0;
Double i2 = 100.0;
Double i3 = 200.0;
Double i4 = 200.0;

System.out.println(i1==i2);
System.out.println(i3==i4);

輸出結果：

false

false

為什麼都返回false呢，我們看下Double.valueOf()方法，就知曉了：

private final double value;

public Double(double value) {
   this.value = value;
}

public static Double valueOf(double d) {
   return new Double(d);
}

示例2：

Boolean i1 = false;
Boolean i2 = false;
Boolean i3 = true;
Boolean i4 = true;

System.out.println(i1==i2);
System.out.println(i3==i4);

輸出結果：

true

true

為什麼都返回true呢，我們看下Boolean.valueOf()方法，就知曉了：

public static final Boolean TRUE = new Boolean(true);
public static final Boolean FALSE = new Boolean(false);

public static Boolean valueOf(boolean b) {
   return (b ? TRUE : FALSE);
}

6. Java中的值傳遞和引用傳遞

6.1 基本概念

值傳遞：傳遞物件的一個副本，即使副本被改變，也不會影響源物件，因為值傳遞的時候，實際上是將實參的值複製一份給形參。

引用傳遞：傳遞的並不是實際的物件，而是物件的引用，外部對引用物件的改變也會反映到源物件上，因為引用傳遞的時候，實際上是將實參的地址值複製一份給形參。

說明：物件傳遞（陣列、類、介面）是引用傳遞，原始型別資料（整形、浮點型、字元型、布林型）傳遞是值傳遞。

6.2 示例

示例1(值傳遞)：

package com.zwwhnly.springbootaction;

public class ArrayListDemo {

    public static void main(String[] args) {
        int num1 = 10;
        int num2 = 20;

        swap(num1, num2);

        System.out.println("num1 = " + num1);
        System.out.println("num2 = " + num2);
    }

    public static void swap(int a, int b) {
        int temp = a;
        a = b;
        b = temp;

        System.out.println("a = " + a);
        System.out.println("b = " + b);
    }
}

執行結果：

a = 20

b = 10

num1 = 10

num2 = 20

可以看出，雖然在swap()方法中a,b的值做了交換，但是主方法中num1，num2的值並未改變。

示例2(引用型別傳遞)：

package com.zwwhnly.springbootaction;

public class ArrayListDemo {

    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};

        change(arr);

        System.out.println(arr[0]);
    }

    public static void change(int[] array) {
        System.out.println(array[0]);
        array[0] = 0;
    }
}

執行結果：

1

0

可以看出，在change()方法中將陣列的第一個元素改為0，主方法中陣列的第一個元素也跟著變為0。

示例3(StringBuffer型別)：

package com.zwwhnly.springbootaction;

public class ArrayListDemo {

    public static void main(String[] args) {
        StringBuffer stringBuffer = new StringBuffer("部落格園：申城異鄉人");
        System.out.println(stringBuffer);

        changeStringBuffer(stringBuffer);
        System.out.println(stringBuffer);
    }

    public static void changeStringBuffer(StringBuffer stringBuffer) {
        stringBuffer = new StringBuffer("掘金：申城異鄉人");

        stringBuffer.append(",歡迎大家關注");
    }
}

執行結果：

部落格園：申城異鄉人

部落格園：申城異鄉人

也許你會認為第2次應該輸出“掘金：申城異鄉人,歡迎大家關注”，怎麼輸出的還是原來的值呢，那是因為在changeStringBuffer中，又new了一個StringBuffer物件，此時stringBuffer變數指向的記憶體地址已經改變，所以主方法中的stringBuffer變數未受到影響。

如果修改changeStringBuffer()方法的程式碼為：

public static void changeStringBuffer(StringBuffer stringBuffer) {

    stringBuffer.append(",歡迎大家關注");
}

則執行結果會變為：

部落格園：申城異鄉人

部落格園：申城異鄉人,歡迎大家關注

示例4(String型別)：

package com.zwwhnly.springbootaction;

public class ArrayListDemo {

    public static void main(String[] args) {
        String str = new String("部落格園：申城異鄉人");
        System.out.println(str);

        changeString(str);
        System.out.println(str);
    }

    public static void changeString(String string) {
        //string = "掘金：申城異鄉人";
        string = new String("掘金：申城異鄉人");
    }
}

執行結果：

部落格園：申城異鄉人

部落格園：申城異鄉人

在changeString()方法中不管用string = "掘金：申城異鄉人";還是string = new String("掘金：申城異鄉人");，主方法中的str變數都不會受影響，也驗證了String建立之後是不可變更的。

示例5(自定義型別)：

package com.zwwhnly.springbootaction;

public class Person {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Person(String name) {
        this.name = name;
    }
}

package com.zwwhnly.springbootaction;

public class ArrayListDemo {

    public static void main(String[] args) {
        Person person = new Person("zhangsan");
        System.out.println(person.getName());

        changePerson(person);
        System.out.println(person.getName());
    }

    public static void changePerson(Person p) {
        Person person = new Person("lisi");
        p = person;
    }
}

執行結果：

zhangsan

zhangsan

修改changePerson()方法程式碼為：

public static void changePerson(Person p) {
    p.setName("lisi");
}

則執行結果為：

zhangsan

lisi

7. 參考

關於==和equals的區別和聯絡，面試這麼回答就可以

Java中==號與equals()方法的區別

Java中的String，StringBuilder，StringBuffer三者的區別

深入剖析Java中的裝箱和拆箱

Integer、new Integer() 和 int 比較的面試題

java面試題之int和Integer的區別

最最最常見的Java面試題總結-第一週

來源：Java基礎知識常見面試題彙總第一篇 - 申城異鄉人 - 部落格園 (cnblogs.com)

1. 前言

網上搜索“Java面試題”幾個關鍵字也是有很多很多的文章講解，為什麼我還要自己總結呢？主要有以下幾個原因：

文章太多，反倒不知道該看哪個（就如一本書中所說太多的資訊等於沒有資訊）
文章的準確性不高（曾多次發現描述不正確或程式碼跑不起來的情況）
可以加深自己的理解和記憶
一勞永逸，下次不用再從網上慢慢篩選，看自己整理的就好了

本篇主要整理下Java基礎知識的面試題，主要包含以下幾點：

Integer和int的區別
==和equals的區別
String,StringBuilder,StringBuffer的區別
裝箱和拆箱
Java中的值傳遞和引用傳遞

接下來一一講解。

2. Integer和int的區別

2.1 基本概念區分

Integer是int的包裝類(引用型別)，int是Java的一種基本資料型別(值型別)。
Integer變數必須例項化後才能使用，而int變數不需要。
Integer實際是物件的引用，當new一個Integer時，實際上是生成一個指標指向此物件，而int則是直接儲存資料值。
Integer的預設值是null，int的預設值是0。

2.2 Integer與int常見的幾種比較場景

1)兩個new Integer()變數相比較，永遠返回false

Integer i = new Integer(100);
Integer j = new Integer(100);
System.out.println(i == j); // false

兩個通過new生成的Integer變數生成的是兩個物件，其記憶體地址不同

2)非new生成的Integer變數和new Integer()生成的變數相比較，永遠返回false

Integer i = new Integer(100);
Integer j = 100;
System.out.println(i == j); // false

非new生成的Integer變數指向的是Java常量池中的物件，而new Integer()生成的變數指向堆中新建的物件，兩者在記憶體中的地址不同

3)兩個非new生成的Integer變數比較，如果兩個變數的值在區間-128到127 之間，則比較結果為true，如果兩個變數的值不在此區間，則比較結果為 false。

Integer i = 100;
Integer j = 100;
System.out.println(i == j); //true

Integer i1 = 128;
Integer j1 = 128;
System.out.println(i1 == j1); //false

為什麼會這樣呢，我們來分析下原因：

Integer i = 100; 在編譯時，會翻譯成 Integer i = Integer.valueOf(100); ，而Java中Integer類的valueOf方法的原始碼如下：

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

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) {
              try {
                  int i = parseInt(integerCacheHighPropValue);
                  i = Math.max(i, 127);
                  // Maximum array size is Integer.MAX_VALUE
                  h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
              } catch( NumberFormatException nfe) {
                  // If the property cannot be parsed into an int, ignore it.
              }
            }
            high = h;

            cache = new Integer[(high - low) + 1];
            int j = low;
            for(int k = 0; k < cache.length; k++)
                cache[k] = new Integer(j++);

            // range [-128, 127] must be interned (JLS7 5.1.7)
            assert IntegerCache.high >= 127;
    }

    private IntegerCache() {}
}

從原始碼可以看出：

Java中的Integer對於-128到127之間的數，會進行快取。
所以 Integer i = 100 時，會將100進行快取，下次再寫Integer j = 100時，就會直接從快取中取，而不會new了。

4)Integer變數和int變數比較時，只要兩個變數的值是向等的，則結果為true

Integer i = new Integer(100);
int j = 100;
System.out.print(i == j); //true

因為包裝類Integer和基本資料型別int比較時，Java會自動拆箱為int，然後進行比較，實際上就變為兩個int變數的比較

3. ==和equals的區別

3.1 基本概念區分

1)對於==，比較的是值是否相等

如果作用於基本資料型別的變數，則直接比較其儲存的值是否相等，

如果作用於引用型別的變數，則比較的是所指向的物件的地址是否相等。

其實==比較的不管是基本資料型別，還是引用資料型別的變數，比較的都是值，只是引用型別變數存的值是物件的地址

2)對於equals方法，比較的是是否是同一個物件

首先，equals()方法不能作用於基本資料型別的變數，

Object類equals()方法原始碼：

public boolean equals(Object obj) {
     return (this == obj);
}

String類equals()方法原始碼：

public boolean equals(Object anObject) {
    if (this == anObject) {
        return true;
    }
    if (anObject instanceof String) {
        String anotherString = (String)anObject;
        int n = value.length;
        if (n == anotherString.value.length) {
            char v1[] = value;
            char v2[] = anotherString.value;
            int i = 0;
            while (n-- != 0) {
                if (v1[i] != v2[i])
                    return false;
                i++;
            }
            return true;
        }
    }
    return false;
}

3.2 示例

示例1：

int x = 10;
int y = 10;
String str1 = new String("abc");
String str2 = new String("abc");
System.out.println(x == y); // true
System.out.println(str1 == str2); // false
System.out.println(str1.equals(str2)); // true

示例2：

String str3 = "abc";
String str4 = "abc";
System.out.println(str3 == str4); // true

str3與str4相等的原因是用到了記憶體中的常量池，當執行到str3建立物件時，如果常量池中沒有，就在常量池中建立一個物件"abc"，第二次建立的時候，就直接使用，所以兩次建立的物件其實是同一個物件，它們的地址值相等。

示例3：

先定義學生Student類

package com.zwwhnly.springbootaction;

public class Student {
    private int age;

    public Student(int age) {
        this.age = age;
    }
}

然後建立兩個Student例項來比較

Student student1 = new Student(23);
Student student2 = new Student(23);

System.out.println(student1.equals(student2)); // false

此時equals方法呼叫的是基類Object類的equals()方法，也就是==比較，所以返回false。

然後我們重寫下equals()方法，只要兩個學生的年齡相同，就認為是同一個學生。

package com.zwwhnly.springbootaction;

public class Student {
    private int age;

    public Student(int age) {
        this.age = age;
    }

    @Override
    public boolean equals(Object obj) {
        Student student = (Student) obj;
        return this.age == student.age;
    }
}

此時再比較剛剛的兩個例項，返回true。

Student student1 = new Student(23);
Student student2 = new Student(23);

System.out.println(student1.equals(student2)); // true

4. String,StringBuilder,StringBuffer的區別

4.1 區別講解

1)執行速度

執行速度快慢順序為：StringBuilder > StringBuffer > String

String最慢的原因：

String為字串常量，而StringBuilder和StringBuffer均為字串變數，即String物件一旦建立之後該物件是不可以更改的，但後兩者的物件是變數，是可以更改的。

2)執行緒安全

線上程安全上，StringBuilder是執行緒不安全的，而StringBuffer是執行緒安全的(很多方法帶有synchronized關鍵字)。

3)使用場景

String：適用於少量的字串操作的情況。

StringBuilder：適用於單執行緒下在字元緩衝區進行大量操作的情況。

StringBuffer：適用於多執行緒下在字元緩衝區進行大量操作的情況。

4.2 示例

以拼接10000次字串為例，我們看下三者各自需要的時間：

String str = "";
long startTime = System.currentTimeMillis();
for (int i = 0; i < 10000; i++) {
    str = str + i;
}
long endTime = System.currentTimeMillis();
long time = endTime - startTime;
System.out.println("String消耗時間：" + time);

StringBuilder builder = new StringBuilder("");
startTime = System.currentTimeMillis();
for (int j = 0; j < 10000; j++) {
    builder.append(j);
}
endTime = System.currentTimeMillis();
time = endTime - startTime;
System.out.println("StringBuilder消耗時間：" + time);

StringBuffer buffer = new StringBuffer("");
startTime = System.currentTimeMillis();
for (int k = 0; k < 10000; k++) {
    buffer.append(k);
}
endTime = System.currentTimeMillis();
time = endTime - startTime;
System.out.println("StringBuffer消耗時間：" + time);

執行結果：

String消耗時間：258

StringBuilder消耗時間：0

StringBuffer消耗時間：1

也驗證了上面所說的StringBuilder > StringBuffer > String。

5. 裝箱和拆箱

5.1 什麼是裝箱？什麼是拆箱？

裝箱：自動將基本資料型別轉換為包裝器型別。

拆箱：自動將包裝器型別轉換為基本資料型別。

Integer i = 10; // 裝箱
int j = i; // 拆箱

5.2 裝箱和拆箱是如何實現的？

裝箱過程是通過呼叫包裝器的valueOf方法實現的，

而拆箱過程是通過呼叫包裝器例項的xxxValue方法實現的（xxx代表對應的基本資料型別）。

怎麼證明這個結論呢，我們新建個Main類,在主方法中新增如下程式碼：

package com.zwwhnly.springbootaction;

public class Main {
    public static void main(String[] args) {
        Integer i = 100;        
        int j = i;
    }
}

然後開啟cmd視窗，切換到Main類所在路徑，執行命令：javac Main.java，會發現該目錄會生成一個Main.class檔案，用IDEA開啟，會發現編譯後的程式碼如下：

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package com.zwwhnly.springbootaction;

public class Main {
    public Main() {
    }

    public static void main(String[] var0) {
        Integer var1 = Integer.valueOf(100);
        int var2 = var1.intValue();
    }
}

注意事項：以上所講使用的是IDEA 2017.2

而在較新版本的IDEA（2018.3.3或者2019.1.3），看到的Main.class是下面這樣的：

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package com.zwwhnly.springbootaction;

public class Main {
    public Main() {
    }

    public static void main(String[] var0) {
        Integer var1 = 100;
        int var2 = var1;
    }
}

5.3 示例

示例1：

Double i1 = 100.0;
Double i2 = 100.0;
Double i3 = 200.0;
Double i4 = 200.0;

System.out.println(i1==i2);
System.out.println(i3==i4);

輸出結果：

false

false

為什麼都返回false呢，我們看下Double.valueOf()方法，就知曉了：

private final double value;

public Double(double value) {
   this.value = value;
}

public static Double valueOf(double d) {
   return new Double(d);
}

示例2：

Boolean i1 = false;
Boolean i2 = false;
Boolean i3 = true;
Boolean i4 = true;

System.out.println(i1==i2);
System.out.println(i3==i4);

輸出結果：

true

true

為什麼都返回true呢，我們看下Boolean.valueOf()方法，就知曉了：

public static final Boolean TRUE = new Boolean(true);
public static final Boolean FALSE = new Boolean(false);

public static Boolean valueOf(boolean b) {
   return (b ? TRUE : FALSE);
}

6. Java中的值傳遞和引用傳遞

6.1 基本概念

值傳遞：傳遞物件的一個副本，即使副本被改變，也不會影響源物件，因為值傳遞的時候，實際上是將實參的值複製一份給形參。

說明：物件傳遞（陣列、類、介面）是引用傳遞，原始型別資料（整形、浮點型、字元型、布林型）傳遞是值傳遞。

6.2 示例

示例1(值傳遞)：

package com.zwwhnly.springbootaction;

public class ArrayListDemo {

    public static void main(String[] args) {
        int num1 = 10;
        int num2 = 20;

        swap(num1, num2);

        System.out.println("num1 = " + num1);
        System.out.println("num2 = " + num2);
    }

    public static void swap(int a, int b) {
        int temp = a;
        a = b;
        b = temp;

        System.out.println("a = " + a);
        System.out.println("b = " + b);
    }
}

執行結果：

a = 20

b = 10

num1 = 10

num2 = 20

可以看出，雖然在swap()方法中a,b的值做了交換，但是主方法中num1，num2的值並未改變。

示例2(引用型別傳遞)：

package com.zwwhnly.springbootaction;

public class ArrayListDemo {

    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};

        change(arr);

        System.out.println(arr[0]);
    }

    public static void change(int[] array) {
        System.out.println(array[0]);
        array[0] = 0;
    }
}

執行結果：

1

0

可以看出，在change()方法中將陣列的第一個元素改為0，主方法中陣列的第一個元素也跟著變為0。

示例3(StringBuffer型別)：

package com.zwwhnly.springbootaction;

public class ArrayListDemo {

    public static void main(String[] args) {
        StringBuffer stringBuffer = new StringBuffer("部落格園：申城異鄉人");
        System.out.println(stringBuffer);

        changeStringBuffer(stringBuffer);
        System.out.println(stringBuffer);
    }

    public static void changeStringBuffer(StringBuffer stringBuffer) {
        stringBuffer = new StringBuffer("掘金：申城異鄉人");

        stringBuffer.append(",歡迎大家關注");
    }
}

執行結果：

部落格園：申城異鄉人

部落格園：申城異鄉人

如果修改changeStringBuffer()方法的程式碼為：

public static void changeStringBuffer(StringBuffer stringBuffer) {

    stringBuffer.append(",歡迎大家關注");
}

則執行結果會變為：

部落格園：申城異鄉人

部落格園：申城異鄉人,歡迎大家關注

示例4(String型別)：

package com.zwwhnly.springbootaction;

public class ArrayListDemo {

    public static void main(String[] args) {
        String str = new String("部落格園：申城異鄉人");
        System.out.println(str);

        changeString(str);
        System.out.println(str);
    }

    public static void changeString(String string) {
        //string = "掘金：申城異鄉人";
        string = new String("掘金：申城異鄉人");
    }
}

執行結果：

部落格園：申城異鄉人

部落格園：申城異鄉人

示例5(自定義型別)：

package com.zwwhnly.springbootaction;

public class Person {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Person(String name) {
        this.name = name;
    }
}

package com.zwwhnly.springbootaction;

public class ArrayListDemo {

    public static void main(String[] args) {
        Person person = new Person("zhangsan");
        System.out.println(person.getName());

        changePerson(person);
        System.out.println(person.getName());
    }

    public static void changePerson(Person p) {
        Person person = new Person("lisi");
        p = person;
    }
}

執行結果：

zhangsan

zhangsan

修改changePerson()方法程式碼為：

public static void changePerson(Person p) {
    p.setName("lisi");
}

則執行結果為：

zhangsan

lisi

7. 參考

關於==和equals的區別和聯絡，面試這麼回答就可以

Java中==號與equals()方法的區別

Java中的String，StringBuilder，StringBuffer三者的區別

深入剖析Java中的裝箱和拆箱

Integer、new Integer() 和 int 比較的面試題

java面試題之int和Integer的區別

最最最常見的Java面試題總結-第一週

Java基礎知識常見面試題彙總

1. 前言

2. Integer和int的區別

2.1 基本概念區分

2.2 Integer與int常見的幾種比較場景

3. ==和equals的區別

3.1 基本概念區分

3.2 示例

4. String,StringBuilder,StringBuffer的區別

4.1 區別講解

4.2 示例

5. 裝箱和拆箱

5.1 什麼是裝箱？什麼是拆箱？

5.2 裝箱和拆箱是如何實現的？

5.3 示例

6. Java中的值傳遞和引用傳遞

6.1 基本概念

6.2 示例

7. 參考

1. 前言

2. Integer和int的區別

2.1 基本概念區分

2.2 Integer與int常見的幾種比較場景

3. ==和equals的區別

3.1 基本概念區分

3.2 示例

4. String,StringBuilder,StringBuffer的區別

4.1 區別講解

4.2 示例

5. 裝箱和拆箱

5.1 什麼是裝箱？什麼是拆箱？

5.2 裝箱和拆箱是如何實現的？

5.3 示例

6. Java中的值傳遞和引用傳遞

6.1 基本概念

6.2 示例

7. 參考

相關推薦