Java学习笔记 -八种包装类

包装类存在的意义

• 前几天的作业stack中：void push(Object s);
• 调用：push(100),将基本类型传递给了Object，
• 理论上这种语法显然是不对的，基本类型无法传递给引用数据类型
• 实际上，java将100先“包装“成包装类(自动装箱和拆箱)，才能实现参数传递的

示例（自己写的包装类）：

package com.javase.integer;
//示例：包装类存在的意义：
public class integerTest01 {
    public static void doSome(Object obj){
        System.out.println(obj);
    }
    public static void main(String[] args) {
        MyInt m = new MyInt(100);
        doSome(m);
    }
}

//自己模拟包装类
class MyInt{
    int value;

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

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

java中的八种包装类

• 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.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 integerTest02 {
    public static void main(String[] args) {
        //基本数据类型向引用数据类型转换（手动装箱）
        Integer i = new Integer(123333);

        //引用数据类型向基本数据类型转换（手动拆箱）
        float f = i.floatValue();
        System.out.println(f);
        int retValue = i.intValue();
        System.out.println(retValue);
        //byte类型的范围：-128~127，所以这里数据会表示错误
        byte v = i.byteValue();
        System.out.println(v);

        //使用类名.的方法访问包装类中的常量
        System.out.println("int的最大值： " + Integer.MAX_VALUE);
        System.out.println("int的最大值： " + Integer.MIN_VALUE);
        System.out.println("Byte的最大值： " + Byte.MAX_VALUE);
    }
}

自动拆箱&自动装箱

• 为了方便包装类的使用，所以有了自动拆箱和自动装箱
• 自动装箱：调用valueOf方法
• 自动拆箱：调用intValue...方法

示例：

public class integerTest04 {
    public static void main(String[] args) {
        //自动装箱（常用）
        Integer a = 1000;
        Integer b = 1000;
        Integer x = 127;
        Integer y = 127;
        //自动拆箱
        int value = x;

        //==比较还是对象的内存地址，不会触发自动拆箱
        System.out.println(a == b);          //false
        //java为了提高执行效率，将(-128~127)之间的所有对象都提前创建好，放到方法区“整数型常量池”
        //所以这个区间不需要new对象了，之间从常量池中取出来就行了
        //常量池在类加载时创建:使用静态代码块： static final Integer cache[]
        //缓存机制：节约对象创建的时间
        System.out.println(x == y);        //true
        //但是使用了 + 运算符之后，就会触发自动拆箱，从而转换为基本数据类型进行比较
        System.out.println(a + x == b + y);   //true
    }
}

内存图如下：

包装类的常用方法

public class integerTest03 {
    public static void main(String[] args) {
        //构造方法:Integer(int) or   Integer(String)
        Integer i1 = new Integer(123);
        Integer i2 = new Integer("123");

        //将非数字的字符串转换成Integer会抛出异常
        //数字格式化异常：java.lang.NumberFormatException
        Integer a = new Integer("中文");
        System.out.println(a);

        //重要方法：parseInt...
        //static int parseInt(String s)
        //功能：将字符串转换成数值
        int retValue = Integer.parseInt("12333");
        double retValue2 = Double.parseDouble("3.11");

        System.out.println(retValue + retValue2);

        //其他方法:toBinaryString
        //public static String toBinaryString(int i)
        //功能：十进制转换成二进制字符串
        //类似的转换成其他进制，看参考手册
        System.out.println(Integer.toBinaryString(3));

        //valueOf方法作为了解
        //static Integer valueOf(int i)
        //功能：将int 转化为Integer，有自动装箱，所以几乎不用。
        Integer i3 = Integer.valueOf(100);
        Integer i4 = Integer.valueOf("100");
        System.out.println(i3);
    }
}

String Integer int 三种类型间的转换

示例程序：

public class integerTest03 {
    public static void main(String[] args) {
        //(十分重要)String -> int
        int retValue = Integer.parseInt("123");

        //int -> String
        String s = String.valueOf(123);

        //int -> Integer
        Integer i = 123;  //自动装箱
        Integer i2 = Integer.valueOf(123);

        //Integer -> int
        int i3 = i;     //自动拆箱
        int i4 = i.intValue();

        //Integer -> String
        String s2 = String.valueOf(i);

        //String -> Integer
        Integer i5 = new Integer("123");
        Integer i6 = Integer.valueOf("123");

    }
}

图示