包装类的使用

包装类（Integer为例）

概述

包装类 : 封装了基本类型的操作,更方便我们使用

• byte — java.lang.Byte
• short — java.lang.Short
• int — java.lang.Integer
• long — java.lang.Long
• float — java.lang.Float
• double — java.lang.Double
• char — java.lang.Character
• boolean — java.lang.Boolean

包装类的好处：①方便②为了面向对象语言的完整性

比如：创建一个可以接受任何类型的方法。
Object是所有类的族类，由于多态的原因，可以接收任何对象。但是基本数据类型不是Object的子类。为了解决这个问题就运用了包装类，把基本类型转换为对应的包装类类型，包装类其他类一样，都是Object的子类

如：

public class Integer_01 {
    public static void main(String[] args) {
        // 基本类型
        byte b1 = 2;
        // 引用类型
        Byte b2 = null;
        //把b1基本类型封装到b2的引用数据类型中
        b2 = new Byte(b1);

        //可以把b2传入m1方法中
        m1(b2);
    }

    public static void m1(Object obj) {
        //重写了toString方法，所以可以直接打印2，而不是内存地址
        System.out.println(obj);
    }
}

包装类的基本使用

如：

public class Integer_02 {
    public static void main(String[] args) {
        //1. 获取最大值和最小值
        System.out.println("int最大值 : " + Integer.MAX_VALUE);
        System.out.println("int最小值 : " + Integer.MIN_VALUE);
        System.out.println("long最大值 : " + Long.MAX_VALUE);
        System.out.println("long最小值 : " + Long.MIN_VALUE);
        System.out.println(Short.MAX_VALUE);
        System.out.println(Short.MIN_VALUE);
        System.out.println((int) (Character.MAX_VALUE));
        System.out.println((int) (Character.MIN_VALUE));

        //2. 创建对象
        Integer i1 = new Integer(12);
        //也可以传入纯数字的字符串
        Integer i2 = new Integer("1999");
        System.out.println(i1);
        System.out.println(i2);

        //如果不是纯数字，在运行时出错
        // java.lang.NumberFormatException: For input string: "1999a"
        Integer ie = new Integer("1999a");
    }
}

常用方法

1. 创建Integer对象

Integer i1 = new Integer(12);
Integer i_i = Integer.valueOf(12);

2. 将Integer转换为int

int i2 = i1.intValue();

3. static int parseInt(String s): 把字符串转换为int

int i3 = Integer.parseInt("123");
        System.out.println(i3);

4. static String toBinaryString(int value):把指定int值转换为二进制的字符串形式展示

String s1 = Integer.toBinaryString(10);
        System.out.println(s1);

5. 十六进制展示

System.out.println(Integer.toHexString(30));

6. 八进制展示

 System.out.println(Integer.toOctalString(10));

Integer int String 三者之间的相互转换

1. int --> Integer

Integer i1 = new Integer(222);
Integer i2 = Integer.valueOf(22);

2. Integer --> int

int i3 = i2.intValue();

3. String --> Integer

Integer i4 = Integer.valueOf("123");
Integer i5 = new Integer("123");

4. Integer --> String

String s1 = i5.toString();

5. String --> int

int i6 = Integer.parseInt("1233");

6. int --> String

 String s2 = 333+"";

自动装箱和自动拆箱

java1.5之后加入了自动装箱和自动拆箱功能

自动装箱：将基本数据类型自动转换为对应的包装类

自动拆箱：把包装类自动转换为基本数据类型

如：

public class Integer_05 {
    public static void main(String[] args) {
        //java可以自动装箱之前
        Integer i1 = new Integer(223);
        //java可以自动装箱之后
        Integer i2 = 223;//编译完成后就等于是：Integer i2 = new Integer(223);

        //java可以自动拆箱之前
        int i3 = i1.intValue();
        //java可以自动拆箱之后
        int i4 = i1;

        //自动装箱为Integer，再发生多态
        m1(2);
    }

    public static void m1(Object obj) {
        //重写了toString方法，所以可以直接打印2，而不是内存地址
        System.out.println(obj);
    }

}

整型常量池

valueOf():把基本类型转换为Integer类型
整型常量池就是在使用Integer.valueOf()创建Integer对象时，valueOf()初始化了一个常量池，常量池里数据的范围是-128 ~ 127之间，常量池里每个值都对一个一个对象，如果赋值操作的数据在 -128 ~ 127，则直接返回常量池中的数据对象，如果不在这个范围，则会开辟新的空间保存数据。
如以下测试：

public class Integer_06 {
    public static void main(String[] args) {
        Integer i1 = 123;
        Integer i2 = 123;
        System.out.println(i1 == i2);//true


        Integer i3 = 129;
        Integer i4 = 129;
        System.out.println(i3 == i4);//false


        Integer i5 = Integer.valueOf(123);
        Integer i6 = Integer.valueOf(123);
        System.out.println(i5 == i6);//true

        Integer i7 = Integer.valueOf(129);
        Integer i8 = Integer.valueOf(129);//这里和new Integer(129);没什么区别
        System.out.println(i7 == i8);//false

        //new的方式直接调用了构造方法，创建了两个对象，对象的地址一定不相同，就需要用equals来比较
        Integer i9 = new Integer(1);
        Integer i10 = new Integer(1);
        System.out.println(i9 == i10);//false
        System.out.println(i9.equals(i10));//true
    }
}
/*
输出结果为：
true
false
true
false
false
tru
*/