Java常用类-包装类

2022/6/16 1:22:39

本文主要是介绍Java常用类-包装类,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

包装类

​ Java中的基本类型功能简单,不具备对象的特性,为了使基本类型具备对象的特性,所以出现了包装类,就可以像操作对象一样操作基本类型数据;包装类不是为了取代基本数据类型,而是在数据类型需要使用对象表示的时候,才使用包装类;

1.包装类的继承关系

2.基本数据类型和包装类的关系

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

提示:所有的包装类+String类都是final修饰的,代表不可以被继承;

3.包装类对应的属性定义(以Integer为例)

System.out.println(Integer.SIZE); //位数 32位
System.out.println(Integer.BYTES); //字节数 4字节
System.out.println(Integer.MAX_VALUE); //最大值 2^32-1 2147483647
System.out.println(Integer.MIN_VALUE); //最小值 -2^32  -2147483648

4.包装类型的基本操作

基本类型,包装类型,String类型的相互转换

序号 类型转换 方法
1 int->Integer new Integer(primitive)
2 Integer->int Integer 对象.xxxValue()
3 Integer->String Integer 对象.toString()
4 String->Integer new Integer(String str)
5 int->String String.valueOf(primitive)
6 String->int Integer.paseXxx(String str)

4.1 int->Integer new Integer(primitive)

所有包装类都可以与之对应的基本数据类型作为参数,来构造他们的实例
//1基本数据类型 ->包装类
//1.1byte->Byte
byte b = 1;
Byte byte1 = new Byte(b);
//1.2 char->Character
Character character1 = new Character('a');
//1.3 short->Short
short s = 2;
Short short1 = new Short(s);
//1.4 int Integer
Integer integer1 = new Integer(4);
//1.5 long->Long
Long long1 = new Long(8);
//1.6 float->Float
Float float1 = new Float((float) 4.0);
//1.7 double->Double
Double double1 = new Double(8.0);
//1.8 boolean->Boolean
Boolean boolean1 = new Boolean(true);

注意:类型一定要对应;

Integer.valueOf(int a)

Integer integer5 = Integer.valueOf(200);
System.out.println(integer5);

源码

//也是new 的对象 跟new Integer(primitive)一样
public static Integer valueOf(int i) {
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
}

4.2 Integer->int Integer 对象.xxxValue()

对象.xxxValue(),将包装类转换为对应的基本数据类型值,所有包装类都有
 Integer integer2 = new Integer(4);
 int int2 = integer2.intValue();
 System.out.println(int2); //4

4.3 Integer->String Integer 对象.toString()

对象.toString() 将基本数据烈性转换为String类型
Integer integer3 = new Integer(4);
String string3 = integer3.toString();
System.out.println(string3); //4

4.4 String->Integer new Integer(String str)

除Character类外,其他包装类可将一个字符作为参数构造他们的实例,前提:字符串内容必须跟对应包装类匹配
Integer integer4 = new Integer("4");
System.out.println(integer4);

Character类型 没有支持字符串的构造方法,因为字符串包含多个字符,Character只包含一个字符

Character a = new Character("aa"); //会报错

Integer.valueOf(String s)

源码

public static Integer valueOf(String s) throws NumberFormatException {
    return Integer.valueOf(parseInt(s, 10)); 
    //先匹配数字,再调用new Integer
}

4.5 int->String String.valueOf(primitive)

基本类型转String类型
String string5 = String.valueOf(100);
System.out.println(string5); //100

String类的valueOf方法

4.6 String->int Integer.paseXxx

直接将字符串转换为对应的基本数据类型Character除外
int int6 = Integer.parseInt("123");
System.out.println(int6); //123

5.装箱,拆箱

5.1装箱

自动装箱,底层就是自动调用valuesOf方法实现
Integer integer5_1_1 = 400;
//实际上,系统执行了Integer obj = Integer.valueOf(400);
System.out.println(integer5_1_1); //400

5.2拆箱

Integer integer5_2_1 = new Integer(500);
System.out.println(integer5_2_1+integer5_2_1); //1000
//实际上执行了integer5_2_1.intValue()+integer5_2_1.intValue();   

6.包装类的缓存

6.1包装类的缓存范围

包装类 缓存范围
Byte 全部缓存(-128—127)
Character <=127缓存
Short -128—127缓存
Integer -128—127缓存
Long -128—127缓存
Float 没有缓存
Double 没有缓存
Boolean 全部缓存(true,false)

6.2案例

Integer integer8_1 = 120;
Integer integer8_2 = 120;
System.out.println(integer8_1 == integer8_2); //true

Integer integer9_1 = 130;
Integer integer9_2 = 130;
System.out.println(integer9_1 == integer9_2); //false
//Integer类中有一个静态内部类IntegerCache,缓存了-128到127之间所有int数字的Integer对象
//120 在-128-127之间 ,产出的对象是从IntegerCache中取出来的
//其他包装类也是一样

6.3垃圾回收相关

Integer integer6_3_1 = 100;
integer6_3_1 = null; //integer6_3_1 不会被垃圾回收器回收
//这里虽然integer6_3_1被赋予null,但它之前指向的是cache中的Integer对象,而cache没有被赋null,所以Integer(100)这个对象还是存在

Integer integer6_3_2 = 128;
integer6_3_2 = null;//integer6_3_2 会被垃圾回收器回收
//integer6_3_2不是缓存中的对象,被赋予null后会被垃圾回收器回收


这篇关于Java常用类-包装类的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!


扫一扫关注最新编程教程