第47節：Java當中的基本類型包裝類

Java當中的基本類型包裝類

01

基本數據類型對象的包裝類

什麼是基本數據類型對象包裝類呢？就是把基本數據類型封裝成對象，這樣就可以提供更多的操作基本數值的功能了。

基本數據類型對象的包裝類8個：

java.lang

類 Integer

java.lang.Object
 -> java.lang.Number
  -> java.lang.Integer

public final class Integer
extends Number
implements Comparable<Integer>

Integer類 是將一個基本類型為int的值包裝成為對象的包裝類。
Integer類型的對象中包含了一個int類型的欄位。

基本數據類型對象的包裝類，就是為了提供更多的操作方法，這裡的Integer類中Java提供了多個方法，而且Integer類能夠在int類型和String類型之間互相進行轉換，還可以處理一些int類型有關一些常量和方法等。

一些常量：

一些構造方法：

02

基本數據類型對象包裝類：用於基本數據和字元串之間的轉換。

parseInt(String s)是將字元串參數作為有符號的十進位整數進行解析。

xxx.parseXxx(string);
註意只有Character沒有解析的方法，我們舉個例子：int parseInt(string); -> byte parseByte(string); -> boolean parseBoolean(string);

System.out.println("12"+3);
// 結果為123
System.out.println(Integer.parseInt("12")+3);
// 結果為 15

parseInt

public static int parseInt(String s) throws NumberFormatException
這個方法是將字元串參數作為有符號的十進位整數進行解析
參數s：包含解析的int表現形式的String。
返回為：帶有符號的十進位的整數值。
拋出為NumberFormatException：如果字元串不含有可解析的整數。

異常：

System.out.println(Integer.parseInt("a12")+3);
// 拋出為NumberFormatException

System.out.println("a12",6);
// 這種方法將其他進位轉換為別的進位數

基本數值轉換為字元串：

1. 12+“ ”;
2. String.valueOf(12);
3. Integer.toString(int);

基本數據類型轉換為包裝類對象

Integer i = new Integer(2);
Integer i2 = new Integer("2");
Integer i3 = Integer.valueOf(2);

包裝類的對象轉換為基本數據類型值

// intValue()：為以int類型返回該Integer的值
Integer i = new Integer(2);
int num = i.intValue();

基本數據類型包裝類的自動裝箱和拆箱

int i = 3;
Integer i = new Integer(3);
// 為裝箱
在JDK1.5後，java提供了一個包裝類的新的特性，為自動裝箱。自然有自動拆箱咯~
Integer i = 3;
// 這樣表示即為新特性，自動裝箱。
// 一般我們是這樣寫
Integer i = Integer.valueOf(3);
// 如今
Integer i = 3; 
// 系統會為它自動裝箱
i = i + 2;
// 此時等於這樣
i = i.intValue() + 2; // 等同於 i = Integer.valueOf(i.intValue() + 2);
// 為自動拆箱 i.intValue()，然後再次裝箱即可

Integer包裝類，自動裝箱和自動拆箱的重點

為JDK1.5前，沒有新特性

Integer a = new Integer(3); // 為手動裝箱
Integer b = new Integer(3); // 為手動裝箱
System.out.println(a == b); // 結果為：false
System.out.println(a.equals(b)); // 結果為：true

自動裝箱和自動拆箱新特性

Integer x = 100; // 自動
Integer y = 100; // 自動
System.out.println(x == y); // 結果為 true
System.out.println(x.equals(y)); // 結果為 true

Integer x = 200; // 自動
Integer y = 200; // 自動
System.out.println(x == y); // 結果為 false
System.out.println(x.equals(y)); // 結果為 true

Integer integer1 = 127;
Integer integer2 = 127;
System.out.println(integer1 == integer2);
// true
Integer integer1 = 128;
Integer integer2 = 128;
System.out.println(integer1 == integer2);
// false

Integer x = 127;
Integer y = 127;
System.out.println(x==y); // 結果為true
System.out.println(x.equals(y)); // 結果為true

Integer x = 128;
Integer y = 128;
System.out.println( x == y); // 結果為false
System.out.println( x.equals(y) ); // 結果為true

因為在JDK1.5中，Java面對在 -128~127 之間的Integer的值，用的是原生基本數據類型int，會在記憶體中共用，不會再新創建對象空間。就是在這個範圍之間的Integer值比較“==”，是進行int原生數據類型的比較，超出範圍的比較，就會創建新的對象空間。

有人問這究竟是為啥呢？你問我？

這個是jdk1.5之後的新特性，規定是數值在byte範圍內不會創建新的對象空間，而是用原來的空間，這樣就可以節省記憶體空間了哦~

03

案例

// 一堆字元串，定義字元串數字的變數
String nums = "12 34 56 23 7 83";
// 字元串中數值的排序，定義一個方法為排序所要定義的字元串數字的變數，完成任務
nums  = sortNumsString(nums);
// 列印排序後的字元串
System.out.println("nums" + nums);

// 靜態String類型
public static String sortNumsString(String numsString){
 // 空格分割
 String[] strs = numsString.split(" ");
 // 字元串數組轉換int數組，定義了一個方法parseIntArray()
 int[] nums = parseIntArray(strs);
 // 對數組進行排序
 Arrays.sort(nums);
 // 將數組轉換為字元串
 return toString(nums);
}

// 字元串數組轉換int數組
private static int[] parseIntArray(String[] strs){
 // 定義int數組
 int[] arr = new int[strs.length];
 // 遍歷字元串數組
 for(int i = 0; i < strs.length; i++){
  arr[i] = Integer.parseInt[strs[i]);
 }
 return arr;
}

// 將數組轉換為字元串
private static String toString(int[] nums){
 // 創建StringBuilder對象
 StringBuilder sb = new StringBuilder(); 
// 迴圈添加
 for(int i = 0; i < nums.length; i++){
  if(i != nums.length-1){
   sb.append(nums[i]+" ");
  }else{
   sb.append(nums[i]);
  }
 }
 // 返回sb.toString();方法
 return sb.toString();
}

往後餘生，唯獨有你
簡書作者：達叔小生
90後帥氣小伙，良好的開發習慣；獨立思考的能力；主動並且善於溝通
簡書博客： https://www.jianshu.com/u/c785ece603d1

結語

• 下麵我將繼續對 其他知識 深入講解 ，有興趣可以繼續關註
• 小禮物走一走 or 點贊