一、什么是包装类
 
包装类（Wrapper Class）： Java是一个面向对象的编程语言，但是Java中的八种基本数据类型却是不面向对象的，为了使用方便和解决这个不足，在设计类时为每个基本数据类型设计了一个对应的类进行代表，这样八种基本数据类型对应的类统称为包装类(Wrapper Class)，包装类均位于java.lang包。
 
二、包装类的用途
 
为了使用方便Java中将8中基本数据类型进行了封装：除了Integer和Character类以后，其它六个类的类名和基本数据类型一直，只是类名的第一个字母大写即可。
 
boolean —> Boolean
 char —> Character
 byte—> Byte
 short—> Short
 long—> Long
 int —> Integer
 float—> Float
 double—> Double
 对于包装类说，用途主要包含两种：
 a、作为 和基本数据类型对应的类 类型存在，方便涉及到对象的操作。
 b、包含每种基本数据类型的相关属性如最大值、最小值等，以及相关的操作方法。
 
三、包装类的实际使用（以int和integer为例）
 
1.int和integer类之间的转换
 在实际转换时，使用Integer类的构造方法和Integer类内部的intValue方法实现这些类型之间的相互转换：
 
        int n=5;
        Integer n1=new Integer(n);
        System.out.println("int类型转换为integer类："+n1);
        //
        Integer i=new Integer(50);
        int i1 = i.intValue();
        System.out.println("integer类转换为int类型："+i1);
 
2、Integer类内部的常用方法
 Integer类的主要方法有：parseInt方法和toString方法。
 
    //parseInt方法： 数字字符串类型转成int类型
        String ss="123";
        int ii = Integer.parseInt(ss);
        System.out.println("字符类型转成整型："+ii);
        //toString方法：int类型转成数字字符串类型
        int ii2=123;
        String ss2 = Integer.toString(ii2);
        System.out.println("int类型转成数字字符串类型:"+ss);
 
JDK自从1.5版本以后，就引入了自动拆装箱的语法，也就是在进行基本数据类型和对应的包装类转换时，系统将自动进行，这将大大方便程序员的代码书写。
 自动装箱：将 基本数据类型 封装为对象类型，来符合java的面向对象的思想。
 自动拆箱：将对象重新转化为基本数据类型。
 
  //5是基本数据类型，通过自动装箱变成对象类型。
        //编译器执行了Integer iii = Integer.valueOf(5)
        Integer iii=5;
        //自动拆箱，实际上执行了 int iii2 = iii.intValue()
        int iii2=iii;
        System.out.println(iii2);
 
valueOf（）源码分析：
 
public static Integer valueOf(int i) {
     assert IntegerCache.high>= 127;
     if (i >= IntegerCache.low&& i <= IntegerCache.high)
     return IntegerCache.cache[i+ (-IntegerCache.low)];
     return new Integer(i); 
}
 
说明：Integer iii=5;相当于编译器执行了Integer iii = Integer.valueOf(5)操作。这个方法就是返回一个 Integer 对象，只是在返回之前，看作了一个判断，判断当前 i 的值是否在 [-128,127] 区别，且 IntegerCache 中是否存在此对象，如果存在，则直接返回引用，否则，创建一个新的对象。
 3.包装类的缓存值
 各个包装类缓存值范围
 
boolean：true和false 
byte：-128～127 
char：0～127 
short：-128～127 
int：-128～127 
long：-128～127 
 
特别注意：对于float和double没有缓存。
 在对上述值进行装箱的时候（如：Character c1=127;or Integer i= Integer.valueOf(1); 这个不行哦：Integer i2=new Integer(1)；因为这是新建了一个对象出来。）,并不是创建一个新对象而是使用缓存中的对象，如果超出范围则需要新建立对象。
 四、常见的面试题
 
1.Java中Int与Integer的区别？
 
一、int 是基本类型，直接存数值；而integer引用数据类型。
二、Int的声明不需要实例化，且变量声明后的初始值为0；Integer的是一个类，初始值为null，需要进行实例化，才能对变量数据进行处理。
三、Integer类是int的包装类，实际开发中Integer被看成一个对象，可以进行数据转换等操作。
 
2.判断下面程序片段输出的结果：
 
        Integer num1 = 200;   
        Integer num2 = 200;           
        System.out.println("num1==num2: "+(num1==num2));                    
        Integer num3 = 100;   
        Integer num4 = 100;   
        System.out.println("num3==num4: "+(num3==num4)); 
 
输出结果：num1num2:false 和num3num4:true
 说明：
 
首先要明确equal方法与==的区别：
 
