java - 不变性和图形模型——如何创建它们？

Question

我将使用示例，因为它更容易展示我想做什么。我有三个类 X、Y 和 Z，我希望能够将它们作为不可变对象(immutable对象)。他们在这里。

X 类:

public class X{
    private int id;
    private String dataX;

    private Collection<Y> collectionOfY;
    private Collection<Z> collectionOfZ;

    /* Constructors */
    /* Getters */
    /* "with" functions */

}

Y 类:

public class Y{

    private int id;
    private String dataY;

    private Collection<X> collectionOfX;
    private Collection<Z> collectionOfZ;

    /* Constructors */
    /* Getters */
    /* "with" functions */

}

Z 类:

public class Z{

    private int id;
    private String dataZ;

    private Collection<X> collectionOfX;
    private Collection<Y> collectionOfY;

    /* Constructors */
    /* Getters */
    /* "with" functions */

}

因此它们相互联系起来，形成一个具有循环结构的图。如果可能的话，我想拥有不可变的对象。我已经实现了“With”函数，它会发回给定对象的一个​​副本，其中只有一个属性发生了变化。

但是，如果我实现完全不变性，我可能会复制(直接或间接)链接到我更改的对象的每个数据: 更改“dataZ”通常意味着我想用链接的 X 和 Y 中新创建的对象替换旧对象。由于更改等原因，将复制旧对象......

另一种解决方案是渲染链接三个类的集合不是不可变的(并且只有部分不可变性)，但后来我几乎失去了尝试拥有不可变性的所有兴趣。

有人有好主意吗？还是我在要求不可能的事情？我应该回到旧的 setter(即使这意味着更复杂的并发管理)吗？

提前致谢;)

Answer 1

C# 可以通过其内置的 Lazy<T> 解决这个问题. Lazy是一个尚未计算其实际值的对象 - 当您构造 Lazy 时，您将工厂函数作为参数传递。

你可以问一个Lazy Value 的值(value)属性(property)。如果工厂函数已经运行，则返回已经构造的值。如果工厂函数还没有运行，那么此时它会运行。无论如何，返回 Value属性总是相同的。一旦一个特定的 Lazy的值(value)已经确定，它坚持下去。

惰性是对可能尚未构造的对象的不可变引用。它在内部使用可变性，但从外部看，它似乎是不可变的。

在你的例子中，如果你有一个相当于 Lazy 的 Java ，你会改变你的集合，比如说，Collection<Y>至 Collection<Lazy<Y>> .这将使 X 的实例能够引用一些尚未构造的 Y 实例。以及构造 X 的代码。小号，Y s 和 Z s 不会直接构建这些实例，而是会构建 Lazy 的实例.这些实例将工厂函数作为参数；反过来，这些工厂功能需要引用一些 Lazy值。这意味着，在构建这些东西并将它们连接在一起的函数上下文中，您需要对 Lazy 实例具有可变引用。

为了理解我的意思，如果您尝试创建一个包含两个对象的循环(我还没有完全掌握 Java 8，所以我可能有语法错误):

Lazy<X> a;
Lazy<Y> b;

a = new Lazy<X>(() -> {
    List<Y> ys = new ArrayList<Y>();
    ys.add(b.getValue());
    return new X(ys);
});

b = new Lazy<Y>(() -> {
    List<X> xs = new ArrayList<X>();
    xs.add(a.getValue());
    return new Y(xs);
});

在实践中，我认为这行不通。我认为封闭变量在 Java 中需要是最终的(在 C# 中不是这种情况)。所以我认为您需要实际执行此操作:

final Lazy<X>[] a = new Lazy<X>[1];
final Lazy<Y>[] b = new Lazy<Y>[1];

a[0] = new Lazy<X>(() -> {
    List<Y> ys = new ArrayList<Y>();
    ys.add(b[0].getValue());
    return new X(ys);
});

b[0] = new Lazy<Y>(() -> {
    List<X> xs = new ArrayList<X>();
    xs.add(a[0].getValue());
    return new Y(xs);
});

之所以可行，是因为不会立即对两个 lambda 进行求值。只要a[0]和 b[0]在执行这些 lambda 之前设置为有效值，一切都会正常进行。

请注意，这使用了可变性，但可变性在非常有限的范围内。 Lazy 内部存在可变性实例，但这些实例似乎是不可变的。连接函数具有可变性，但该函数会先运行并终止，而构造的对象可以存活更长的时间。至少对我而言，这种受限的可变性是一种可以接受的权衡。