不可变类？

Question

如何使 Java 类不可变，什么是不可变性的需要，使用它有什么好处？

Answer 1

什么是不可变对象？

不可变对象是一种在实例化后不会改变状态的对象。

如何使对象不可变？

一般来说，不可变对象可以通过定义一个没有暴露任何成员并且没有任何 setter 的类来创建。

以下类将创建一个不可变对象：

class ImmutableInt {
  private final int value;

  public ImmutableInt(int i) {
    value = i;
  }

  public int getValue() {
    return value;
  }
}

从上面的例子中可以看出， ImmutableInt的值只能在实例化对象时设置，并且只有一个 getter ( getValue ) 对象的状态在实例化后无法更改。

但是，必须注意对象引用的所有对象也必须是不可变的，否则可能会更改对象的状态。

例如，允许通过 getter 获取对数组或ArrayList的引用将允许通过更改数组或集合来更改内部状态：

class NotQuiteImmutableList<T> {
  private final List<T> list;

  public NotQuiteImmutableList(List<T> list) {
    // creates a new ArrayList and keeps a reference to it.
    this.list = new ArrayList(list); 
  }

  public List<T> getList() {
    return list;
  }
}

上面代码的问题是， ArrayList可以通过getList获取getList操作，导致对象本身的状态被改变，因此不是一成不变的。

// notQuiteImmutableList contains "a", "b", "c"
List<String> notQuiteImmutableList= new NotQuiteImmutableList(Arrays.asList("a", "b", "c"));

// now the list contains "a", "b", "c", "d" -- this list is mutable.
notQuiteImmutableList.getList().add("d");

解决此问题的一种方法是在从 getter 调用时返回数组或集合的副本：

public List<T> getList() {
  // return a copy of the list so the internal state cannot be altered
  return new ArrayList(list);
}

不变性有什么好处？

不变性的优势来自于并发。 在可变对象中很难保持正确性，因为多个线程可能会尝试更改同一对象的状态，导致某些线程看到同一对象的不同状态，具体取决于对所述对象的读取和写入时间目的。

通过拥有一个不可变对象，可以确保所有正在查看该对象的线程都将看到相同的状态，因为不可变对象的状态不会改变。

Answer 2

除了已经给出的答案之外，我建议您阅读 Effective Java, 2nd Ed. 中关于不变性的内容，因为有一些很容易遗漏的细节（例如防御性副本）。 另外，Effective Java 第二版。 是每个 Java 开发人员的必读之书。

Answer 3

您可以像这样使类不可变：

public final class Immutable
{
    private final String name;

    public Immutable(String name) 
    {
        this.name = name;
    }

    public String getName() { return this.name; } 

    // No setter;
}

以下是使 Java 类不可变的要求：

• 类必须声明为final （这样子类就不能被创建）
• 类中的成员必须声明为final （这样我们就不能在创建对象后更改它的值）
• 为其中的所有变量编写Getter方法以获取Members值
• 没有 Setter 方法

不可变类很有用，因为
- 它们是线程安全的。
- 他们还表达了一些关于您的设计的深刻内容：“无法改变这一点。”，当它适用时，这正是您所需要的。

Answer 4

不变性主要可以通过两种方式实现：

• 使用final实例属性避免重新分配
• 使用一个类接口，它根本不允许任何能够修改类中内容的操作（只有getter没有setter

不变性的优点是您可以对这些对象做出的假设：

• 您获得了无副作用规则（这在函数式编程语言中非常流行）并允许您更轻松地在并发环境中使用对象，因为您知道它们不能以原子或非原子方式更改时被多个线程使用
• 语言的实现可以以不同的方式处理这些对象，将它们放置在用于静态数据的内存区域中，从而更快、更安全地使用这些对象（这就是在 JVM 内部发生的字符串）

Answer 5

不可变类在实例化后不能重新赋值。构造函数为其私有变量赋值。 在对象变为 null 之前，由于 setter 方法不可用，无法更改值。

不可变应满足以下条件，

• Al 变量应该是private 。
• 没有提供增变方法（setter）。
• 通过使类最终（强不变性）或方法最终（周不变性）来避免方法覆盖。
• 如果它包含非原始类或可变类，则进行深度克隆。

---

/**
* Strong immutability - by making class final
*/
public final class TestImmutablity {

// make the variables private
private String Name;

//assign value when the object created
public TestImmutablity(String name) {
this.Name = name;
}

//provide getters to access values
public String getName() {

return this.Name;
}
}

