Java中的基本数据类型包装类

基本数据类型包装类

    基本数据类型包装类：就是按照万事万物皆对象的思想，将原先的那些基本数据类型,当成类和对象来看，也就是说吧这些基本数据类型变成了封装成类，每个类都有自己的方法：
    byte——Byte类
    short——Short类
    int——Integer类
    long——Long类
    float——Float类
    double——Double类
    char——Character类
    boolean——Boolean类
最主要的使用场景就是在基本数据与字符串之间的转换问题：
（1）将基本类型转字符串；
（2）将字符串转成基本类型。
对于这些基本数据类型类它们的父类是Number类，它们都是属于Number类的子类，除了Character类：
例如：Integer类

public final class Integer extends Number implements Comparable<Integer> 

通过查找API，找到java.lang.Number类，可以发现Number类是抽象类，里面的抽象方法基本都没有实现，而实现接口Serializable（序列化：是将内存里面的数据放到存在硬盘里面）

通过API，也可以在java.lang包下，查找Integer类，可以找到其解释及各种方法：

Integer类：

所有已实现的接口： Serializable, Comparable

public final class Integerextends Numberimplements Comparable<Integer>

Integer 类在对象中包装了一个基本类型 int的值。Integer 类型的对象包含一个 int 类型的字段。

此外，该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，还提供了处理 int 类型时非常有用的其他一些常量和方法。

字段摘要

• static int MAX_VALUE
  值为 231－1 的常量，它表示 int 类型能够表示的最大值。
• static int MIN_VALUE
  值为 －231 的常量，它表示 int 类型能够表示的最小值。
• static int SIZE
  用来以二进制补码形式表示 int 值的比特位数。
• static Class TYPE
  表示基本类型 int 的 Class 实例。

public static final Class<Integer>  TYPE = (Class<Integer>) Class.getPrimitiveClass("int");

    /**
     * All possible chars for representing a number as a String
     */
     //转一个字符串进制的时候，0,1,2:指的是三进制，0~9：用的是十进制，0~f：用的是十六进制，0~z：三十六进制
    final static char[] digits = {
        '0' , '1' , '2' , '3' , '4' , '5' ,
        '6' , '7' , '8' , '9' , 'a' , 'b' ,
        'c' , 'd' , 'e' , 'f' , 'g' , 'h' ,
        'i' , 'j' , 'k' , 'l' , 'm' , 'n' ,
        'o' , 'p' , 'q' , 'r' , 's' , 't' ,
        'u' , 'v' , 'w' , 'x' , 'y' , 'z'
    };

构造方法摘要

• Integer(int value)
  构造一个新分配的 Integer 对象，它表示指定的 int 值。
• Integer(String s)
  构造一个新分配的 Integer 对象，它表示 String 参数所指示的 int 值。
  

（1）将基本类型转字符串，以Integer类举例。

public class IntegerDemo {
    public static void main(String[] args) {
        //将基本类型转字符串
        //将该数字默认以十进制转为字符串形式
        System.out.println(Integer.toString(100));
        //将该数字以三进制转为字符串形式，radix是指进制，把前面的数字用几进制形式表示
        System.out.println(Integer.toString(100,3));
        //以二进制形式表示字符串
        System.out.println(Integer.toBinaryString(100));
        //以八进制形式表示字符串
        System.out.println(Integer.toOctalString(100));
        //以十六进制形式表示字符串
        System.out.println(Integer.toHexString(100));
        //将数字拼接一个空串转为字符串形式
        System.out.println(10010 + "");
        //在String类里面的方法，数字转字符串
        System.out.println(String.valueOf(100));
    }
}

（2）将字符串转成基本类型，以Integer类举例。

public class IntegerDemo {
    public static void main(String[] args) {
        //将字符串转成基本类型
        //将字符串s默认以十进制转出来十进制整数
        System.out.println(Integer.parseInt("1123"));
        //将字符串s以radix进制转出来十进制整数
        System.out.println(Integer.parseInt("1001",2));
    }
}