List item equals() 比较的是**两个对象的值（内容）**是否相同。
List item “==” 比较的是**两个对象的引用（内存地址）**是否相同，也用来比较两个基本数据类型的变量值是否相等。
 
java定义：在自动装箱时对于值从–128到127之间的值，它们被装箱为Integer对象后，会存在内存中被重用，始终只存在一个对象而如果超过了从–128到127之间的值，被装箱后的Integer对象并不会被重用，即相当于每次装箱时都新建一个 Integer对象；
 
感恩作者，写的非常好
 作者：谁是谁的小确幸 来源：CSDN
 原文：https://blog.csdn.net/qq_29119581/article/details/78327759
 版权声明：本文为博主原创文章，转载请附上博文链接！

1.区别 
 包装类是对象,拥有方法和字段.对象的调用都是通过引用对象的地址 ; 
 包装类创建的是对象，拥有方法和字段.对象的调用都是通过引用对象的地址 ; 
 基本类型不是.另外一个区别是,包装类是引用传递 而基本类型是值传递 ; 
 例如： 
 int 是基本类型，直接存数值 
 Integer是类，产生对象时用一个引用指向这个对象 
 Java把内存划分成两种：一种是栈内存，另一种是堆内存 
 在函数中定义的一些基本类型的变量和对象的引用变量都是在函数的栈内存中分配 
 而实际的对象是在存储堆内存中 
 即 
 int i = 5;//直接在栈中分配空间 
 Integer i = new Integr(5);//对象是在堆内存中,而i(引用变量)是在栈内存中 
 在堆中分配的内存，由java虚拟机的自动垃圾回收器来管理. 
 因为在堆中分配空间所需的时间远大于从栈中分配存储空间,所以JAVA速度比c慢，当需要往ArrayList，HashMap中放东西时，像int，double这种基本类型是放不进去的，因为容器都是装object的，这是就需要这些基本类型的外覆类了。Java中每种基本类型都有相应的外覆类。
 
 
2.作用
 
【基本数据类型对象包装类】 
 想要对基本类型数据进行更多的操作，最方便的方式就是将其封装成对象。 
 为啥呢？因为在对象描述中就可以定义更多的属性和行为对该基本数据类型进行操作。
 
【八种基本数据类型的包装类】 
 byte ——Byte 
 short ——Short 
 int ——Integer 
 long—–Long 
 float—–Float 
 double—-Double 
 char—-Character 
 boolean—Boolean
 
【基本数据类型变成对象包装类的好处】 
 可以将基本数据和字符串之间进行互相的转换。 
 如：int类型的取值范围是多少？ 
 这就应该去查 Integer —— Integer.MAX_VALUE ； 
 
【基本数据类型包装类的主要作用： 进行基本数据类型和字符串之间的转换】 
 【基本类型数据 转为 字符串 的三种方式】 
 1. 基本数据类型对象包装类中的方法 static String toString(基本类型); 
 2. String类中的方法： static String valueOf(基本类型) 
 3. 基本类型数据 +“ ”； 
 【重点要掌握的就是：】 
 字符串—->基本类型数据。 
 返回值类型——>基本类型 ；参数——>字符串。 
 基本数据类型 变量名 = 基本数据类型包装类.parseXxx(XxxString)； 
 Long l = Long.parseLong(“4546545646546”); 
 System.out.println(Integer.parseInt(“23”) + 1); 
 在八个基本类型对象包装类中只有一个对象没有parse方法，就是Character.
 
【类型转换错误】——NumberFormatException——数字格式异常——我碰到了，因为我多加了一个 空格。
 
【Integer中要掌握的方法】涉及到一个进制转换的问题。 
 十进制–>其他进制。 
 二进制：static String toBinaryString(int); 
 16进制：static String toHexString(int); 
 八进制：static String toOctalString(int); 
 其他进制——>转成十进制； 
 Integer.toString(6 , 2); 将6转换为二进制。 
 parseInt(intString , radix); 
 System.out.println(Integer.parseInt(“110”) , 2);
 
———————————————————————————————— 
 【基本数据类型值 和 基本类型数据对象之间的转换】 
 使用构造函数——Integer（）； 
 即可以接受基本数值，也可以接收基本数值的字符串形式。 
 可以使用基本类型对象中的方法。 static Integer valueOf(int); 
 【基本类型的对象 和 基本数据类型数值】 
 int intValue(); 
 如： 
 Integer i = new Integer(34); 
 int num = i.intValue( ); 
 System.out.println(num); 
 ————————————————————————————————————————————
 
