apache-common-lang3之mutable包

apache-common-lang3中org.apache.commons.lang3.mutable包下的类是干什么用的？MutableInt跟Integer什么区别？跟AtomicInteger什么区别？这里说下我的理解，如有不对的地方，还请不吝赐教。

简要概括

org.apache.commons.lang3.mutable包对Java基本类型和String提供了一些简单的可变值封装类，比如MutableInt、MutableLong、MutableObject等，其实现非常简单，就是对基本类型封装了get、set方法以及一些常用的运算符。其官方建议使用场景（Mutable接口的注释）有二：

1. 作为入参传入方法，在方法内对其值进行修改，退出方法后，修改仍然是生效的，解决基本类型/String类型值传递进方法内修改后，方法外不可见的问题；
2. 在集合中存储一个经常变化的数字基本类型，比方说是一个用来计数的Map，能够避免频繁的新建对象。

使用场景理解

场景一

作为入参传入方法，在方法内对其值进行修改，退出方法后，修改仍然是生效的，解决基本类型/String类型值传递进方法内修改后，方法外不可见的问题；

为什么基本类型和String传递进方法内修改，方法外不可见呢？首先明确一点，Java中方法参数是值传递的，值传递推荐这篇为什么说Java中只有值传递----说服自己（砸电视那个例子笑的我不轻233）

由于是值传递，实参到方法内会复制一份，

• 基本类型很单纯，整个就在栈里，复制一份就跟外边传入那哥们儿毫无瓜葛了，自己咋变都不会影响到外边的变量。
• 封装类型复杂一点，栈里存的是引用，是堆里实际对象的地址；被复制的也是引用，也是堆里同一个对象的地址，所以我们通过方法内复制的引用，也可以访问到原对象，可以对其进行修改，方法外自然也就生效了。
• String比较特殊，它虽然是封装类型，但它有类似基本类型的语法糖，我们都知道，String内部实际存储数据的char数据是final修饰的，也就是说String的值是不可变的。那么我们在方法内如果要改变String的值，如

  private static void test(String s) {
  	s = "bye bye";
  }
  
  public static void main(String[] args) {
      String s = "hello";
      test(s);
      System.out.println(s);  // hello
  }
  

  其实是新创建了一个String对象，然后将复制的引用指向了这个新对象，方法外的引用所指向的对象是没有变化的。

个人感觉String这种，也可以直接new一个StringBuilder进方法，也可以达到目的。

场景二

在集合中存储一个经常变化的数字基本类型，比方说是一个用来计数的Map，能够避免频繁的新建对象。

一般做法

例如我们要统计一下班级里的男生人数和女生人数，可能就会在从数据源拿到数据后，声明一个Map来进行统计计数，大概逻辑如下：

List<String> students = new ArrayList<>();  // 假装这是从数据源取出了大量的数据
students.add("小华,男,14");
students.add("小红,女,13");
students.add("小刚,男,13");
Map<String, Integer> map = new HashMap<>();
for (String student: students) {
    String sex = student.split(",")[1];
    if (!map.containsKey(sex)) {
        map.put(sex, 1);
    } else {
        map.put(sex, map.get(sex) + 1);
    }
}

在不知道MutableInt这个类的时候，我们一般会采用上述代码，这段代码中规中矩，但是存在着频繁新建对象的问题，为什么呢？

Integer计数频繁创建对象

首先基本类型是不能用作泛型的，没有~~Map<String, int>~~ 的写法，所以我们采用Map<String, Integer>，即使用JDK的基本类型int的封装类型Integer，然后在统计数据的时候，对Integer对象有+1的操作；

通过源码可以发现，Integer这些JDK提供的封装类型，其中的基本类型属性都是final修饰的，

/**
* The value of the {@code Integer}.
*
* @serial
*/
private final int value;

也就是说Integer的value值是不可变的，如果要变化，就会产生新对象。例如：

Integer i = 222;
i = i + 1;

上述代码第二行，i会先拆箱，然后执行+1，然后再装箱赋值给i，在装箱的时候，会调用Integer的valueOf方法，生成一个新对象（值在[-128, 127]之间会返回缓存中对象）。前文中说到的“频繁创建对象”，即这种情况。

替换方案

当然就是使用MutableInt类：

List<String> students = new ArrayList<>();  // 假装这是从数据源取出了大量的数据
students.add("小华,男,14");
students.add("小红,女,13");
students.add("小刚,男,13");
Map<String, MutableInt> map = new HashMap<>();
for (String student: students) {
	String sex = student.split(",")[1];
    if (!map.containsKey(sex)) {
        map.put(sex, new MutableInt(1));
    } else {
        map.get(sex).increment();
    }
}
System.out.println(map.get("男").intValue());   // 2

increment方法其实就是对基本类型执行++的操作，不会产生新对象。

与atomic的区别

mutable包下边的类都是非线程安全的，其提供的方法与java.util.concurrent.atomic包下的类非常类似，atomic包下的类，其主属性value与mutable包下一样，也没有用final修饰。所以，非多线程访问的对象，可以用mutable包下边的封装类，他无锁，轻量；多线程访问的对象，直接用atomic包下的类就可以了。