java-常用类之封装类

jdk中的内置类型即常用类，由jdk内部预定义好的一些Java类，直接可以拿来使用，例如对字符串的处理使用java.lang.String；需要处理数值类型转换可以使用java.lang.Integer，日期处理，文件处理，网络操作等，这些常见操作Java中都提供相关的类以便轻松实现所需功能。

以上所有基本类型提供的引用类型中都封装一些实用的方法，用于进行类型转换，数值处理，进制转换等操作

Integer类是针对int的封装，一般常见使用Integer进行类型转换，进制转换等操作，java.lang.Integer类继承自java.lang.Number（java中所有的数值类型封装类都是从该类继承：Byte,Short,Integer,Long,Float,Double）

Integer提供的构造器：

• Integer(int i):将一个基本int类型包装为一个Integer对象
• Integer(String s)：将一个字符串类型的数值包装为Integer

Integer的常见方法

• byteValue():将一个Integer对象转换为byte类型
• shortValue()：将一个Integer对象转换为short类型
• intValue()：将一个Integer对象转换为int类型
• longValue()：将一个Integer对象转换为long类型
• floatValue()：将一个Integer对象转换为float类型
• valueOf(int i)：返回一个 Integer实例表示指定的 int值
• valueOf(String s)：返回一个 Integer对象持有指定的 String值。
• doubleValue()：将一个Integer对象转换为double类型
• static int parseInt(String s):将字符串类型的数值转换为int类型
• static String toBinearyString(int i):将十进制整数转换为二进制字符串
• static String toOctalString(int i):将十进制整数转换为八进制字符串
• static String toHexString(int i):将十进制整数转换为十六进制字符串

String s1 = "123";
String s2 = "456";

//        int i = 123;
//        String s3 = i+"";

System.out.println(s1+s2);

Integer i1 = new Integer(10);
Integer i2 = new Integer("10");

// 0110  6
// 0111  7
// 1000  8
//获取将数值转换为二进制后，数值为1的个数
System.out.println(Integer.bitCount(6));
//将Integer对象转换为byte类型
byte b = i1.byteValue();

int i4 = Integer.parseInt("123");
System.out.println(i4);

//将十进制整数转换为二进制字符串
String bin = Integer.toBinaryString(8);
System.out.println(bin);

//十进制整数转换为八进制
String oct = Integer.toOctalString(8);
System.out.println(oct);

//十进制整数转换为16进制
String hexString = Integer.toHexString(1257);
System.out.println(hexString);

System.out.println(Integer.sum(10,20));

// 0000 0000 0000 0000 0000 0000 0000 1000
System.out.println(Integer.reverse(8));

在Jdk1.5版本引入自动装箱和拆箱机制，用于实现基本类型数据和封装类型之间无缝转换:

• 自动装箱：将基本类型数据自动封装为包装类
• 自动拆箱：将封装类型中包含基本类型数据拆分成基本类型数值

//自动装箱，内部是通过Integer.valueOf(int i)
Integer i1 = 10;

//自动拆箱,内部通过调用Integer的intValue()方法实现
int i2 = new Integer(10);

注意事项：

• 装箱，拆箱机制应用于所有的封装类

观察以下代码，查看运行结果：

Integer x = 120;  //cache[index]
Integer y = 120;  //cache[index]
System.out.println(x == y);  // true

Integer x1 = 150; // new Integer(150);
Integer y1 = 150; // new Integer(150);
System.out.println(x1 == y1); // false

以上的运行结果存在较大差异，造成以上以上结果的原因：Integer内部提供了一个缓存区（默认缓存了从-128~127之间的Integer对象）：

private static class IntegerCache {
    static final int low = -128;
    static final int high;
    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;
		//声明一个指定范围大小的Integer数组（长度256）
        cache = new Integer[(high - low) + 1];
        int j = low;
        for(int k = 0; k < cache.length; k++)
            //缓存从-128到127之间的整数
            cache[k] = new Integer(j++);

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

    private IntegerCache() {}
}

在进行两个对象比较的时候默认调用一下方法：

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

如果获取的封装类型在缓存区，则直接取出缓存区中的对象（从数组中获取），如果获取的值不在缓存区，此时会重新new一个出来，地址将会发生改变

缓存（cache）:将一些经常使用到的数据进行缓存，避免每次需要使用时都重新创建获取等（减少时间的开销，提高程序的访问效率）

封装类型中常见的方法主要是parseXXX(String s):将字符串类型的数据转化为其他基本类型数据。