JAVASE-13：包装类和自动拆装箱机制

包装类

案例：
a. 将100转换为二进制、八进制、十六进制
b. 判断一个数是否在int范围内

public static void main(String[] args) {
    int num = 100;
    String s = Integer.toBinaryString(num);
    String s1 = Integer.toOctalString(num);
    String s2 = Integer.toHexString(num);
    System.out.println(s);// 1100100
    System.out.println(s1);// 144
    System.out.println(s2);// 64
    if(25252525>=Integer.MIN_VALUE && 25252525<=Integer.MAX_VALUE){
        System.out.println("在int范围内");// 在int范围内
    }

为了更加方便操作，针对每种基本数据类型，都提供了他的一个包装类型（引用类型）

常用的操作：用于基本数据类型与字符串之间的转换

包装类型	基本类型
Byte	byte
Short	short
Integer	int
Float	float
Character	char
Double	double
Boolean	boolean
Long	long

Integer类
通过JDK提供的API，查看Integer类的说明：Integer 类在对象中包装了一个基本类型 int 的值，该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，还提供了处理 int 类型时非常有用的其他一些常量和方法

1.构造方法
public Integer(int value) 构造一个新分配的 Integer 对象，它表示指定的 int 值。
public Integer(String s) 构造一个新分配的 Integer 对象，它表示 String 参数所指示的 int 值。
注：s要是一个字面上是数字的字符串，如果不是就会报错

public static void main(String[] args) {
    int num = 100;
    //把int类型的值，包装成引用类型。
    Integer integer = new Integer(num);
    //NumberFormatException: For input string: "a200"
    //要的这个字符串，字面上是一个数字的字符串。
    Integer integer2 = new Integer("200");
    System.out.println(integer2 + 100);//300
    System.out.println(integer2 + "100");//200100
}

2.String和int相互转换

public static void main(String[] args) {
    //String和int类型的相互转换
    //int----String
    int num=100; //"100"
    //方式1：
    String str=num+"";
    //方式2：
    String s = String.valueOf(num);
    //方式3:
    Integer integer = new Integer(num);
    String s1 = integer.toString();

    //String-----int
    String strNum="100";
    //方式1：
    Integer integer1 = new Integer(strNum);
    int i = integer1.intValue();
    //方式2：
    int i1 = Integer.parseInt(strNum);
}

自动拆装箱机制

是Jdk1.5之后引入的

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

自动拆箱：将包装类型自动转换成它所对应的基本数据类型

public static void main(String[] args) {
    Integer a = new Integer(100);
    Integer b = new Integer(100);
    //自动拆箱
    int r=a+b;
    System.out.println(r);//200

    //手动拆箱 intValue();
    Integer c = new Integer(100);
    Integer d = new Integer(100);
    int i = c.intValue();
    int i1 = d.intValue();
    System.out.println(i+i1);//200

    System.out.println("====================================");

    int num=10;
    //自动装箱
    Integer nmuInteger=num;

    //手动装箱 Integer.valueOf(num);
    Integer integer = Integer.valueOf(num);
}

1.Integer重写了equals()方法，比较的不是地址值了，比较的是包装的值。

2.Integer重写了toString()方法，把它包装的int类型的数据，转换成字符串。

3.当我们采用Integer i=128;这种方式自动装箱的时候，会调用ValueOf()方法，其中使用IntegerCache()是Integer的静态内部类，IntegerCache()中有一个静态代码块，当IntegerCache()加载，这个静态代码就会执行。

public static void main(String[] args) {
    Integer i1 = new Integer(127);
    Integer i2 = new Integer(127);
    System.out.println(i1 == i2); //false
    //Integer 重写了i1.equals(i2)方法，比较的是，他包装的这个值是否相同
    System.out.println(i1.equals(i2)); //true
    System.out.println("-----------");

    Integer i3 = new Integer(128);
    Integer i4 = new Integer(128);
    System.out.println(i3 == i4); //false
    System.out.println(i3.equals(i4));//true
    System.out.println("-----------");

    Integer i5 = 128;
    Integer i6 = 128;
    System.out.println(i5 == i6);//  false
    System.out.println(i5.equals(i6)); //true
    System.out.println("-----------");

    Integer i7 = 127;
    Integer i8 = 127;
    System.out.println(i7 == i8);//true
    System.out.println(i7.equals(i8)); //true
}