夯實Java基礎系列2:Java基本數據類型,以及自動拆裝箱里隱藏的秘密
- 2019 年 10 月 7 日
- 筆記
目錄
- Java 基本數據類型
- Java 的兩大數據類型:
- 內置數據類型
- 引用類型
- Java 常量
- 自動拆箱和裝箱(詳解)
- 實現
- 自動裝箱與拆箱中的「坑」
- 了解基本類型快取(常量池)的最佳實踐
- 總結:
- 基本數據類型的存儲方式
- 存在棧中
- 存在堆里
- 參考文章
- 微信公眾號
- Java技術江湖
- 個人公眾號:黃小斜
- Java 的兩大數據類型:
title: 夯實Java基礎系列2:Java自動拆裝箱里隱藏的秘密
date: 2019-9-2 15:56:26 # 文章生成時間,一般不改
categories:
- Java技術江湖
- Java基礎 tags:
- Java基本數據類型
- Java基礎 tags:
本系列文章將整理到我在GitHub上的《Java面試指南》倉庫,更多精彩內容請到我的倉庫里查看
喜歡的話麻煩點下Star哈
文章首發於我的個人部落格:
www.how2playlife.com
本文是微信公眾號【Java技術江湖】的《夯實Java基礎系列博文》其中一篇,本文部分內容來源於網路,為了把本文主題講得清晰透徹,也整合了很多我認為不錯的技術部落格內容,引用其中了一些比較好的部落格文章,如有侵權,請聯繫作者。
該系列博文會告訴你如何從入門到進階,一步步地學習Java基礎知識,並上手進行實戰,接著了解每個Java知識點背後的實現原理,更完整地了解整個Java技術體系,形成自己的知識框架。為了更好地總結和檢驗你的學習成果,本系列文章也會提供每個知識點對應的面試題以及參考答案。
如果對本系列文章有什麼建議,或者是有什麼疑問的話,也可以關注公眾號【Java技術江湖】聯繫作者,歡迎你參與本系列博文的創作和修訂。
TOC
<!– more –>
Java 基本數據類型
變數就是申請記憶體來存儲值。也就是說,當創建變數的時候,需要在記憶體中申請空間。
記憶體管理系統根據變數的類型為變數分配存儲空間,分配的空間只能用來儲存該類型數據。
因此,通過定義不同類型的變數,可以在記憶體中儲存整數、小數或者字元。
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.cachei-low。比如,如果Integer.valueOf(3),直接返回Integer.cache131;如果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
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://www.runoob.com/java/java-basic-datatypes.html
https://www.cnblogs.com/zch1126/p/5335139.html
https://blog.csdn.net/jreffchen/article/details/81015884
https://blog.csdn.net/yuhongye111/article/details/31850779