以上都是以Integer类来举例，其他类也是类似的方法，除了Character类，它不仅仅可以表示数字也可以表示字符，所以里面有额外的一些方法，判断字符的特殊性。
（3）自动装箱与自动拆箱
Integer类自动装箱和拆箱运用的方法 valueOf(int i) 和 intValue()：

    public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }
        public int intValue() {
        return value;
    }

如下实例讲解自动装箱和拆箱的过程，和底层运用的方法

public class IntegerDemo {
    public static void main(String[] args) {
        int i1 = 3;
        int i2 = 4;
        //手动装箱
        Integer i3 = Integer.valueOf(5); //new Integer(),Integer i3 = 5
        Integer i4  = new Integer(6);//Integer i4 = 6
        Integer i5 = new Integer("7");//Integer i5 = 7

        //自动装箱 自动将8封装为一个Integer对象
        Integer i6 = 8; //底层的过程Integer.valueOf(8) -> new Integer(8)

        //自动拆箱 基本数据类型的包装类对象一旦和基本数据类型或基本数据类型包装类进行基本四则运算
        //自动会使用 intValue();
        System.out.println(i1 + i3.intValue());//i1 + i3
        System.out.println(i2 + i4.intValue());//i2 + i4
        System.out.println(i3.intValue() + i4.intValue());//i3 + i4
        System.out.println(i4.intValue() + i5.intValue());//i4 + i5
    }
}

结果如下：

注意：下来讲一下valueOf(int i)方法里面一个特殊的情况，valueOf(int i)方法的底层是IntegerCache类里面有个cache[]变量：

 public static Integer valueOf(int i) {
 //当i >= -128 && i <= 127，不用创建新的对象，直接把缓存数组中的数字拿出来就可以
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

private static class IntegerCache {
        static final int low = -128;
        static final int high;//127
        static final Integer cache[];

        static {
            // high value may be configured by property
            int h = 127;
            String integerCacheHighPropValue =
                sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
            if (integerCacheHighPropValue != null) {
                try {
                    int i = parseInt(integerCacheHighPropValue);
                    i = Math.max(i, 127);
                    // Maximum array size is Integer.MAX_VALUE
                    h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
                } catch( NumberFormatException nfe) {
                    // If the property cannot be parsed into an int, ignore it.
                }
            }
            high = h;
            //注意
            cache = new Integer[(high - low) + 1];//-127 ~ 128里面的所以数字
            int j = low;
            for(int k = 0; k < cache.length; k++)
                cache[k] = new Integer(j++);//把-127 ~ 128里面的所以数字放进去

            // range [-128, 127] must be interned (JLS7 5.1.7)
            assert IntegerCache.high >= 127;
        }

        private IntegerCache() {}
    }

所以如下实例：

public class IntegerDemo {
    public static void main(String[] args) {
        Integer a = 1;  //new Integer(1)
        Integer b = 1;  //new Integer(1)
        System.out.println(a == b);
        //不是你理解a.intValue() == b.intValue()
        //a == b 确实比较的是两个对象的地址
        System.out.println(a.equals(b));

        Integer x = 200;    //new Integer(200)
        Integer y = 200;    //new Integer(200)
        System.out.println(x == y);
        //x == y 确实比较的是两个对象的地址
        System.out.println(x.equals(y));

    /*
    * if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
    *
    high = h;

        cache = new Integer[(high - low) + 1];
        int j = low;
        for(int k = 0; k < cache.length; k++)
            cache[k] = new Integer(j++);

        // range [-128, 127] must be interned (JLS7 5.1.7)
    *
    *
    * */
    }
}

结果：因为a和b都是1，本来就在 valueOf(int i) 方法里面，属于当i >= -128 && i <= 127的情况，就不用创建新的对象，直接把缓存数组中的数字拿出来就可以，所以a和b的真实物理地址是一样的，就是因为它们是一个东西，而x和y都是200，不属于当i >= -128 && i <= 127的情况，需要给x和y的每个都创建一个新对象，它们的真实物理值不一样，内容一样。