java byte 包装类_java中的包装类详解

包装类出现原因

简单来说，就是让基本数据类型的变量具有类中对象的特征。

基本数据类型，使用起来非常方便，但是没有对应的方法来操作这些基本类型的数据，可以使用一个类，把基本数据类型的数据装起来，这个类叫做包装类(wrapper)。这样我们可以调用类中的方法。

开发中，用的最多的是字符串变为基本数据类型。

8种基本数据类型对应包装类：可以看到除了int和char类型，其它都是首字母大写。

基本数据类型

包装类

byte

Byte

short

Short

int

Integer

long

Long

float

Float

double

Double

char

Character

boolean

Boolean

装箱

基本类型->包装类

通过包装类的构造器实现

int i = 500;

Integer t = new Integer(i);

通过字符串参数构造包装类对象

Float f = new Float("4.56");

Long l = new Long("wer");//NumberFormatException

自动装箱

Integer i = 100;

相当于编译器自动作以下的语法编译：Integer i = Integer.valueOf(100);

拆箱

包装类->基本类型

调用包装类中的.xxxValue()方法

Integer t = 128; // 此时t就是一个包装类

System.out.println(t.intValue());//128

自动拆箱

Integer i = 10; //自动装箱

int t = i; //自动拆箱，实际上执行了 int t = i.intValue();

JDK1.5之后，支持自动装箱，自动拆箱。但类型必须匹配。

类型间转换

基本数据类型->String类

String类的valueOf()方法：String fs = String.valueOf(2.34f);

更直接的方式5+""

String类->基本数据类型

通过包装类的构造器实现：int i = new Integer("12")

通过调用包装类的parseXxx(字符串)该静态方法：Float f = Float.parseFloat("12.1");

包装类->String类

包装类对象的toString()方法

Integer t = new Integer(100);

String s = t.toString();// s = "100";

//将数字转换为字符串

调用包装类的toString(形参)方法

String s1 = Integer.toString(314); // s1= "314" 将数字转换成字符串。

String类->包装类

通过字符串参数

Float f = new Float("3.14f");

int、Integer之间的比较

总结

int 是基本数据类型

Integer是包装类，Integer i = num，自动装箱而num值的范围如果取(-128<=num<=127)，那么就在IntegerCache中直接取已经创建好的对象，不会创建新的Integer对象

new Integer() 在堆中创建新的Integer对象

具体请看下面的例子：

Integer和int比较

@Test

public void testInteger(){

//int 和 Integer在进行比较的时候，Integer会进行拆箱，转为int值与int进行比较

Integer i = 10;

int i1 = 10;

System.out.println(i == i1); //true

Integer i2 = 300;

int i3 = 300;

System.out.println(i2 == i3); //true

}

Integer与Integer比较

@Test

public void testInteger2(){

/*

* Integer与Integer比较的时候，由于直接赋值的时候会进行自动的装箱，

* 那么这里就需要注意两个问题，

* 一、-128<= x<=127的整数，将会直接缓存在IntegerCache中，

* 那么当赋值在这个区间的时候，不会创建新的Integer对象，

* 而是从缓存中获取已经创建好的Integer对象。

* 二、当大于这个范围的时候，直接new Integer来创建Integer对象。

* */

System.out.println("Integer与Integer比较");

Integer i6 = 128;

Integer i7 = 128;

System.out.println(i6 == i7);//false

// i6自动装箱产生的Integer对象，大小超过了-128——127的范围，这里会直接创建该对象：new Integer(128)

// i7同理。它们在堆中的地址是不同的，因此false.

Integer i4 = 1;

Integer i5 = 1;

System.out.println(i4 == i5); //true

// i4、i5都是从IntegerCache中取出来的对象，故true;

Integer i8 = 127;

Integer i9 = 127;

System.out.println(i8 == i9);//true

// i8、i9都是从IntegerCache中取出来的对象，故true;

Integer i10 = new Integer(127);

Integer i11 = 127;

System.out.println(i10 == i11); //false

// i10是创建的一个Integer的对象，取值是127

// i11是进行自动装箱后生成的Integer对象，在-128——127之间，是直接从缓存IntegerCache中取出来的对象

// i10是自己new出来的对象，i11是从IntegerCache中取的对象，地址不同，故false.

Integer i12 = new Integer(128);

Integer i13 = 128;

System.out.println(i12 == i13);//false

// 说明：i12是创建的一个Integer的对象，取值是128

// i13 是进行自动装箱的实例，这里超出了-128——127的范围，创建了新的Integer对象。

// 二者存储在堆中，分配的地址不同，因此用==判断时，由于对象的地址不同，所以false.

}

}

参考链接

标签：java,String,包装,数据类型,int,详解,new,Integer

来源： https://www.cnblogs.com/benjieqiang/p/11305777.html