不可变对象

引入概念

在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<Integer> list = new ArrayList<Integer>()；
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都会先拆箱变为基本类型相加，然后结果再打包。

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

1. 由于包装器类的引用可以为null，所以在拆箱的时候会抛出NullPointerException
2. 在一个条件表达式中混合使用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。