装箱与拆箱简介

装箱与拆箱

要点

1、8种基本数据类型对应的包装类型名是什么?
基本数据类型     包装类型

-------------------------------------
byte            java.lang.Byte (父类Number )
short           java.lang.Short (父类Number )
int             java.lang.Integer (父类Number )
long            java.lang.Long (父类Number )
float           java.lang.Float (父类Number )
double          java.lang.Double (父类Number )
boolean         java.lang.Boolean ( 父类object )
char            java.lang.Character (父类object )

2、八种包装类中其中6个都是数宇对应的包装类,他们的父类都是Number，可以先研究Number中公共的方法:
Number是一个抽象类,无法实例化对象。
Number类中有这样的方法:
byte byteValue() 以byte形式返回指定的数值。
abstract double doubleValue()以 double 形式返回指定的数值。
abstract float floatValue()以 float 形式返回指定的数值。
abstract int intValue()以 int 形式返回指定的数值。
abstract long longValue()以 long 形式返回指定的数值。
short shortValue()以 short 形式返回指定的数值。
这些方法其实所有的数字包装类的子类都有，这些方法是负责折箱的。

实例

public class IntegerTest01{
    public static void main(String[] args) {
        // 123这个基本数据类型,进行构造方法的包装达到了:基本数据类型向引用数据类型的转换。
        //基本数据类型-(转换为)->引用数据类型(装箱)
        Integer i = new Integer( value: 123);//通过构造方法装箱（Java9后该方法已废除）

        //引用数据类型--(转换为)->基本数据类型
        float f = i.floatValue();
        System.out.println(f); //123.0
        //将引用数据类型--(转换为)->基本数据类型(拆箱)
        int retValue = i.intValue();
        System.out.print1n(retValue); //123
    }
}

包装类型的构造方法(查文档)

自动装箱与自动拆箱

要点

java5之后支持自动装箱和自动拆箱
自动装箱：基本数据类型自动转换成包装类
自动拆箱：包装类自动转换成基本数据类型

实例

public class IntegerTest02{
    public static void main(String[] args){
        // 900是基本数据类型
        // x是包装类型
        //基本数据类型--(自动转换)--> 包装类型:自动装箱
        Integer x = 900;
        System.out.print1n(x);
        // x是包装类型
        // y是基本数据类型
        //包装类型--(自动转换)--> 基本数据类型:自动拆箱
        int y= x;
        System.out.print1n(y);

        // z是一个引用,z是一个变量, z还保存了一个对象的内存地址。
        Integer z = 1000; //等同于: Integer z = new Integer(1000);
        //分析为什么这个没有报错呢?
        // +两边要求是基本数据类型的数字, z是包装类，不属于基本数据类型,这里会进行自动拆箱。将2转换成基本数据类型
        //在java5之前你这样写肯定编译器报错。
        System.out.println(z + 1); 

        Integer a = 1000; // Integer a = new Integer(1000); a是个引用,保存内存地址指向对象。
        Integer b = 1000; // Integer b = new Integer(1000); b是个引用，保存内存地址指向对象。
        // ==比较的是对象的内存地址, a和b两个引用中保存的对象内存地址不同。
        // ==这个运算符不会触发自动拆箱机制。 (只有+ . * /等运算的时候才会。)
        System.out.println(a==b);//false
    }
}

实例

public class IntegerTest03{
    public static void main(String[] args) {
    Integer a = 128;
    Integer b = 128;
    System.out.println(a == b); //false
    /*
    java中为了提高程序的执行效率,将[ -128到127]之间所有的包装对象提前创建好,
    放到了一个方法区的“整数型常量池”当中了，目的是只要用这个区间的数据不需要再new了,
    直接从整数型常量池当中取出来。

    原理:x变量中保存的对象的内存地址和y变量中保存的对象的内存地址是一样的。
    */
    Integer x = 127;
    Integer y = 127;
    // == 永远判断的都是两个对象的内存地址是否相同。
    System.out.println(x == y); //true
    }
    

内存图（部分）

实例

public class IntegerTest04 {
    
    public static void main(String[] args) {
        //手动装箱
        Integer x = new Integer(value: 1000);
        //手动拆箱。
        int y = x.intValue();
        System.out.print1n(y);
        Integer a = new Integer( s: "123");
        //编译的时候没问题，一切符合java语法，运行时会不会出问题呢?
        //不是一个“数字”可以包装成Integer吗?不能。运行时出现异常。
        // java.lang.NumberFormatException
        //Integer a = new Integer("中文");

        //重点方法
        // static int parseInt(String s)
        //静态方法，传参string，返回int
        //网页上文本框中输入的100实际上是"100"宇符串。后台数据库中要求存储100数字，此时java程序需要将"100"转换成100
        int retValue = Integer.parseInt( s: "123"); // String -转换-> int
        //int retValue = Integer.parseInt("中文"); // NumberFormatException
        System.out.println(retValue + 100);

        //照葫芦画瓢
        double retValue2 = Double. parseDouble( s: "3.14");
        System.out.println(retValue2 + 1); //4. 1000000000010 (精度问题)
        float retValue3 = Float. parseFloat( s: "1.0");
        System.out.println(retValue3 + 1); //2.0
    }
}