第47节：Java当中的基本类型包装类

Java当中的基本类型包装类

01

基本数据类型对象的包装类

什么是基本数据类型对象包装类呢？就是把基本数据类型封装成对象，这样就可以提供更多的操作基本数值的功能了。

基本数据类型对象的包装类8个：

java.lang

类 Integer

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

public final class Integerextends Numberimplements 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);// 结果为123System.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); // 结果为：falseSystem.out.println(a.equals(b)); // 结果为：true

自动装箱和自动拆箱新特性

Integer x = 100; // 自动Integer y = 100; // 自动System.out.println(x == y); // 结果为 trueSystem.out.println(x.equals(y)); // 结果为 true

Integer x = 200; // 自动Integer y = 200; // 自动System.out.println(x == y); // 结果为 falseSystem.out.println(x.equals(y)); // 结果为 true

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

Integer x = 127;Integer y = 127;
System.out.println(x==y); // 结果为trueSystem.out.println(x.equals(y)); // 结果为true

Integer x = 128;Integer y = 128;
System.out.println( x == y); // 结果为falseSystem.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();
}

原文出处：https://www.cnblogs.com/dashucoding/p/9684518.html