自动包装机制 java_浅谈Java中的自动包装机制

不可变对象

引入概念

在Java中，除了基本类型以外，其他都是以对象的形式存在。而基本类型也有其对应的类，这些类被称为包装器(Wrapper)。例如

基本类型

对应的类

int

Integer

double

Double

以下

同理

这些类就属于不可变对象

解释

通常我们创建一个类时，会设置相应的get和set方法来对成员进行修改。但是对于不可变对象而言，内部成员的值是不能被修改到的，所以被称为不可变。

对于用户自定义的类而言，若想设计成不可变对象，可以借助private或者final关键字防止使用者来修改对象内部的值。

对于Integer这些对象包装器来说，他们不能够被继承，也不能修改内部的值。(因为他们其实就是final类)例如，调用构造函数: new Integer(1) 来实例化一个内部保存了一个int=1的Integer对象，这个对象内部的值再也不能被修改了。这样做的好处是，将Java里的所有基本类型都统一为了对象，而且可以将一些工具类放入包装器中。所以当我们想定义一个整数数组列表时，因为<>尖括号中是不允许是基本类型的，这时候就可以使用Integer对象包装器类。但是在数组列表中，调用list.add()方法时，可以直接传入一个整数类型int，这是因为Java中存在有自动包装机制。

自动包装机制

拆包和自动装箱

借着上面的那个例子，例如调用如下代码

ArrayList list = new ArrayList()；

list.add(2)；

实际上第二句话相当于

list.add(new Integer(2))；

这里就发生了一个自动装箱过程(Autoboxing)

由于Integer是不可变对象，那么如果我们调用如下语句的时候，会发生什么呢？

Integer n = 3;

Integer m = 2;

n++;

m+n;

第一句话，等号右边是个int基本类型，所以这里先进行自动装箱，将3变成一个Integer类。

但是在第二句话中，由于Integer不能参与运算，这里会发生拆箱动作，将Integer类变成基本类型int参与运算，执行自增动作，在运算结束之后，再自动装箱。

拆箱动作会发生在Integer类型被当作int使用时(例如：打印操作)。

接下来在第三句中，两个Integer类型要发生运算关系，所以两个Integer都会先拆箱变为基本类型相加，然后结果再打包。

关于自动装箱还有几点需要说明

由于包装器类的引用可以为null，所以在拆箱的时候会抛出NullPointerException

在一个条件表达式中混合使用Integer和Double类型，Integer值会拆箱，提升为double，再装箱为Double

常量池

Java在栈里设计了一个静态常量池，里面已经准备好了一些会经常用到的数字(0~127)或者字符串(比如"abc")，所以当实例化对象的值在常量池里有的时候，Java不会去堆中再开辟新的空间，而是直接指向栈内的那个值。

包装类的创建方式

==常量化赋值==

Integer a = 10;

放在栈内存储，将被常量化，相当于在栈内开辟一个对象给a，但是由于a是10，是被常量化的 直接指向栈里那个10，以后是凡10的也都指同一个地址。但是如果是128那些就要自己重新在栈里开辟了，因为他们是常量池之外的。

==new对象创建==

Integer c = new Integer(10);

放在堆内，不会被常量化， 就算是10，也不能指到栈里那个10去。因为是再堆中重新开辟的。

代码

下面是一段测试代码，涉及到了常量池和自动装箱机制：

public class BoxClassTest {

public static void main(String[] args) {

int i1 = 10;

Integer i2 = 10; //自动装箱

System.out.println(i1 == i2); //true

//i2会被自动拆箱比大小

//Ps.

//在两边都是对象的时候 == 是比较地址

//两边都是基本类型的时候 == 是比较值

//当有有一边是对象，有一边是基本类型时，会自动拆箱比较。

Integer i3 = new Integer(10); //在堆中开辟一块空间

System.out.println(i1 == i3); //true

//虽然i3在堆里 但是直接拆箱比大小

System.out.println(i2 == i3); //false

//两个都是Integer，一个的地址在栈里一个的地址在堆里

Integer i4 = new Integer(5);

Integer i5 = new Integer(5);

System.out.println(i1 == (i4+i5)); //true

System.out.println(i2 == (i4+i5)); //true

System.out.println(i3 == (i4+i5)); //true

//i4+i5的操作会暴力拆箱 括号那一团就变成基本类型了

//第三个：对象比基本类型，自动给对象拆箱

Integer i6 = i4 + i5; //i4+i5会自动拆箱 也就是 i6 = 10，然后再自动装箱

System.out.println(i1 == i6); //true //拆箱操作

System.out.println(i2 == i6); //true //一样的

System.out.println(i3 == i6); //false //一个在栈里一个在堆里

}

}

String类

String类的自动包装区别

语言描述有点难，直接看代码和注解吧：

public class StringConstantTest {

public static void main(String[] args) {

String s1 = "abc";

String s2 = "abc";

String s3 = "ab"+"c";

String s4 = "a"+"b"+"c";

System.out.println(s1==s2); //只要后面都是常数 就直接被编译器当成abc

System.out.println(s1==s3); //所以这里三个全是true

System.out.println(s1==s4); //true

//对于String来说，如果你是给的一堆常量，Java会自动把他们包装起来

//所以上面的全都是abc

String s5 = "c"；

String s6 = "ab" + s6;

System.out.println(s1==s6); //false

//但是比如你相加的东西里面有个变量，那么编译器就无法识别出来了

//他就不能帮你直接组合好了

//所以他会在代入s3的值之后在堆内重新开辟一块地址

//所以这里的abc就不是和常量池里的是一个地址了

}

}

String的缺陷

以这段代码为例：

public class StringTest {

public static void main(String[] args) {

String str = "a";

str = "ab";

}

}

由于String也是一个不可变对象，所以每次改变String引用变量的时候，我们并没有去修改实际字符串的内容，而是重新指向了新的一个对象。

在这里插入图片描述

显然，单是为了增加一个b字母，我们又重新创建了一个新的对象，而且原先的a还被闲置了(虽然会被回收)，这样的效率太低了，所以，Java里提供了另外两个操作字符串的可变对象类。

StringBuffer和StringBuilder

StringBuffer：线程安全，但是速度没用StringBuilder快。

StringBuilder：线程没那么安全，但是快些。

使用方法如下:

StringBuffer str = "a";

for(int i = 0;i<3;i++)

str.append("b");

System.out.println(str);

这时结果输出的str就是abbb了，而且没用创建新的对象。同理StringBuilder。