本系列文章將整理到我在GitHub上的《Java面試指南》倉庫，更多精彩內容請到我的倉庫裡檢視
> https://github.com/h2pl/Java-Tutorial

喜歡的話麻煩點下Star哈

文章首發於我的個人部落格：
> www.how2playlife.com

本文是微信公眾號【Java技術江湖】的《夯實Java基礎系列博文》其中一篇，本文部分內容來源於網路，為了把本文主題講得清晰透徹，也整合了很多我認為不錯的技術部落格內容，引用其中了一些比較好的部落格文章，如有侵權，請聯絡作者。

該系列博文會告訴你如何從入門到進階，一步步地學習Java基礎知識，並上手進行實戰，接著瞭解每個Java知識點背後的實現原理，更完整地瞭解整個Java技術體系，形成自己的知識框架。為了更好地總結和檢驗你的學習成果，本系列文章也會提供部分知識點對應的面試題以及參考答案。

如果對本系列文章有什麼建議，或者是有什麼疑問的話，也可以關注公眾號【Java技術江湖】聯絡作者，歡迎你參與本系列博文的創作和修訂。

# Java 基本資料型別

變數就是申請記憶體來儲存值。也就是說，當建立變數的時候，需要在記憶體中申請空間。

記憶體管理系統根據變數的型別為變數分配儲存空間，分配的空間只能用來儲存該型別資料。