优点：不可变对象包含它的初始化值，直到它死亡。

java-immutable-classes-short-note

Answer 6

不可变类是那些对象在创建后无法更改的类。

不可变类对于

• 缓存目的
• 并发环境（ThreadSafe）
• 难以继承
• 值不能在任何环境中改变

例子

字符串类

代码示例

public final class Student {
    private final String name;
    private final String rollNumber;

    public Student(String name, String rollNumber) {
        this.name = name;
        this.rollNumber = rollNumber;
    }

    public String getName() {
        return this.name;
    }

    public String getRollNumber() {
        return this.rollNumber;
    }
}

Answer 7

如何使 Java 类不可变？

从具有JEP 359 的JDK 14+ 开始，我们可以使用“ records ”。 它是创建 Immutable 类的最简单、最自由的方式。

记录类是一种浅不可变、透明的载体，用于一组固定的字段，称为记录components ，为记录提供state描述。 每个component都会产生一个保存所提供值的final字段和一个用于检索该值的accessor方法。 字段名称和访问器名称与组件名称匹配。

让我们考虑创建一个不可变矩形的例子

record Rectangle(double length, double width) {}

无需声明任何构造函数，无需实现 equals 和 hashCode 方法。 任何记录都需要名称和状态描述。

var rectangle = new Rectangle(7.1, 8.9);
System.out.print(rectangle.length()); // prints 7.1

如果要在对象创建期间验证值，我们必须显式声明构造函数。

public Rectangle {

    if (length <= 0.0) {
      throw new IllegalArgumentException();
    }
  }

记录的主体可以声明静态方法、静态字段、静态初始值设定项、构造函数、实例方法和嵌套类型。

实例方法

record Rectangle(double length, double width) {

  public double area() {
    return this.length * this.width;
  }
}

静态字段、方法

由于状态应该是组件的一部分，我们不能向记录添加实例字段。 但是，我们可以添加静态字段和方法：

record Rectangle(double length, double width) {

  static double aStaticField;

  static void aStaticMethod() {
    System.out.println("Hello Static");
  }
}

什么是不变性的需要，使用它有什么好处？

以前发布的答案足以证明不变性的必要性及其优点

Answer 8

制作不可变对象的另一种方法是使用Immutables.org库：

假设添加了所需的依赖项，创建一个带有抽象访问器方法的抽象类。 您可以通过使用接口甚至注释（@interface）进行注释来执行相同的操作：

package info.sample;

import java.util.List;
import java.util.Set;
import org.immutables.value.Value;

@Value.Immutable
public abstract class FoobarValue {
  public abstract int foo();
  public abstract String bar();
  public abstract List<Integer> buz();
  public abstract Set<Long> crux();
}

现在可以生成然后使用生成的不可变实现：

package info.sample;

import java.util.List;

public class FoobarValueMain {
  public static void main(String... args) {
    FoobarValue value = ImmutableFoobarValue.builder()
        .foo(2)
        .bar("Bar")
        .addBuz(1, 3, 4)
        .build(); // FoobarValue{foo=2, bar=Bar, buz=[1, 3, 4], crux={}}

    int foo = value.foo(); // 2

    List<Integer> buz = value.buz(); // ImmutableList.of(1, 3, 4)
  }
}

Answer 9

不可变类只是一个实例不能修改的类。

每个实例中包含的所有信息在对象的生命周期内都是固定的，因此无法观察到任何变化。

不可变类比可变类更容易设计、实现和使用。

要使类不可变，请遵循以下五个规则：

1. 不要提供修改对象状态的方法

2. 确保该类无法扩展。

3. 使所有字段最终。

4. 将所有字段设为私有。

5. 确保对任何可变组件的独占访问。

不可变对象本质上是线程安全的； 它们不需要同步。

不可变对象可以自由共享。

不可变对象为其他对象提供了很好的构建块

Answer 10

@Jack，在类中拥有 final 字段和 setter 不会使类不可变。 final 关键字仅确保永远不会重新分配变量。 您需要在 getter 方法中返回所有字段的深层副本。 这将确保从 getter 方法获取对象后，对象的内部状态不会受到干扰。

Answer 11

以下是要求：

• 该类必须声明为final （这样子类就不能被创建）

• 类中的数据成员必须声明为final （这样我们就不能在对象创建后改变它的值）

