1.包装类

概念：基本数据类型对应的类就是包装类，就是为了把基本数据类型转换为包装类，使用这个类里面的方法操作数据----装箱的过程；

//装箱：基本数据类型->包装类
//拆箱：包装类->基本数据类型

int n1 = 100;
//手动装箱
Integer integer = new Integer(n1);
Integer integer1 = Integer.valueOf(n1);

//手动拆箱
int i = Integer.intValue();

//到了jdk5之后，可以实现自动装箱和拆箱
int n2 = 200;
Integer integer2 = n2;//这个底层还是使用的这个Integer.valueOf方法，return的是new Integer
                      //底层还是手动装箱的过程，只不过这个IDEA底层帮我们完了

//自动拆箱
int n3 = integer2;//底层还是进入intValue方法

由此可见，

手动装箱的过程中，需要new基本数据类型，或者是调用这个valueOf方法也是可以的；

手动拆箱就是使用这个intValue方法，把基本数据类型转换为int类型数据；

自动装箱可以把这个整形数据直接赋值给基本数据类型，底层还是使用的valueOf方法，返回包装类的对象；

自动拆箱也是调用这个intValue方法，但是写代码的时候直接把包装类赋值给int类型数据；

2.课堂测试题

下面的代码是否正确：

Double d = 100d;//ok,自动装箱，调用valueOf(100d)
Float f = 1.5f;//ok,自动装箱，调用valueOf(1.5f)

上面的这个代码里面，我们的Double,Float这样的第一个字母大写表示的就是保证类，这个第一个字母大小写也是区分包装类和基本数据类型的一个依据；

上面的两个都是进行装箱过程，自动装箱，因此是可以的；

---

下面的两个题目的输出结果：

Object obj = true? new Integer(1):new Double(2.0); 
system.out.println(obj);

Object obj2;
if(true)
	obj2 = new Integer(1)
else
	obj2 = new Double(2.0)
system.out.println(obj2);

上面的第一个三目运算符是一个整体，因此这个输出的就是我们的1.0，这个主要是因为这个double的精度更高，因此这个int会转换为double类型的数据，所以这个打印结果是1。0，而不是1；

下面的这个判断语句，就不是一个整体，不会因为这个double类型数据的存在，影响我们的整形数据，因此这个打印输出结果是1；

3.包装类方法

Integer类<—>String类型:相互转化

Integer i = 100;

String str1 = i+"";

String str2 = i.toString();

String str3 = String.valueOf(i);

字符串转换为Integer包装类：

String str4 = "12345";

Integer i2 = Integer.parseInt(str4);

Integer i3 = new Integer(str4);

其他的数据类型和包装类之间也是可以转化，方法很多，我们用到的时候查阅即可；

4.Integer创建机制

下面的这个案例是一个Integer创建机制的说明：

public class Main {
    public static void main(String[] args) {
        Integer i = new Integer(1);
        Integer j = new Integer(1);
        System.out.println(i==j);

        Integer m=1;//调用Integer.valueOf(1);
        Integer n=1;//调用Integer.valueOf(1);
        System.out.println(m==n);

        Integer x=128;
        Integer y=128;
        System.out.println(m==n);
    }

在上面的这个里面：

第一个判断相等：我们是new两个对象，这个i,j都是对象，这个地址不可能是一样的，因此不会相等；

第二个判断：我们调用的这个valueOf实现自动装箱的过程，下面的这个图片里面就是我们的valueOf源代码，范围是-128到127时候，就会直接在数组返回，不在这个范围就会new对象，这个时候地址就不会相同了；

第三个判断：这个128不在我们的这个范围里面，因此会new对象，因此这个第三个的输出结果不会一样；

这个low就是-128，这个源码里面的high就是127,cache是数组，在这个范围里面返回的就是数组里面的元素

5.Integer面试题

下面的这个案例需要我们区分一下，相关的注意事项我添加到了注释里面去：

public class test1 {
    public static void main(String[] args) {
//示例一
        Integer i1 = new Integer(127);
        Integer i2 = new Integer(127);
        System.out.println(i1 == i2);//F---new出来的对象肯定是不一样的~
        
        
//示例二
        Integer i3 = new Integer(128);
        Integer i4 = new Integer(128);
        System.out.println(i3 == i4);//F---new出来的对象肯定是不一样的~
        
        
//示例三
        Integer i5 = 127;//底层 Integer.valueOf(127)
        Integer i6 = 127;//-128~127
        System.out.println(i5 == i6); //T----------在范围里面，因此是相同的；
        
        
//示例四
        Integer i7 = 128;
        Integer i8 = 128;
        System.out.println(i7 == i8);//F-----不在我们的范围里面，因此是不同的~
        
        
//示例五
        Integer i9 = 127; //Integer.valueOf(127)
        Integer i10 = new Integer(127);
        System.out.println(i9 == i10);//F---
        
        //i9是在这个范围里面，返回的是我们的数组里面的数据，但是											//这个，i10就是new出来的，因此两个对象的这个地址肯定是不一样的；
        
        
//示例六
        Integer i11 = 127;
        int i12 = 127;
		//只要有基本数据类型， 判断的是值是否相同
        System.out.println(i11 == i12); //T----有基本数据类型i12，因此这个就是一样的
        
        
//示例七
        Integer i13 = 128;
        int i14 = 128;
        //只要有基本数据类型， 判断的是值是否相同
        System.out.println(i13 == i14);//T--
        //有一个i14是基本数据类型，因此这个时候只要两个的数值一样即可；
    }
}

    Integer i13 = 128;
    int i14 = 128;
    //只要有基本数据类型， 判断的是值是否相同
    System.out.println(i13 == i14);//T--
    //有一个i14是基本数据类型，因此这个时候只要两个的数值一样即可；
}

}