![](https://www.runoob.com/wp-content/uploads/2013/12/memorypic1.jpg)

因此，透過定義不同型別的變數，可以在記憶體中儲存整數、小數或者字元。

## Java 的兩大資料型別:

- 內建資料型別
- 引用資料型別
- - *

### 內建資料型別

Java語言提供了八種基本型別。六種數字型別（四個整數型，兩個浮點型），一種字元型別，還有一種布林型。

**byte：**

- byte 資料型別是8位、有符號的，以二進位制補碼錶示的整數；
- 最小值是 -128（-2^7）；
- 最大值是 127（2^7-1）；
- 預設值是 0；
- byte 型別用在大型陣列中節約空間，主要代替整數，因為 byte 變數佔用的空間只有 int 型別的四分之一；
- 例子：byte a = 100，byte b = -50。

**short：**

- short 資料型別是 16 位、有符號的以二進位制補碼錶示的整數
- 最小值是 -32768（-2^15）；
- 最大值是 32767（2^15 - 1）；
- Short 資料型別也可以像 byte 那樣節省空間。一個short變數是int型變數所佔空間的二分之一；
- 預設值是 0；
- 例子：short s = 1000，short r = -20000。

**int：**

- int 資料型別是32位、有符號的以二進位制補碼錶示的整數；
- 最小值是 -2,147,483,648（-2^31）；
- 最大值是 2,147,483,647（2^31 - 1）；
- 一般地整型變數預設為 int 型別；
- 預設值是 0 ；
- 例子：int a = 100000, int b = -200000。

**long：**

- long 資料型別是 64 位、有符號的以二進位制補碼錶示的整數；
- 最小值是 -9,223,372,036,854,775,808（-2^63）；
- 最大值是 9,223,372,036,854,775,807（2^63 -1）；
- 這種型別主要使用在需要比較大整數的系統上；
- 預設值是 0L；
- 例子： long a = 100000L，Long b = -200000L。
  "L"理論上不分大小寫，但是若寫成"l"容易與數字"1"混淆，不容易分辯。所以最好大寫。

**float：**

- float 資料型別是單精度、32位、符合IEEE 754標準的浮點數；
- float 在儲存大型浮點陣列的時候可節省記憶體空間；
- 預設值是 0.0f；
- 浮點數不能用來表示精確的值，如貨幣；
- 例子：float f1 = 234.5f。

**double：**

- double 資料型別是雙精度、64 位、符合IEEE 754標準的浮點數；
- 浮點數的預設型別為double型別；
- double型別同樣不能表示精確的值，如貨幣；
- 預設值是 0.0d；
- 例子：double d1 = 123.4。

**boolean：**

- boolean資料型別表示一位的資訊；
- 只有兩個取值：true 和 false；
- 這種型別只作為一種標誌來記錄 true/false 情況；
- 預設值是 false；
- 例子：boolean one = true。

**char：**

- char型別是一個單一的 16 位 Unicode 字元；
- 最小值是 \u0000（即為0）；
- 最大值是 \uffff（即為65,535）；
- char 資料型別可以儲存任何字元；
- 例子：char letter = 'A';。

```
//8位
byte bx = Byte.MAX_VALUE;
byte bn = Byte.MIN_VALUE;
//16位
short sx = Short.MAX_VALUE;
short sn = Short.MIN_VALUE;
//32位
int ix = Integer.MAX_VALUE;
int in = Integer.MIN_VALUE;
//64位
long lx = Long.MAX_VALUE;
long ln = Long.MIN_VALUE;
//32位
float fx = Float.MAX_VALUE;
float fn = Float.MIN_VALUE;
//64位
double dx = Double.MAX_VALUE;
double dn = Double.MIN_VALUE;
//16位
char cx = Character.MAX_VALUE;
char cn = Character.MIN_VALUE;
//1位
boolean bt = Boolean.TRUE;
boolean bf = Boolean.FALSE;
```

`127`
    `-128`
    `32767`
    `-32768`
    `2147483647`
    `-2147483648`
    `9223372036854775807`
    `-9223372036854775808`
    `3.4028235E38`
    `1.4E-45`
    `1.7976931348623157E308`
    `4.9E-324`
    ``
    
    `true`
    `false`

### 引用型別

- 在Java中，引用型別的變數非常類似於C/C++的指標。引用型別指向一個物件，指向物件的變數是引用變數。這些變數在宣告時被指定為一個特定的型別，比如 Employee、Puppy 等。變數一旦宣告後，型別就不能被改變了。
- 物件、陣列都是引用資料型別。
- 所有引用型別的預設值都是null。
- 一個引用變數可以用來引用任何與之相容的型別。
- 例子：Site site = new Site("Runoob")。

### Java 常量

常量在程式執行時是不能被修改的。

在 Java 中使用 final 關鍵字來修飾常量，宣告方式和變數類似：

```
final double PI = 3.1415927;
```

雖然常量名也可以用小寫，但為了便於識別，通常使用大寫字母表示常量。

字面量可以賦給任何內建型別的變數。例如：

```
byte a = 68;
char a = 'A'
```

## 自動拆箱和裝箱（詳解）

Java 5增加了自動裝箱與自動拆箱機制，方便基本型別與包裝型別的相互轉換操作。在Java 5之前，如果要將一個int型的值轉換成對應的包裝器型別Integer，必須顯式的使用new建立一個新的Integer物件，或者呼叫靜態方法Integer.valueOf()。
    
    //在Java 5之前，只能這樣做
    Integer value = new Integer(10);
    //或者這樣做
    Integer value = Integer.valueOf(10);
    //直接賦值是錯誤的
    //Integer value = 10;`

在Java 5中，可以直接將整型賦給Integer物件，由編譯器來完成從int型到Integer型別的轉換，這就叫自動裝箱。

`//在Java 5中，直接賦值是合法的，由編譯器來完成轉換`
    `Integer value = 10;`
    `與此對應的，自動拆箱就是可以將包裝型別轉換為基本型別，具體的轉換工作由編譯器來完成。`
    `//在Java 5 中可以直接這麼做`
    `Integer value = new Integer(10);`
    `int i = value;`

自動裝箱與自動拆箱為程式設計師提供了很大的方便，而在實際的應用中，自動裝箱與拆箱也是使用最廣泛的特性之一。自動裝箱和自動拆箱其實是Java編譯器提供的一顆語法糖（語法糖是指在計算機語言中新增的某種語法，這種語法對語言的功能並沒有影響，但是更方便程式設計師使用。透過可提高開發效率，增加程式碼可讀性，增加程式碼的安全性）。

### 實現

在八種包裝型別中，每一種包裝型別都提供了兩個方法：

靜態方法valueOf(基本型別)：將給定的基本型別轉換成對應的包裝型別；

例項方法xxxValue()：將具體的包裝型別物件轉換成基本型別；
下面我們以int和Integer為例，說明Java中自動裝箱與自動拆箱的實現機制。看如下程式碼：

class Auto //code1
    {
    	public static void main(String[] args) 
    	{
    		//自動裝箱
    		Integer inte = 10;
    		//自動拆箱
    		int i = inte;
    
    	//再double和Double來驗證一下
    	Double doub = 12.40;
    	double d = doub;
    	
        }

}
上面的程式碼先將int型轉為Integer物件，再講Integer物件轉換為int型，毫無疑問，這是可以正確執行的。可是，這種轉換是怎麼進行的呢？使用反編譯工具，將生成的Class檔案在反編譯為Java檔案，讓我們看看發生了什麼：

class Auto//code2
    {
      public static void main(String[] paramArrayOfString)
      {
        Integer localInteger = Integer.valueOf(10);
        
    
    int i = localInteger.intValue();
    
     
    
    Double localDouble = Double.valueOf(12.4D);
    double d = localDouble.doubleValue();
    
      }
    }
    
我們可以看到經過javac編譯之後，code1的程式碼被轉換成了code2，實際執行時，虛擬機器執行的就是code2的程式碼。也就是說，虛擬機器根本不知道有自動拆箱和自動裝箱這回事；在將Java原始檔編譯為class檔案的過程中，javac編譯器在自動裝箱的時候，呼叫了Integer.valueOf()方法，在自動拆箱時，又呼叫了intValue()方法。我們可以看到，double和Double也是如此。
實現總結：其實自動裝箱和自動封箱是編譯器為我們提供的一顆語法糖。在自動裝箱時，編譯器呼叫包裝型別的valueOf()方法；在自動拆箱時，編譯器呼叫了相應的xxxValue()方法。

### 自動裝箱與拆箱中的“坑”

在使用自動裝箱與自動拆箱時，要注意一些陷阱，為了避免這些陷阱，我們有必要去看一下各種包裝型別的原始碼。

Integer原始碼

```
public final class Integer extends Number implements Comparable<integer> {
	private final int value;

/*Integer的構造方法，接受一個整型引數,Integer物件表示的int值，儲存在value中*/
 public Integer(int value) {
        this.value = value;
 }
 
/*equals()方法判斷的是:所代表的int型的值是否相等*/
 public boolean equals(Object obj) {
        if (obj instanceof Integer) {
            return value == ((Integer)obj).intValue();
        }
        return false;
}
 
/*返回這個Integer物件代表的int值，也就是儲存在value中的值*/
 public int intValue() {
        return value;
 }
 
 /**
  * 首先會判斷i是否在[IntegerCache.low,Integer.high]之間
  * 如果是，直接返回Integer.cache中相應的元素
  * 否則，呼叫構造方法，建立一個新的Integer物件
  */
 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);
 }

/**
  * 靜態內部類，快取了從[low,high]對應的Integer物件
  * low -128這個值不會被改變
  * high 預設是127，可以改變，最大不超過：Integer.MAX_VALUE - (-low) -1
  * cache 儲存從[low,high]物件的Integer物件
 */
 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) -1);
        }
        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() {}
}
```

以上是Oracle(Sun)公司JDK 1.7中Integer原始碼的一部分，透過分析上面的程式碼，得到：

1）Integer有一個例項域value，它儲存了這個Integer所代表的int型的值，且它是final的，也就是說這個Integer物件一經構造完成，它所代表的值就不能再被改變。

2）Integer重寫了equals()方法，它透過比較兩個Integer物件的value，來判斷是否相等。

3）重點是靜態內部類IntegerCache，透過類名就可以發現：它是用來快取資料的。它有一個陣列，裡面儲存的是連續的Integer物件。
   (a) low：代表快取資料中最小的值，固定是-128。
   
   (b) high：代表快取資料中最大的值，它可以被該改變，預設是127。high最小是127，最大是Integer.MAX_VALUE-(-low)-1，如果high超過了這個值，那麼cache[ ]的長度就超過Integer.MAX_VALUE了，也就溢位了。
   
   (c) cache[]：裡面儲存著從[low,high]所對應的Integer物件，長度是high-low+1(因為有元素0，所以要加1)。

4）呼叫valueOf(inti)方法時，首先判斷i是否在[low,high]之間，如果是，則複用Integer.cache[i-low]。比如，如果Integer.valueOf(3)，直接返回Integer.cache[131]；如果i不在這個範圍，則呼叫構造方法，構造出一個新的Integer物件。

5）呼叫intValue()，直接返回value的值。
透過3）和4）可以發現，預設情況下，在使用自動裝箱時，VM會複用[-128,127]之間的Integer物件。

Integer  a1 = 1;
    Integer  a2 = 1;
    Integer  a3 = new Integer(1);
    //會列印true，因為a1和a2是同一個物件,都是Integer.cache[129]
    System.out.println(a1 == a2);
    //false，a3構造了一個新的物件，不同於a1,a2
    System.out.println(a1 == a3);

### 瞭解基本型別快取（常量池）的最佳實踐

```
//基本資料型別的常量池是-128到127之間。
// 在這個範圍中的基本資料類的包裝類可以自動拆箱，比較時直接比較數值大小。
public static void main(String[] args) {
    //int的自動拆箱和裝箱只在-128到127範圍中進行，超過該範圍的兩個integer的 == 判斷是會返回false的。
    Integer a1 = 128;
    Integer a2 = -128;
    Integer a3 = -128;
    Integer a4 = 128;
    System.out.println(a1 == a4);
    System.out.println(a2 == a3);

Byte b1 = 127;
    Byte b2 = 127;
    Byte b3 = -128;
    Byte b4 = -128;
    //byte都是相等的，因為範圍就在-128到127之間
    System.out.println(b1 == b2);
    System.out.println(b3 == b4);

//
    Long c1 = 128L;
    Long c2 = 128L;
    Long c3 = -128L;
    Long c4 = -128L;
    System.out.println(c1 == c2);
    System.out.println(c3 == c4);

//char沒有負值
    //發現char也是在0到127之間自動拆箱
    Character d1 = 128;
    Character d2 = 128;
    Character d3 = 127;
    Character d4 = 127;
    System.out.println(d1 == d2);
    System.out.println(d3 == d4);

`結果`
    
    `false`
    `true`
    `true`
    `true`
    `false`
    `true`
    `false`
    `true`

Integer i = 10;
    Byte b = 10;
    //比較Byte和Integer.兩個物件無法直接比較，報錯
    //System.out.println(i == b);
    System.out.println("i == b " + i.equals(b));
    //答案是false,因為包裝類的比較時先比較是否是同一個類，不是的話直接返回false.
    int ii = 128;
    short ss = 128;
    long ll = 128;
    char cc = 128;
    System.out.println("ii == bb " + (ii == ss));
    System.out.println("ii == ll " + (ii == ll));
    System.out.println("ii == cc " + (ii == cc));
    
    結果
    i == b false
    ii == bb true
    ii == ll true
    ii == cc true
    
    //這時候都是true，因為基本資料型別直接比較值，值一樣就可以。
```

### 總結：

透過上面的程式碼，我們分析一下自動裝箱與拆箱發生的時機：

（1）當需要一個物件的時候會自動裝箱，比如Integer a = 10;equals(Object o)方法的引數是Object物件，所以需要裝箱。

（2）當需要一個基本型別時會自動拆箱，比如int a = new Integer(10);算術運算是在基本型別間進行的，所以當遇到算術運算時會自動拆箱，比如程式碼中的 c == (a + b);

（3） 包裝型別 == 基本型別時，包裝型別自動拆箱；

需要注意的是：“==”在沒遇到算術運算時，不會自動拆箱；基本型別只會自動裝箱為對應的包裝型別，程式碼中最後一條說明的內容。

在JDK 1.5中提供了自動裝箱與自動拆箱，這其實是Java 編譯器的語法糖，編譯器透過呼叫包裝型別的valueOf()方法實現自動裝箱，呼叫xxxValue()方法自動拆箱。自動裝箱和拆箱會有一些陷阱，那就是包裝型別複用了某些物件。

（1）Integer預設複用了[-128,127]這些物件，其中高位置可以修改；

（2）Byte複用了全部256個物件[-128,127]；

（3）Short服用了[-128,127]這些物件；

（4）Long服用了[-128,127];

（5）Character複用了[0,127],Charater不能表示負數;

Double和Float是連續不可數的，所以沒法複用物件，也就不存在自動裝箱複用陷阱。

Boolean沒有自動裝箱與拆箱，它也複用了Boolean.TRUE和Boolean.FALSE，透過Boolean.valueOf(boolean b)返回的Blooean物件要麼是TRUE，要麼是FALSE，這點也要注意。

本文介紹了“真實的”自動裝箱與拆箱，為了避免寫出錯誤的程式碼，又從包裝型別的原始碼入手，指出了各種包裝型別在自動裝箱和拆箱時存在的陷阱，同時指出了自動裝箱與拆箱發生的時機。

## 基本資料型別的儲存方式

上面自動拆箱和裝箱的原理其實與常量池有關。

### 存在棧中：

public void(int a)
{
int i = 1;
int j = 1;
}
方法中的i 存在虛擬機器棧的區域性變數表裡，i是一個引用，j也是一個引用，它們都指向區域性變數表裡的整型值 1.
int a是傳值引用，所以a也會存在區域性變數表。

### 存在堆裡：

class A{
int i = 1;
A a = new A();
}
i是類的成員變數。類例項化的物件存在堆中，所以成員變數也存在堆中，引用a存的是物件的地址，引用i存的是值，這個值1也會存在堆中。可以理解為引用i指向了這個值1。也可以理解為i就是1.

3 包裝類物件怎麼存
其實我們說的常量池也可以叫物件池。
比如String a= new String("a").intern()時會先在常量池找是否有“a"物件如果有的話直接返回“a"物件在常量池的地址，即讓引用a指向常量”a"物件的記憶體地址。
public native String intern();
Integer也是同理。

下圖是Integer型別在常量池中查詢同值物件的方法。

```
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() {}
}
```

所以基本資料型別的包裝型別可以在常量池查詢對應值的物件，找不到就會自動在常量池建立該值的物件。

而String型別可以透過intern來完成這個操作。

JDK1.7後，常量池被放入到堆空間中，這導致intern()函式的功能不同，具體怎麼個不同法，且看看下面程式碼，這個例子是網上流傳較廣的一個例子，分析圖也是直接貼上過來的，這裡我會用自己的理解去解釋這個例子：

```
[java] view plain copy
String s = new String("1");  
s.intern();  
String s2 = "1";  
System.out.println(s == s2);  
  
String s3 = new String("1") + new String("1");  
s3.intern();  
String s4 = "11";  
System.out.println(s3 == s4);  
輸出結果為：

[java] view plain copy
JDK1.6以及以下：false false  
JDK1.7以及以上：false true
```

![image](https://img-blog.csdn.net/20180422231916788?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2E3MjQ4ODg=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70)

![image](https://img-blog.csdn.net/20180422231929413?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2E3MjQ4ODg=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70)
JDK1.6查詢到常量池存在相同值的物件時會直接返回該物件的地址。

JDK 1.7後，intern方法還是會先去查詢常量池中是否有已經存在，如果存在，則返回常量池中的引用，這一點與之前沒有區別，區別在於，如果在常量池找不到對應的字串，則不會再將字串複製到常量池，而只是在常量池中生成一個對原字串的引用。

那麼其他字串在常量池找值時就會返回另一個堆中物件的地址。

下一節詳細介紹String以及相關包裝類。

具體請見：https://blog.csdn.net/a724888/article/details/80042298

關於Java物件導向三大特性，請參考：

https://blog.csdn.net/a724888/article/details/80033043

## 參考文章

<https:>

## 微信公眾號

### 個人公眾號：黃小斜

黃小斜是跨考軟體工程的 985 碩士，自學 Java 兩年，拿到了 BAT 等近十家大廠 offer，從技術小白成長為阿里工程師。

作者專注於 JAVA 後端技術棧，熱衷於分享程式設計師乾貨、學習經驗、求職心得和程式人生，目前黃小斜的CSDN部落格有百萬+訪問量，知乎粉絲2W+，全網已有10W+讀者。

黃小斜是一個斜槓青年，堅持學習和寫作，相信終身學習的力量，希望和更多的程式設計師交朋友，一起進步和成長！

**原創電子書:**
關注微信公眾號【黃小斜】後回覆【原創電子書】即可領取我原創的電子書《菜鳥程式設計師修煉手冊：從技術小白到阿里巴巴Java工程師》這份電子書總結了我2年的Java學習之路，包括學習方法、技術總結、求職經驗和麵試技巧等內容，已經幫助很多的程式設計師拿到了心儀的offer！

**程式設計師3T技術學習資源：** 一些程式設計師學習技術的資源大禮包，關注公眾號後，後臺回覆關鍵字 **“資料”** 即可免費無套路獲取，包括Java、python、C++、大資料、機器學習、前端、移動端等方向的技術資料。

![](https://img-blog.csdnimg.cn/20190829222750556.jpg)

### 技術公眾號：Java技術江湖

如果大家想要實時關注我更新的文章以及分享的乾貨的話，可以關注我的微信公眾號【Java技術江湖】

這是一位阿里 Java 工程師的技術小站。作者黃小斜，專注 Java 相關技術：SSM、SpringBoot、MySQL、分散式、中介軟體、叢集、Linux、網路、多執行緒，偶爾講點Docker、ELK，同時也分享技術乾貨和學習經驗，致力於Java全棧開發！

（關注公眾號後回覆”Java“即可領取 Java基礎、進階、專案和架構師等免費學習資料，更有資料庫、分散式、微服務等熱門技術學習影片，內容豐富，兼顧原理和實踐，另外也將贈送作者原創的Java學習指南、Java程式設計師面試指南等乾貨資源）

**Java工程師必備學習資源:** 一些Java工程師常用學習資源，關注公眾號後，後臺回覆關鍵字 **“Java”** 即可免費無套路獲取。

![我的公眾號](https://img-blog.csdnimg.cn/20190805090108984.jpg)

</https:></https:></https:></https:></integer>

夯實Java基礎系列2：Java自動拆裝箱裡隱藏的秘密

相關文章