• 参数化constructor应该初始化所有执行深度复制的字段（这样数据成员就不能用对象引用修改）

• 对象的深层复制应该在getter方法中执行（返回副本而不是返回实际的对象引用）

• 无setters （没有更改实例变量值的选项）

import java.util.HashMap;
import java.util.Map;
 
// An immutable class
public final class Student {
    private final String name;
    private final int regNo;
    private final Map<String, String> metadata;
 
    public Student(String name, int regNo,
                   Map<String, String> metadata)
    {
        this.name = name;
        this.regNo = regNo;
        Map<String, String> tempMap = new HashMap<>();
        for (Map.Entry<String, String> entry :
             metadata.entrySet()) {
            tempMap.put(entry.getKey(), entry.getValue());
        }
        this.metadata = tempMap;
    }
 
    public String getName() { return name; }
 
    public int getRegNo() { return regNo; }
 
    public Map<String, String> getMetadata()
    {
        Map<String, String> tempMap = new HashMap<>();
        for (Map.Entry<String, String> entry :
             this.metadata.entrySet()) {
            tempMap.put(entry.getKey(), entry.getValue());
        }
        return tempMap;
    }
}
 
// Driver class
class Test {
    public static void main(String[] args)
    {
        Map<String, String> map = new HashMap<>();
        map.put("1", "first");
        map.put("2", "second");
        Student s = new Student("ABC", 101, map);
        System.out.println(s.getName());
        System.out.println(s.getRegNo());
        System.out.println(s.getMetadata());
 
        // Uncommenting below line causes error
        // s.regNo = 102;
 
        map.put("3", "third");
        System.out.println(s.getMetadata()); // Remains unchanged due to deep copy in constructor
 
        s.getMetadata().put("4", "fourth");
        System.out.println(s.getMetadata()); // Remains unchanged due to deep copy in getter
    }
}

Answer 12

作为非英语母语人士，我不喜欢“不可变类”的常见解释是“构造的类对象是不可变的”； 相反，我自己倾向于将其解释为“类对象本身是不可变的”。

也就是说，“不可变类”是一种不可变对象。 区别在于回答好处是什么时。 据我所知/解释，不可变类防止其对象运行时行为修改。

Answer 13

这里的大多数答案都很好，有些人提到了规则，但是当我们需要遵循这些规则时，我觉得用文字解释为什么和这样很好。 所以我给出以下解释

• 将成员变量声明为“final”——当我们将它们声明为 final 时，编译器会强制我们初始化它们。 我们可以直接初始化，默认构造函数，通过 arg 构造函数。（见下面的示例代码），初始化后我们不能修改它们，因为它们是最终的。

• 当然，如果我们尝试对这些最终变量使用 Setter，编译器会抛出错误。

   public class ImmutableClassExplored { public final int a; public final int b; /* OR Generally we declare all properties as private, but declaring them as public will not cause any issues in our scenario if we make them final public final int a = 109; public final int b = 189; */ ImmutableClassExplored(){ this. a = 111; this.b = 222; } ImmutableClassExplored(int a, int b){ this.a = a; this.b= b; } }

我们是否需要将类声明为“final”？

• 类声明中没有final关键字，类可以被继承。 所以子类可以覆盖 getter 方法。 这里我们要考虑两种情况：

1.只有原始成员：我们没有问题如果类只有原始成员，那么我们不需要将类声明为final。

2.将对象作为成员变量：如果我们将对象作为成员变量，那么我们必须使这些对象的成员也是最终的。 意味着我们需要深入到树的深处，并使所有对象/原语都成为最终的，这可能并非总是可能的。 因此，解决方法是使类成为 final，从而防止继承。 所以不存在子类覆盖 getter 方法的问题。

Answer 14

Lombok 的 @Value 注释可用于生成不可变类。 它就像下面的代码一样简单。

@Value
public class LombokImmutable {
    int id;
    String name;
}

根据 Lombok 网站上的文档：

@Value 是@Data 的不可变变体； 默认情况下，所有字段都设置为私有和最终字段，并且不会生成设置器。 默认情况下，类本身也是 final 的，因为不可变性不是可以强加给子类的东西。 和@Data一样，也会生成有用的toString()、equals()和hashCode()方法，每个字段获取一个getter方法，还生成一个覆盖每个参数的构造函数（除了在字段声明中初始化的final字段） .

可以在这里找到一个完整的示例。