最近，在我主导的几场代码面试中，经常出现不可变数据结构（Immutable Data Structure）相关内容。关于这个主题我个人并不过分教条，不变性通常体现在数据结构中，"除非必要"否则不会要求代码一定具备不变性。然而，我发现大家对不变性（Immutability）这个概念似乎有一些误解。开发者通常认为加上 `final`，或者在 Kotlin、Scala 中加上 `val` 就足以实现不可变对象。这篇文章会深入讨论不可变引用和不可变数据结构。
1. 不可变数据结构的优点
不可变数据结构有下列显著优点：
没有无效状态（Invalid State）
线程安全
代码易于理解
易于测试
可用作值类型
译注：在计算机编程中包含两种类型，值类型 value type 与引用类型 reference type。值类型表示实际值，引用类型表示对其他值或对象的引用。
2. 没有无效状态
不可变对象只能通过构造函数初始化，并且通过参数限制了输入的有效性，从而确保对象不会包含无效值。例如下面这段代码示例：
```java
Address address = new Address();
address.setCity("Sydney");
// 由于没有设置 country，address 现在处于无效状态.
Address address = new Address("Sydney", "Australia");
// Address 对象有效并且不提供 setter 方法，因此 address 对象会一直保持有效.
```3. 线程安全
由于对象值不可修改，在线程间共享时不会产生竞态条件或者数据突变问题。
4. 代码易于理解
在上面的示例代码中，使用构造函数比初始化方法更易于理解。构造函数会强制检查输入参数，而 setter 或初始化方法不会在编译时进行检查。
5. 易于测试
使用初始化方法，必须测试调用顺序对对象的影响。而使用构造函数，对象的值要么有效要么无效，无需进行排列组合测试。代码执行结果的可靠性更强，出现 `NullPointerExceptions` 的机率更小。下面是一个传递对象过程中改变了对象状态的示例：
```java
public boolean isOverseas(Address address) {
if(address.getCountry().equals("Australia") == false) {
address.setOverseas(true); // address 的值发生了改变!
return true;
} else {
return false;
}
}
```上面的代码是一种错误示范，在返回 `boolean` 结果的同时改变了对象状态。这样的代码可读性和可测性都很差。一种更好的方法是从 `Address` 类中移除 setter 方法，为 `country` 属性提供 `boolean` 类型的测试方法；更进一步，可以把 `address.isOverseas()` 的逻辑移到 `Address` 类中。需要设置状态时，拷贝原来的对象而非修改输入对象的值。
6. 可作为值类型使用
如何做到使用 `Money` 对象表示10美金，使用的时候一直是10美金？比如这段代码，`public Money(final BigInteger amount, final Currency currency)` 确保了一旦声明10美金后接下来不会改变。这样对象的值可以安全地作为值类型使用。
7. final 并不能让对象变成不可变对象
文章开头提到过，我经常遇到开发者不能完全理解 `final` 引用和不可变对象的区别。最常见误区是，只要在变量前加上 `final` 就会成为不可变数据结构。不幸的是，实际并没有这么简单。接下来会为大家消除这个误解：
在变量前加 `final` 不会产生不可变对象。
换句话说，下面这段代码生成的对象是可变对象：
```java
final Person person = new Person("John");
```尽管 `person` 是一个 final 字段不能重新赋值，但 `Person` 类可能提供了 setter 方法或者其他修改方法，比如像下面这个方法：
```java
person.setName("Cindy");
```无论是否加 `final` 修饰符，轻易就可以修改对象。不仅如此，`Person` 类可能还提供了许多修改 address 属性的类似方法，调用它们可以向对象添加地址，同样会修改 `person` 对象。
```java
person.getAddresses().add(new Address("Sydney"));
````final` 引用并没能阻止修改对象。
现在我们已经澄清了这个误解，接下来讨论如何让类具有不可变的特性。在设计时需要考虑以下事项：
不要把内部状态暴露出来
不要在内部修改状态
确保子类不会破坏上面的行为
按照上面这些建议，让我们重新设计 `Person` 类：
```java
public final class Person { // final 类, 不支持重载
private final String name; // 加 final 修饰, 支持多线程
private final List<Address> addresses;
public Person(String name, List<Address> addresses) {
this.name = name;
this.addresses = List.copyOf(addresses); // 拷贝列表, 避免从外面修改对象 (Java 10+).
// 也可以使用 Collections.unmodifiableList(new ArrayList<>(addresses));
}
public String getName() {
return this.name; // String 是不可变对象, 可以暴露
}
public List<Address> getAddresses() {
return addresses; // Address list 可以修改
}
}
public final class Address { // final 类, 不支持重载
private final String city; // 只使用不可变类
private final String country;
public Address(String city, String country) {
this.city = city;
this.country = country;
}
public String getCity() {
return city;
}
public String getCountry() {
return country;
}
}
```现在，代码变成下面这样：
```java
import java.util.List;
final Person person = new Person("John", List.of(new Address(“Sydney”, "Australia"));
```更新后的 `Person` 和 `Address` 让上面的代码成为不可变代码。不仅如此，`final` 引用让 `person` 变量无法再次赋值。
更新：正如评论中[指出的][1]，上面的代码还是可以修改的，因为并没有在构造函数中执行列表拷贝。如果不在构造函数中调用 `new ArrayList()` 还可以像下面这样做：
```java
final List<Address> addresses = new ArrayList<>();
addresses.add(new Address("Sydney", "Australia"));
final Person person = new Person("John", addressList);
addresses.clear();
```[1]:https://www.reddit.com/r/java/comments/azryu6/final_vs_immutable_data_structures_in_java/?st=jt74o32w&sh=40d418d3
由于不在构造函数中执行 `copy`，上面的代码无法修改 `Person` 类中拷贝后的 address list，这样代码就安全了。感谢指正！