包装类（Integer/Boolean等、字符串与基本数据类型转化，-127-128自动装箱入池)

为什么要有包装类？
Object类可以接收所有引用数据类型。然而在Java中，数据类型分为基本数据类型和引用数据类型，那么基本数据类型如何处理呢？
使用包装类 ：包装类是将基本数据类型封装到类中，因为Object无法接受基本数据类型，封装成类后就可以用Object类来接收。
简单定义一个int的包装类：

class IntDemo
{
    private int num;
    public IntDemo(int num)
    {
        this.num=num;
    }
    public int value()
    {
        return this.num;
    }
}
public class Demo
{
    public static void main(String[] args)
    {
        Object ob=new IntDemo(10); //子类对象向上转型
        IntDemo a=(IntDemo)ob;  //向下转型，
        System.out.println(a.value()); //取出里面的基本数据类型操作
    }
}

将基本数据类型包装为一个类对象的本质就是使用Object进行接收处理。
Java为了方便开发，定义了包装类的使用，即可以直接使用包装类。
包装类的分类：

• 对象型包装类（Objetc的直接子类），不存在数值转换异常：Boolean类(boolean)、Character类(char)；
• 数值型包装类（Number的直接子类），存在数值转换异常（运行时异常）：Byte类(byte) 、 Short类(short) 、Long类（long）、Double类（double）、Float类(flaot)、Integer类(int)。
  拆箱与装箱
  拆箱和装箱指基本数据类型与相应包装类的数据处理。
• 装箱：将基本数据类型变为包装类对象，利用每个包装类提供的构造方法实现装箱。
• 拆箱：将包装类包装的基本数据类型值取出，利用Number类提供的xxValue( )实现。

public class Demo
{
    public static void main(String[] args)
    {
        Integer a=new Integer(10); //装箱
        int data=a.intValue();  //拆箱
        System.out.println(data); //10
    }
}

以上操作采用的是手工的装箱和拆箱。在JDK1.5之后，提供了自动拆装箱的机制，最为重要的是，由于此类机制的
存在，可以直接利用包装类的对象进行各种数学计算。

public class Demo
{
    public static void main(String[] args)
    {
        Integer a=10;
        System.out.println(a*3);//30
    }
}

包装类的==和equals

public class Demo
{
    public static void main(String[] args)
    {
        Integer a1=new Integer(10);
        Integer a2=new Integer(10);
        System.out.println(a1==a2);  //false 因为==比较地址
        System.out.println(a1.equals(a2)); //true  比较对象内容

        Integer a3=20;
        Integer a4=20;
        Integer a5=170;
        Integer a6=170;
        System.out.println(a3==a4); //ture 因为对于直接赋值，如果值在-127-128之间，会入池
        System.out.println(a5==a6); //false   值没有在-127-128之间，不会入池，会在堆上产生
    }
}

阿里编码规范：
所有相同类型的包装类对象之间的值比较，全部使用equals方法比较。
说明：对于Integer var=? 在-128-127之间的赋值，Integer对象在Integer常量池产生，会复用已有对象，这个区间内的Integer值可以直接用==判断。除此之外的所有数据，都会在堆上产生，并不会复用已有对象。，这是一个大坑，推荐使用 equals 方法进行判断。
使用Integer还是int ?

• 强制：所有的POJO类（简单JAVA类，Bean）属性必须使用包装类型（简单JAVA类是只有属性、getsetter、setsetter）；
• 强制：RPC方法的返回值和参数必须使用包装类型；
• 推荐：所有的局部变量（方法中声明变量）使用基本类型。

字符串与基本数据类型的转换

• 将字符串转为基本数据类型（静态方法）：
  调用各个包装类.parseXX(String str)；如：Integer.parseInt(String str) ;

 - String变为int 类型（Integer类）：public static int parseInt(String s) throws NumberFormatException
 - String变为double类型（Double类）：public static double parseDouble(String s) throws NumberFormatException
 - String变为Boolean类型（Boolean类）：public static boolean parseBoolean(String s)

将字符串转化为基本数据类型：
将 字 符 串 转 为 数 字 的 时 候 ， 字 符 串 的 组 成 有 非 数 字 ， 那 么 转 换 就 会 出 现 错 误（NumberFormatException），以后就因为这个异常，我们要写一堆程序来回避。

public class Demo
{
    public static void main(String[] args)
    {
       String str1="123";
       int a=Integer.parseInt(str1) ;
       System.out.println(a); //123

       //字符串字母
       String str2="123abc";
       //int a2=Integer.parseInt(str2); //会报错:NumberFormatException.forInputString(NumberFormatException.
      
       boolean bo=Boolean.parseBoolean(str2);
       System.out.println(bo); //false，因为对于Boolean来说不是true,就是false
    }
}

将基本数据类型转化为字符串：

• 因为字符串是最高类型：" "（空字符串）+基本类型，就会转为String类；
• 使用String类的valueof(基本类型）静态方法，此方法不产生垃圾空间，推荐使用。

public class Demo
{
    public static void main(String[] args)
    {
       String str1=String.valueOf(100); //将int转为String
       String str2=String.valueOf(10.3); //double 转为String
       String str3=""+'a';   //将字符转为字符串 
       System.out.println(str1); //100
       System.out.println(str2); //10.3
       System.out.println(str3); //a
    }
}