7.包装类

1.包装类
将基本数据类型封装成一个类，让其具有类的属性。

2.包装类的基本构成（以Integer为例）：

private final int value;  #定义最终的一个包装类对应的基本数据类型

#构造器
public Integer(int value) {
    this.value = value;#int类型直赋值
}
public Integer(String s) throws NumberFormatException {
    this.value = parseInt(s, 10);#调用静态方法parseInt将字符串转换为
}
//intValue方法获取包装类的属性值
public int intValue() {
    return value;
}


/*
toString方法，属于静态方法
i：要转换的数据
radix：进制数，缺省是10进制
将i转换为radix进制的字符串
*/
public static String toString(int i, int radix) {  
}
//例：
public static void main(String[] args) {
    String s = Integer.toString(8,2);//将8转换为2进制的字符串
    System.out.println(s);//1000
}

/*equals()方法
object：要比较的对象
先比较是否为同一个包装类，如果是再判断两对象的int值是否相等。
*/
public boolean equals(Object obj) {
    if (obj instanceof Integer) {
        return value == ((Integer)obj).intValue();
    }
    return false;
}

区分Integer.getInteger（string）、Integer.valueOf(String s)、Integer.parseInt(String s)

• getInteger:根据系统属性名得到系统属性得整数数值，其中系统属性可以通过System.getProperty(java.lang.String)方法获取，如果不存在该系统属性名则返回得结果是null。

• valueOf:获取字符串所代表得整数，返回的是包装类

• parseInt：将字符串解析为对应得整数。返回得是基本数据类型

详情：https://www.cnblogs.com/zl1991/p/6669582.html

3.基本数据类型、包装类和字符串的相互转换

注：从jdk1.5开始，支持自动装箱、自动拆箱。装箱时候是调用valueOf(int)方法，而拆箱是调用intValue方法。

//1.基本数据类型与包装类互转
Integer integer = 23;//自动装箱
int a = new Integer(23);//自动拆箱

int b = integer.intValue();//获取包装类的基本数据类型值


//2.字符串与基本数据类型、包装类互转
int c = Integer.parseInt("23");//将字符串解析为对应的整数，返回基本数据类型
int d = new Integer("23");//先用构造器将字符串转为包装类Integer，再自动拆箱

String s1 = String.valueOf("23.2");
String s2 = 23.2+"";
Integer in = new Integer(12);
String s3 = in.toString();

4.面试题
（1）

答案：第一个是1.0，第二个是1

//代码解析：
Object o1 = true?new Integer(1):new Double(2.0);

if (o1 instanceof Double)
    System.out.println("is Double");//Integer类在二元运算或三元运算中自动转换为Double
else System.out.println("is object");

System.out.println(o1);//1.0  上面的Integer自动换为Double，再转为Object类在打印时调用重写的toString方法

Object o2;
if (true){
    o2 = new Integer(1);
}else {
    o2 = new Double(2.0);
}
System.out.println(o2);//1

（2）下面输出的结果是什么？

解析：在Integer包装类中存在一个内部类：IntegerCache，这个内部类中有一个属性static final Integer cache[]，该数组的范围为[-128,127]，当自动装箱的数据在该范围时，会直接从该数组获取，如果超出该范围则重新new一个包装类。所以m和n对应的包装类指向同一个地址，而x和y则不同。

Integer包装类部分源码：
private static class IntegerCache {
    static final Integer cache[];
}

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

（3）下面输出的结果什么？

        Double i1 = 100.0;
        Double i2 = 100.0;
        Double i3 = 200.0;
        Double i4 = 200.0;
        System.out.println(i1==i2); //false
        System.out.println(i3==i4);  //false

Double的装箱方法valueOf具体实现：

public static Double valueOf(double d) {
    return new Double(d);
}

public static Double valueOf(String s) throws NumberFormatException {
    return new Double(parseDouble(s));
}

通过上面的源码可以知道，Double自动装箱时通过new一个包装类，故二者的地址是不同的。

注意:Integer、Short、Byte、Character、Long这几个类的valueOf方法的实现是类似的。
Double、Float的valueOf方法的实现是类似的。

(4)
下面这段代码输出结果是什么：

public class Main {
    public static void main(String[] args) {
         
        Boolean i1 = false;
        Boolean i2 = false;
        Boolean i3 = true;
        Boolean i4 = true;
         
        System.out.println(i1==i2);//true
        System.out.println(i3==i4);//true
    }
}

至于为什么是这个结果，同样地，看了Boolean类的源码也会一目了然。下面是Boolean的valueOf方法的具体实现：

public static Boolean valueOf(boolean b) {
        return (b ? TRUE : FALSE);
    }

而其中的 TRUE 和FALSE又是什么呢？在Boolean中定义了2个静态成员属性：（由于是静态的，只会实例化一次）

 public static final Boolean TRUE = new Boolean(true);

    /** 
     * The <code>Boolean</code> object corresponding to the primitive 
     * value <code>false</code>. 
     */
    public static final Boolean FALSE = new Boolean(false);

再看下面的输出的是什么？

Boolean b1 = new Boolean(true);
Boolean b2 = new Boolean("True");//字符串会忽略大小写
Boolean b3 = new Boolean("true12");
System.out.println(b1);//true
System.out.println(b2);//true
System.out.println(b3);//false 


class A{
	Boolean isFlag;
}
A a = new A();
System.out.println(a.isFlag);//null  此时是Boolean对象，默认初始化为null

Boolean的构造方法实现如下：

public Boolean(String s) {
    this(parseBoolean(s));
}

public static boolean parseBoolean(String s) {
    return ((s != null) && s.equalsIgnoreCase("true"));//忽略大小写来比较
}

(5).谈谈Integer i = new Integer(xxx)和Integer i =xxx;这两种方式的区别。
　　当然，这个题目属于比较宽泛类型的。但是要点一定要答上，我总结一下主要有以下这两点区别：
　　1）第一种方式不会触发自动装箱的过程；而第二种方式会触发；
　　2）在执行效率和资源占用上的区别。第二种方式的执行效率和资源占用在一般性情况下要优于第一种情况（注意这并不是绝对的）。