Java当中的基本类型包装类

01

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

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

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

基本数据类型	包装类
byte	Byte
short	Short
int	Integet
long	Long
float	Float
double	Double
boolean	Boolean
char	character

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类型有关一些常量和方法等。

一些常量：

常量	返回的类型
MAX_VALUE	`static int` 为返回的是静态整数类型，表示为`int`类型的最大值
MIN _VALUE	`static int` 为返回的是静态整数类型，表示为`int`类型的最小值
SIZE	`static int` 为返回的是静态整数类型，表示`int`值的比特位数
TYPE	`static Class<Integer>` 表示返回基本类型`Int`的`Class`实例

一些构造方法：

方法	说明
Integer(int value)	构造一个`Integer`对象，表示指定`int`的值
Integer(String s)	构造一个分配的`Integer`对象，表示`String`参数所指的int值

方法	说明
decode(String nm)	`static Integer`该方法可以将`String`解码为`Integer`
doubleValue()	返回为`double`类型是以`double`类型返回该`Integer`的值
equals(Object obj)	返回`boolean`类型比较此对象与指定对象
floatValue()	返回`float`类型以`float`类型返回该`Integer`的值
getInteger(String nm)	返回的是 `static Integer`，确定具有指定名称的系统属性的整数值
getInteger(String nm, int val)	返回的是`static Integer`，确定具有指定名称的系统属性的整数值
getInteger(String nm, Integer val)	返回的是`static Integer`，返回具有指定名称的系统属性的整数值
hashCode()	返回此`Integer`的哈希码
intValue()	返回`int`类型以`Int`类型返回给`Integer`的值
longValue()	返回`long`类型以`long`类型返回该`Integer`的值
toBinaryString(int i)	返回`static String`类型，以二进制无符号整数形式返回一个整数参数的字符串表示形式
toHexString(int i)	返回`static String`类型，以十六进制无符号整数形式返回一个整数参数的字符串表示形式
toOctalString(int i)	返回`static String`类型，以八进制无符号整数形式返回一个整数参数的字符串表示形式
toString()	返回`String`类型，返回一个表示该`Integer`值的`String`对象
toString(int i)	返回类型为`static String`，返回一个表示指定整数的`String`对象
toString(int i, int radix)	返回类型为`static String`，返回用第二个参数指定基数表示的第一个参数的字符串形式
valueOf(int i)	返回类型为`static Integer`，返回一个表示指定的`int`值的`Integer`实例
valueOf(String s)	返回类型为`static Integer`，返回一个表示指定的`String`值的`Integer`实例

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);

// 这种方法将其他进制转换为别的进制数

基本数值转换为字符串：

12+“ ”;
String.valueOf(12);
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 点赞