浅谈Java中的自动包装机制

曾经终败给现在 2022-01-30 01:04 228阅读 0赞

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

*  不可变对象
 *   *  引入概念
     *  解释
 *  自动包装机制
 *   *  拆包和自动装箱
     *  常量池
     *  包装类的创建方式
     *  代码
 *  String类
 *   *  String类的自动包装区别
     *  String的缺陷
     *  StringBuffer和StringBuilder

# 不可变对象 #

## 引入概念 ##

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

<table> 
 <thead> 
  <tr> 
   <th>基本类型</th> 
   <th align="left">对应的类</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>int</td> 
   <td align="left">Integer</td> 
  </tr> 
  <tr> 
   <td>double</td> 
   <td align="left">Double</td> 
  </tr> 
  <tr> 
   <td>以下</td> 
   <td align="left">同理</td> 
  </tr> 
 </tbody> 
</table>

这些类就属于`不可变对象`

## 解释 ##

通常我们创建一个类时，会设置相应的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引用变量的时候，我们并没有去修改实际字符串的内容，而是重新指向了新的一个对象。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzOTQ4NTgz_size_16_color_FFFFFF_t_70]  
显然，单是为了增加一个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。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzOTQ4NTgz_size_16_color_FFFFFF_t_70]: /images/20220130/72aa9c9c29874e7db59d3ec8984f86ba.png