【如果两数被封装成了对象该如何比较呢？】 
 【 基本数据类型的比较——用比较运算符； 引用数据类型使用compareTo进行比较。】 
 int compareTo( Integer anotherInteger ) 在数字上比较两个Integer对象。 
 在数值上比较两个Integer对象。以0 正数 负数 比较两个数多的大小。
 
Integer a = new Integer(7); 
 Integer b = new Integer(5); 
 System.out.println(a.compareTo(b));
 
【重点】 
 对象想要进行比较，必须通过方法来完成，这个方法就是compareTo。 
 而很多对象都可以进行比较。所以这个方法定义在Comparable接口中。 
 想要对象具备比较功能，只要实现Comparable接口。
 
【练习题】。 
 ———————————————————————————————————————————————— 
 【基本数据类型对象包装类JDk1.5以后的新特性】——【自动拆箱，装箱】 
 简化书写。
 
Integer i = new Integer(5); 
 基本数据类型对象包装类，对象创建的简化写法Integer i = 5; 
 1. Integer i = 5;(其实在内存中也是通过 new Integer(5)这种方式创建的！) 
 这种方式成为——自动装箱，Integer.valueOf(5)自动完成了对象创建的动作。 
 2. 在进行 i = i + 5，运算时—— 
 = 右边的i 会先转成基本数据值（自动拆箱）i.intValue()，其实质为： 
 i = i.intValue() + 5 ；然后再和5进行加法运算。
 
= 右边运算完的结果，再次被自动装箱变成Integer对象赋给i.
 
一旦简化就有弊端：多具备一个值null. 使用自动装箱拆箱时，要进行null的健壮性判断。 
 【实例】 
 Integer x = null; 
 x = x.intValue() + 4; x为null 不能调用方法，此时会发生：NullPointerException异常。 
 ———————————————————————————————— 
 Boolean b = true; boolean b = true;的区别 
 答：前者：类类型变量指向一个对象，true为一个对象； 
 后者：true为基本类型变量。 
 ———————————————————————————————— 
 在JdK1.5的新特性自动装箱中，如果数值在byte类型范围内（-128 ~ 127）。如果该对象数值重复出现 
 多个引用其实是指向同一个Integer对象，节省空间！但是超出了byte范围，都会生产新的Integer对象。 
 Integer m = 127; 
 Integer n = 127; 
 System.out.println( m == n); //true 
 System.out.println(m.equals(n)); //true
 
Object x = 5；Object x 接受到了一个Integer对象,自动装箱。 
 然而 Object不可以接受基本数据类型。 
 ——————————————————————————————————————
 
【面试题】——”34 9 -7 67 25”要求对这个字符串中的数值进行从小到大的排序，生成一个数值有序的字符串。 
 【必须会】 
 思路：
 
把其中的数拿出来，——对字符串进行切割。
对数进行排序
再追加成字符串。
 
步骤：1.split;——这个方法我还没掌握，怎么用。 
 【】——数组排序 
 2.定义一个int数组 将 字符串数组——>int数组 
 3.对int数组排序； 
 4. 将int数组转成字符串数组。 
 代码体现：
 
/**
 * 需求："34 9 -7 67 25"要求对这个字符串中的数值进行从小到大的排序，生成一个数值有序的字符串。
 * @author Administrator
 *
 */
public class StringTestint {
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //要操作的目标
        String s = "34 9 -7 67 25";
        //用空格对原字符串进行切割，转成字符串数组；
        String[] s1 = s.split(" ");
        //定义int[]数组，用来存放整型数据
        int[] arr = new int[s1.length];
        //将字符串数组转成int类型的数组。
        for(int i = 0 ; i < s1.length; i++)
            arr[i] = Integer.parseInt(s1[i]);
        //对int类型的数组进行排序
        for(int i = 0 ; i < s1.length;i++){
            for(int j = i+1 ; j < s1.length;j++){
                if(arr[i] > arr[j]){
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        //定义字符串缓冲区，并将int类型的数组转换为 字符串类型的数组。
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < arr.length; i++) {
            if(i != arr.length - 1)
                sb.append(arr[i] + " ");
            else
                sb.append(arr[i]);
        }
        System.out.println(sb);     
    }
}
 
代码优化：
 
import java.util.Arrays;

public class WrapperTest2 {

