Java——包装类

最新推荐文章于 2025-06-19 02:11:42 发布

原创最新推荐文章于 2025-06-19 02:11:42 发布 · 144 阅读

0 ·

CC 4.0 BY-SA版权

JavaSE 专栏收录该内容

49 篇文章

订阅专栏

包装类——将基本数据类型封装到类中

1.分类

a.对象型包装类(Object的直接子类):Boolean、Character(char)；

b.数值型包装类(Number的直接子类)，存在数值转换异常: Byte、Double、Short、Long、Integer(int)、Float；

2.装箱与拆箱

基本数据类型与相应包装类的数据处理

装箱：将基本数据类型变为包装类对象，利用每个包装类提供的构造方法实现装箱处理。
拆箱：将包装类中包装的基本数据类型取出。利用Number类中提供的**Value( )实现拆箱处理。
意义：为了能够让基本数据类型能够赋值给引用数据类型（Object），衍生引用类型。

public class Test1 {
    public static void main(String[] args) {
        //包装 —— 装箱
        Object obj =new IntWrapper(10);
        System.out.println(obj);    //IntWrapper{value=10}

        IntWrapper intWrapper = (IntWrapper)obj;
        //拆箱
        int intValue = intWrapper.getValue();
        System.out.println(intValue);   //10
    }
}

class IntWrapper{
    private final int value;

    public IntWrapper(int value){
        this.value=value;
    }

    public int getValue(){
        return this.value;
    }

    @Override
    public String toString() {
        return "IntWrapper{" +
                "value=" + value +
                '}';
    }
}

代码示例：

public class PackageTest2 {
    public static void main(String[] args) {
        //手工装箱
        Integer i1 = new Integer(10);  //10->装箱->i1
        //手工拆箱
        int result = i1.intValue();    //i1->拆箱->10
        System.out.println(result+10);   //20

        //JDK1.5之后
        //自动装箱
        Object i2=10;  //对10new一个Integer对象，赋给i2
        //自动拆箱
        int result2 =(int)i2;
        System.out.println(result2);    //10
        
        Integer i3=25;
        //i3.intValue()后进行运算
        System.out.println(++i3*5);  //55

        System.out.println(i1==i2);  //false  比较的是i1、i2的地址
        System.out.println(i1.equals(i2));  //true  比较的是i1、i2的值
    }
}

对于Integer var = ？在-128 至 127 范围内（左闭右闭）的赋值，Integer 对象是在Integer常量池产生，会复用已有对象，这个区间内的 Integer 值可以直接使用==进行判断。除此之外的所有数据，都会在堆上产生，并不会复用已有对象。

练习：

public class PackageTest2 {
    public static void main(String[] args) {
        //基于String赋值的方式 -> 内存池
        //Integer并不是直接跟内存有关，而是Integer内部做了缓存
        Integer i1 = 10;  //自动装箱    new Integer() -> Integer.valueOf(i1);
        Integer i2 = 10;

        //用不到缓存
        Integer i3 = new Integer(10);
        Integer i4 = new Integer(10);

        //超出范围，用不到缓存
        Integer i5 = 200;
        Integer i6 = 200;

        System.out.println(i1 == i2);  //true
        System.out.println(i1 == i3);  //false
        System.out.println(i3 == i4);  //false
        //
        System.out.println(i5 == i6);  //false

        System.out.println(i1.equals(i2));  //true
        System.out.println(i1.equals(i3));  //true
        System.out.println(i3.equals(i4));  //true
        System.out.println(i5.equals(i6));  //true

        //IntegerCache，用到了缓存
        Integer j = Integer.valueOf(127);
        Integer k = Integer.valueOf(127);
        System.out.println(j == k);   //true

        Integer j1 = Integer.valueOf(200);
        Integer k1 = Integer.valueOf(200);
        System.out.println(j1 == k1);  //false
    }
}

所有相同类型的包装类对象之间的值比较，全部使用equals方法比较。
使用int还是Integer?

【强制】所有的 POJO 类（简单Java类，Bean）属性必须使用包装数据类型。
【强制】RPC 方法（远程方法调用）的返回值和参数必须使用包装数据类型。
【建议】所有的局部变量使用基本数据类型。

3.字符串与基本类型的转换

3.1 将字符串转为基本类型（静态方法）

调用各个包装类.parse**(String str)，eg：Integer.parseInt(String str)

代码示例：

public class PackageTest3 {
    public static void main(String[] args) {
        String str="123";
        int i=Integer.parseInt(str);   //默认将123当作十进制
        //radix：当前转换的字符表示的数字的进制
        int i1=Integer.parseInt(str,16);  //将123当作十六进制
        //Java表示的进制默认为十进制
        System.out.println(i+2);   //125
        System.out.println(i1);    //291  291的十六进制为123

        //boolean  当前转换的字符串只有为“true”，才返回true（忽略大小写），否则返回false
        System.out.println(Boolean.parseBoolean("true"));  //true
        System.out.println(Boolean.parseBoolean("TrUe"));  //true
        System.out.println(Boolean.parseBoolean("false"));  //false
        System.out.println(Boolean.parseBoolean("123"));   //false
        
        String str1="123.25";
        double i2=Double.parseDouble(str1);
        System.out.println(i2+5);  //128.25

    }
}

3.2 将基本类型转为字符串
方法：

a. ""+基本类型

b.使用String类的valueOf（基本类型），此方法不产生垃圾空间。

public class PackageTest3 {
    public static void main(String[] args) {
        String str1=""+123;
        System.out.println(str1.length());  //3

        String str2=String.valueOf(true);
        System.out.println(str2.length());  //4
    }
}

拓展：

public class PackageTest3 {
    public static void main(String[] args) {
        int a=100_000;  //100000  _连接较长的数字
        int b=0b0110;  //6  二进制表示方式0b****
        System.out.println(a+b);  //10006
    }
}

2.Java中参数传递：值传递（传递的是栈空间的内容）

基本数据类型存放在栈空间->值（栈空间的内容）

引用数据类型变量存放于栈空间->引用的对象所在的堆空间的地址（栈空间的内容），堆空间存放的是数据

public class Test1 {
    public static void main(String[] args) {
        int a = 20;
        char[] ch = new char[]{'a', 'b'};  //1
        swap(a, ch);
        System.out.println(a);    //20  20复制后赋给a，将20传递给b，b的值变为10，a不受影响
        //ch的地址复制后赋给ch1，ch的地址传递给chars，chars[0]='A',则ch[0]='A'
        System.out.println(java.util.Arrays.toString(ch));  //[A,b]
    }
    public static void swap(int b,char[] ch1){
        b=10;
        //chars指向ch1的地址
        char[] chars=ch1;  //1
        chars[0]='A';
        //ch1指向新的栈空间，不影响原来地址的内容
        ch1=new char[]{'C','D'};  //2
    }
}