JAVA——八种基本数据类型对应的包装类-CFANZ编程社区

java中为8种基本数据类型又对应准备了8种包装类型。8种包装类属于引用数据类型，父类是Object。

思考：为什么要再提供8种包装类呢？
因为8种基本数据类型不够用。
所以SUN又提供对应的8种包装类型。

引例：

有没有这种需求：调用doSome()方法的时候需要传一个数字进去。
但是数字属于基本数据类型，而doSome()方法参数的类型是Object。
可见doSome()方法无法接收基本数据类型的数字。那怎么办呢？可以传一个数字对应的包装类进去。

        // 把100这个数字经过构造方法包装成对象。
        MyInt myInt = new MyInt(100);
        // doSome()方法虽然不能直接传100，但是可以传一个100对应的包装类型。
        doSome(myInt);

public static void doSome(Object obj){
        //System.out.println(obj);
        System.out.println(obj.toString());    //默认是传一个对象的地址，如果不想传地址需要重写toString方法。
    }

// 这种包装类目前是我自己写的。实际开发中我们不需要自己写。
// 8种基本数据类型对应的8种包装类，SUN公司已经写好了。我们直接用。
public class MyInt {
    int value;

    public MyInt() {
    }

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

    @Override
    public String toString() {
        return String.valueOf(value);
    }
}

以上包装类为自己手写，但SUN公司已经写好了，直接调用即可。

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）

以上八种包装类中，重点以java.lang.Integer为代表进行学习，其它的类型照葫芦画瓢就行。

八种包装类中其中6个都是数字对应的包装类，他们的父类都是Number，可以先研究一下Number中公共的方法：

public abstract class Number implements java.io.Serializable { . . . }

Number是一个抽象类，无法实例化对象。

将基本数据类型--(转换为)->引用数据类型（装箱）
将引用数据类型--(转换为)->基本数据类型（拆箱）

// 123这个基本数据类型，进行构造方法的包装达到了：基本数据类型向引用数据类型的转换。
// 基本数据类型 -(转换为)->引用数据类型（装箱）
Integer i = new Integer(123);

// 将引用数据类型--(转换为)-> 基本数据类型
float f = i.floatValue();
System.out.println(f); //123.0

// 将引用数据类型--(转换为)-> 基本数据类型（拆箱）
int retValue = i.intValue();
System.out.println(retValue); //123

byte byteValue() 以 byte 形式返回指定的数值。
abstract double doubleValue()以 double 形式返回指定的数值。
abstract float floatValue()以 float 形式返回指定的数值。
abstract int intValue()以 int 形式返回指定的数值。
abstract long longValue()以 long 形式返回指定的数值。
short shortValue()以 short 形式返回指定的数值。
这些方法其实所有的数字包装类的子类都有，这些方法是负责拆箱的。

Integer构造方法

Integer构造方法有两个：

Integer(int);
Integer(String);

        // Java9之后不建议使用这个构造方法了。出现横线表示已过时。
        // 将数字100转换成Integer包装类型（int --> Integer）
        Integer x = new Integer(100);
        System.out.println(x);

        // 将String类型的数字，转换成Integer包装类型。（String --> Integer）
        Integer y = new Integer("123");
        System.out.println(y);

        // double -->Double
        Double d = new Double(1.23);
        System.out.println(d);

        // String --> Double
        Double e = new Double("3.14");
        System.out.println(e);

通过包装类的常量获取最大值和最小值

    System.out.println("int的最大值：" + Integer.MAX_VALUE);
    System.out.println("int的最小值：" + Integer.MIN_VALUE);
    System.out.println("byte的最大值：" + Byte.MAX_VALUE);
    System.out.println("byte的最小值：" + Byte.MIN_VALUE);

（不必记忆了）

自动装箱、拆箱

好消息：在java5之后，引入了一种新特性，自动装箱和自动拆箱

自动装箱：基本数据类型自动转换成包装类。
自动拆箱：包装类自动转换成基本数据类型。

有了自动拆箱之后，Number类中的方法就用不着了！

自动装箱和自动拆箱的好处？方便编程！

        // 900是基本数据类型
        // x是包装类型
        // 基本数据类型 --(自动转换)--> 包装类型：自动装箱
        Integer x = 900;
        System.out.println(x);//900

        // x是包装类型
        // y是基本数据类型
        // 包装类型 --(自动转换)--> 基本数据类型：自动拆箱
        int y = x;
        System.out.println(y);//900

在进行+ - * /运算时会自动进行拆箱

// z是一个引用，z是一个变量，z还是保存了一个对象的内存地址。
   Integer z = 1000; // 等同于：Integer z = new Integer(1000);
// 分析为什么这个没有报错呢？
// +两边要求是基本数据类型的数字，z是包装类，不属于基本数据类型，这里会进行自动拆箱。将z转换成基本数据类型
// 在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

Integer非常重要的面试题

        Integer a = 128;
        Integer b = 128;
        System.out.println(a == b); //false

        Integer x = 127;
        Integer y = 127;
        // == 永远判断的都是两个对象的内存地址是否相同。
        System.out.println(x == y); //true

java中为了提高程序的执行效率，将[-128到127]之间所有的包装对象提前创建好，
放到了一个方法区的“整数型常量池”当中了，目的是只要用这个区间的数据不需要
再new了，直接从整数型常量池当中取出来（提高效率）。

原理：x变量中保存的对象的内存地址和y变量中保存的对象的内存地址是一样的。

源码注释：

Cache to support the object identity semantics of autoboxing for values between -128 and 127 (inclusive) as required by JLS.

Integer常用方法

Integer(int value);

(现在可以自动装箱拆箱，这种方法有些过时)

        // 手动装箱
        Integer x = new Integer(1000);

        // 手动拆箱。
        int y = x.intValue();
        System.out.println(y);

static int parseInt(String s);

String -转换-> int

        //网页上文本框中输入的100实际上是"100"字符串。后台数据库中要求存储100数字，此时java程序需要将"100"转换成100数字。
        int retValue = Integer.parseInt("123"); // String -转换-> int
        //int retValue = Integer.parseInt("中文"); // NumberFormatException
        System.out.println(retValue + 100);

常见的异常（目前所学）

空指针异常：NullPointerException
类型转换异常：ClassCastException
数组下标越界异常：ArrayIndexOutOfBoundsException
数字格式化异常：NumberFormatException

数字格式化异常

编译的时候没问题，一切符合java语法，运行时会不会出问题呢？

不是一个“数字”可以包装成Integer吗？不能。运行时出现异常。

Integer a = new Integer("中文");    //java.lang.NumberFormatException

总结

String int Integer之间相处转化

        // String --> int
        int i1 = Integer.parseInt("100"); // i1是100数字
        System.out.println(i1 + 1); // 101

        // int --> String
        String s2 = i1 + ""; // "100"字符串
        System.out.println(s2 + 1); // "1001"

        // int --> Integer
        // 自动装箱
        Integer x = 1000;

        // Integer --> int
        // 自动拆箱
        int y = x;

        // String --> Integer
        Integer k = Integer.valueOf("123");

        // Integer --> String
        String e = String.valueOf(k);