    private static final String SPACE = " ";
    /**
     * @param args
     */
    public static void main(String[] args) {

        /*
         * 综合练习：
         * "34 9 -7 12 67 25"要求对这个字符串中的数值进行从小到大的排序，
         * 然后生成一个数值有序的字符串。
         * 
         * 思路：
         * 1，看到排序，就想要到了数组
         * 2，那数组中的元素怎么获取呢？数值都在字符串中。
         * 3，先从字符串中获取到这些具体的数值。怎么获取呢？
         * 4，发现这个字符串居然有规律。数值之间都是由空格隔开的。
         *      可以对字符串进行切割。
         * 5，将获取的数据存储到数组中并排序，在将数组转成字符就可以了。哦了。
         * 
         * 
         * 步骤：
         * 1，将字符串切割成字符串数组。split。
         * 2，定义一个int数组将字符串数组中的元素转成整数存储到int数组中。
         * 3，对int数组排序。
         * 4，将int数组排序后转成一个字符串。 
         * 
         */

        String str = "34 9 -7 12 67 25";

        str = sortStringNumber(str);
        System.out.println(str);
    }

    public static String sortStringNumber(String str) {

        //1，将字符串中的数值通过指定的规则进行切割获取字符串数组。
        String[] str_nums = toStringArray(str);

        //2，将字符串数组转成int数组。 
        int[] nums = toIntArray(str_nums);

        //3，对int数组排序;
        sortIntArray(nums);

        //4，将int数组变成字符串。 
        return arrayToString(nums);
    }
    /*
     * 将int数组变成字符串。 
     */
    private static String arrayToString(int[] nums) {
        //1，创建字符串缓冲区。
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < nums.length; i++) {
            if(i!=nums.length-1)
                sb.append(nums[i]+SPACE);
            else
                sb.append(nums[i]);
        }

        return sb.toString();
    }

    /*
     * 对int数组排序。 
     */
    private static void sortIntArray(int[] nums) {
        Arrays.sort(nums);
    }

    /*
     * 将字符串数组转成int数组。 
     */
    private static int[] toIntArray(String[] str_nums) {
        //1,先定义一个int数组。 
        int[] arr = new int[str_nums.length];

        //2,对字符串数组进行遍历。
        for (int i = 0; i < str_nums.length; i++) {
            //将数组格式的字符串转成整数。存储到arr数组中。 
            arr[i] = Integer.parseInt(str_nums[i]);
        }


        return arr;
    }
    /*
     * 将字符串转成字符串数组。 
     */
    private static String[] toStringArray(String str) {

        return str.split(SPACE);
    }



}

Java为什么需要包装类
    java并不是纯面向对象的语言，java语言是一个面向对象的语言，但是java中的基本数据类型却不是面向对象的，但是我们在实际使用中经常将基本数据类型转换成对象，便于操作，比如：数字字符串和数字之间的转化 例如：
 
public class Baochuanglei {
    public static void main(String[] args) {
        String s1 = "12346";
        Integer a = new Integer(s1.toString()); //s1.toString()方法返回的是s1这个类的值，返回类型是字符串类
        System.out.println(getType("s1.toString() 的返回类型是："+s1.toString()));
        System.out.println("a的值是多少："+ a);
    }
    public static String getType(Object a){
        return a.getClass().toString();
    }
}

运行结果如下：	class java.lang.String
a的值是多少：12346
 
他们之间如何转化
   1：基本数据类型和其对应的包装类的转化
       从基本数据类型转化到包装类的方法和创建对象的方法是一致的
 
public class Baochuanglei {
    public static void main(String[] args) {
        Integer a = new Integer(5);
        System.out.println(a);
    }

}

结果是：5
 
  2：包装类如何转化基本数据类型？
       显然，定义一个基本数据类型变量，然后将包装类对象的成员属性赋值给基本数据类型就可以了。但是String转换成char类型可能相对比较麻烦。
       需要对String对象使用.toCharArray（）方法将String对象准换成一个字符数组。
 
public class Baochuanglei {
    public static void main(String[] args) {
        int b;
        Integer a = new Integer(5);
        b = a;
        System.out.println(b);
        char c;
        String s = new String("lishaohui");
        c = s.toCharArray()[2];
        System.out.println(c);
    }

}
结果是：5
       s

基本书库类型的包装类：
 
对基本数据类型进行更多的操作，则将基本数据类型包装成对象，使用对象的方法对基本类型的数据进行更多操作。
 
基本数据类型的对应包装类：
 
byte  --------------- Byte
 
int ----------- -------Integer
 
double---------Double
 
boolean----    Boolean
 
char  ---------Character
 
float  --------Float
 
long ---------Long
 
short---------Short
 
使用的主要方法是 基本类型和字符（即把数字定义的字符而不是abcd这样的字符）之间的相互转换，将字符转换成数据
 
其他方法看API java.lang 中的基本数据类型的包装类