概述

说起Java包装类就不得不说Java的特性 - 面向物件，Java是Sun公司的程序James Gosling，Bill Joe本来打算试图修改和扩展C 的功能，新开发一个语言Oak的发展，C语言是一个面向程序的语言，改进后的Java是面向物件，这是一个非常大的改进，这也是Java发展至今依旧非常流行的原因，

但是，Java又不是完全的面向物件，它沿用了C语言的基本资料型别（这是为了便于开发者的使用，使得在进行基本的资料计算时，开发者可以直接使用基础类），但当需要和Java其他物件结合使用，如存入集合中，就需要将基础资料型别实体封装为Java物件，这样操作起来又比较麻烦了，为了满足面向物件的这一特性，Java的java.lang包中设定了包装类，使得每一个基本型别都有对应的包装类，这样直接就方便了开发者的使用，

转为包装类的物件，是为了使用专门为物件设计的API和特性(比如泛型)

在JDK1.5之前，这个转化程序需要手动实作，即使用包装类的构造器来创建物件，（称为手动装箱）；
在JDK1.15之后，这个转化程序可以自动实作，即直接赋值，（称为自动装箱）

代码示例

import org.junit.Test;//汇入junit包，用来进行单元测验（比main方法好用，一个类可以创建多个程序入口）

public class Demo7 {

    /**
     *  Integer(Byte,Double,Float,Long,Short类似)
     */
    @Test
    public void test1(){
        int i1 = 10; //定义基本资料型别（整型）

		//基本资料型别转化成包装类
        //手动装箱（使用构造器）
        Integer i2 = new Integer(i1);
        Integer i3 = new Integer("11"); //也可以是字符型别，但是必须是数字，否则报错
        //自动装箱（直接赋值）
        Integer i4 = i1;

		//输出结果，测验验证
        System.out.println(i1);
        System.out.println(i2);
        System.out.println(i3);
        System.out.println(i4);


    }

    /**
     * Character
     */
    @Test
    public void test2(){
        char c1 = 'a'; //定义基本资料型别（字符型）

		//基本资料型别转化成包装类
        //手动装箱（构造器）
        Character c2 = new Character(c1);
		//Character c3 = new Character("a"); 不能是字符，如果是字符就会分不清，本身就是了

        //自动装箱（直接赋值）
        Character c4 = c1;

		//输出结果，测验验证
        System.out.println(c1);
        System.out.println(c2);
        System.out.println(c4);
    }

    /**
     * Boolean
     */
    @Test
    public void test3(){
        boolean b1=true; //定义基本资料型别（布尔型）
        
		//基本资料型别转化成包装类
        //手动装箱
        Boolean b2=new Boolean(b1);
        Boolean b3=new Boolean("true");//只要自变量不是true这个字符串，都回传false
        if(b3)
            System.out.println("b3=true");
        else
            System.out.println("b3=false");

        //自动装箱（直接赋值）
        Boolean b4=b1;
		
		//输出结果，测验验证
		System.out.println(b1);
		System.out.println(b2);
		System.out.println(b4);

    }
}

拆箱

介绍

与装箱相反，拆箱就是把包装类物件转化为基本型别的程序，

注意: 如果字符串自变量的内容无法正确转换为对应的基本型别，
则会抛出java.lang.NumberFormatException例外，

资料型别的最大值和最小值

求某个资料型别的最大值和最小值，直接呼叫MAX_VALUE和MIN_VALUE方法

import org.junit.Test;

public class Demo8 {
   /**
     * Integer型别的最大值和最小值（其他类似）
     */
    @Test
    public void test1(){
        
        //最大值
        int maxValue = Integer.MAX_VALUE;
        //最小值  
        int minValue = Integer.MIN_VALUE;

		//输出结果，验证测验
        System.out.println(maxValue);
        System.out.println(minValue);
    }

}

转大小写

如果转包装型别的大小写，则需要呼叫toUpperCase()方法和toLowerCase()方法

import org.junit.Test;

public class Demo8 {
    /**
     * Character转大小写
     */
 
    @Test
    public void test2(){

        char x1 = Character.toUpperCase('x');
        char x2 = Character.toLowerCase('X');

        System.out.println(x1);
        System.out.println(x2);
    }

}

转进制

如果转包装型别的进制，则需要呼叫对应方法（二进制toBinaryString()，十六进制toHexString()，八进制toOctalString()）

package com.atguigu.demo;

import org.junit.Test;

public class Demo8 {

    /**
     * 转进制
     */

    @Test
    public void test3(){

        int i = 6; //十进制的6

        String s1 = Integer.toBinaryString(i); //二进制
        String s2 = Integer.toHexString(i); //十六进制
        String s3 = Integer.toOctalString(i); //八进制

        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s3);
    }
}

包装类物件的快取问题

介绍

有一部分包装类提供了物件的快取，对于频繁使用的包装类物件，其类在初始化时就会提前创建好物件，当需要使用该包装类的物件时，如果该物件包装的值在快取的范围内（这个范围是在Java原始码中设定的），就回传快取的物件；当该物件的值大于快取的范围，就会创建新的物件并回传，

下面以Integer的原始码进行说明

	Integer i = 10; //自动装箱，默认会呼叫valueOf方法
	
              /**
		     * Integer的自动装箱原始码
		     */
                 public static Integer valueOf(int i) {
                     //判断i的值，是否在一个范围  -128 ~ 127  从阵列中取值(地址)
                    if (i >= IntegerCache.low && i <= IntegerCache.high)
                        //如果值在这个范围，回传一个阵列中的值
                        return IntegerCache.cache[i + (-IntegerCache.low)];
                        //如果不在这个范围，new一个（和自己new的物件没区别）
                    return new Integer(i);
                 }

各个包装类对应的快取物件大小如下表：

面试常考

包装类中“== ”与equals的用法比较，可以算是非常重要的考点了，

包装类中的equals方法和String类一样，都是重写了Object类中的equals方法，因此比较的是内容而不是地址，而“= =”比较的依然是参考变量的地址，只是当包装型别和与之相对应的基本型别进行“==”比较时会先做自动拆箱处理，具体可以分类如下：

• ①如果在默认范围内的自动装箱，则相等（比较地址）
• ②如果比较的物件有自己new的，则不相等（比较地址）
• ③如果比较的物件值不在范围内部也是不想等的（比较地址）
• ④如果有基本资料型别参与对比，包装型别就会自动拆箱，就会变成了基本资料型别的对比，
  这个时候比的就是值了，

常见笔试或面试问题举例

import org.junit.Test;

public class Demo9 {

    @Test
    public void test(){
        Integer i1 = 10; //1. Integer这个类会加载  2. 在创建i2这个区域变量
        Integer i2 = 10; 
        System.out.println(i1 == i2); //true 对比地址

        Integer i3 = new Integer(10);
        System.out.println(i1 == i3); //false 对比地址

        Integer i4 =300;
        Integer i5 =300;
        System.out.println(i4 == i5);//false 对比地址

        Integer i6 = 300;
        int i7 = 300;
        System.out.println(i6 == i7); //true 对比值（因为有基本资料型别(i6会转为int在对比) ）

    }
}