Java当中的基本类型包装类

时间：2021-06-22 17:21:19

Java当中的基本类型包装类

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

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

基本数值转换为字符串：

  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 点赞

相关文章