当前位置：文江博客话题详情

Java immutability

java：示例中不可变对象的优点

发布于 2024-11-01 02:18:59 字数 75 浏览 1 评论 0 原文

请给我一些例子，让我可以看到不可变对象的优点。我在互联网上找到的信息都集中在线程中。我还不知道线程。如果示例能够使用简单的原理那就太好了

原文

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

赠意 2024-11-08 02:18:59

不变性在多线程程序中很重要，因为这样您就知道一个线程不会破坏另一个线程中使用的值。但它在单线程程序中也很有用。

这是一个简单的例子：

Integer i=Integer.valueOf(17);
foo(i);
bar(i);

您可能很想知道，传递给 bar() 的值是什么？

假设 foo() 是一个大而复杂的函数。在这个例子中，我知道一个绝对的事实：当 foo 完成时，i 仍然等于 17，因为 Integer 是不可变的。如果不是这样，我将不得不研究 foo 来判断它是否可以改变。

这是一个稍微复杂的例子。假设我有一些类似于整数但可变的对象。我们称之为 MutableInteger。然后说我这样写：

MutableInteger currentInventory=findQtyInInventory();
MutableInteger neededInventory=currentInventory; // copy current for starters
... bunch of other code ...
neededInventory.subtract(allocatedToSales);
currentInventory.add(arriving);
... bunch of more code ...
if (neededInvenory.compareTo(currentInventory)>0)
  display("Shortage!");

你看到上面的问题了吗？ needInventory 和 currentInventory 指向同一个对象。所有的加法和减法实际上都作用于相同的值，而不是两个不同的值，因此当我们进行测试时，它总是相等的。如果对象是可变的，上面的代码将永远不会工作。如果它们是不可变的，则加法和减法必须返回结果对象，而不是就地更新，这是可行的。

几年前，我使用了 Fortran 编译器，其中整数是可变的。我们有一个函数接受多个参数，其中之一是整数。在极少数情况下，该函数会更新整数。然后有一天，有人编写了对该函数的调用，传递常量“2”作为整数。该函数决定更新参数，从而将“常量”2更改为1！程序中所有其他使用常量 2 的地方现在都神秘地得到了值 1。这花了很长时间来调试。

Immutability is important in multi-threaded programs, because then you know that one thread won't corrupt a value used in another thread. But it's also useful in a single-threaded program.

Here's a simple example:

Integer i=Integer.valueOf(17);
foo(i);
bar(i);

You might well want to know, What value is passed to bar()?

Suppose that foo() is a big, complex function. In this example, I know for an absolute fact that when foo completes, i is still equal to 17, because an Integer is immutable. Were that not true, I would have to study foo to tell if it might be changed or not.

Here's a slightly more complex example. Suppose I have some object that resembles an Integer, but is mutable. Let's call it MutableInteger. Then say I write this:

MutableInteger currentInventory=findQtyInInventory();
MutableInteger neededInventory=currentInventory; // copy current for starters
... bunch of other code ...
neededInventory.subtract(allocatedToSales);
currentInventory.add(arriving);
... bunch of more code ...
if (neededInvenory.compareTo(currentInventory)>0)
  display("Shortage!");

Do you see the problem with the above? neededInventory and currentInventory point to the same object. All the adds and subtracts are really acting on the same value, not two different values, so when we get to the test, it will always be equal. The above code would never work if the objects are mutable. If they are immutable, the adds and subtracts would have to return a result object rather than updating in place, and that would work.

Years ago I used a Fortran compiler where integers WERE mutable. We had a function that accepted several parameters, one of them an integer. In some rare cases, the function updated the integer. Then one day someone wrote a call to this function passing the constant "2" as the integer. The function decided to update the parameter, thus changing the "constant" 2 to 1! Every other place in the program that used a constant 2 now mysteriously got the value 1 instead. This took a long time to debug.

回复收藏 0 原文

寄居人 2024-11-08 02:18:59

这不是一个可以通过示例进行有效解释的概念。不可变对象的优点是你知道它们的数据不能改变，所以你不必担心这一点。您可以自由地传递它们，而不必记住传递它们的方法是否会以您的代码不准备处理的方式更改它们。这使得处理不可变数据变得更加容易。

对于多线程，这种优势更加重要，因为基于多线程以不应该更改的方式更改数据的错误通常是不可重现的 - 它们取决于时间，因此有时会发生，有时不会，这使得它们很难分析并修复。

回复收藏 0 原文

懒猫 2024-11-08 02:18:59

正如您已经知道的，这是一个很好的多线程模式。

它还意味着更好的封装。您可以传递这些对象并共享它们，并且您永远不必担心有人更改您的对象的状态。

Java 核心库中有一些很棒的示例。数字子类是其中之一，但我认为最好的例子是String。您可以传递它们、连接、获取子字符串等，而无需考虑其他地方。如果它像 C/C++ char[] 一样是可变的，那么您始终需要牢记这一点。

出于同样的原因，它也会导致代码更具可读性和可维护性。无需关心该对象的其他用户。

这两个原因将我们引向另一个重要的模式，称为值对象。简而言之，当您关心某些特定值（日期、数字、字符串、间隔、金钱或一些稍微复杂的对象（如果需要）时，这是有意义的，但是该值本身没有身份，即无论上下文如何，它都具有完全相同的含义。

回复收藏 0 原文

埖埖迣鎅 2024-11-08 02:18:59

由于 Java 按值返回（即从方法返回对象引用），如果我像这样返回一个 String：

private String myString = "foo";

public String getString() {
    return this.myString;
}

并且 String 类不是不可变的，那么 getString() 的调用者可以修改myString，这可能不是所需的行为；系统的其他部分可能不希望或期望 myString 发生变化。因此调用者只能更改 myString 指向的对象，而不能更改 myString 本身。

As Java returns by value (i.e. object references are returned from methods), if for example I return a String like so:

private String myString = "foo";

public String getString() {
    return this.myString;
}

and the String class wasn't immutable, then the caller of getString() could modify myString, which may not be the desired behaviour; other parts of the system might not want or expect myString to change. So the caller can only change the object which myString points to, not myString itself.

回复收藏 0 原文

我家小可爱 2024-11-08 02:18:59

这有点同义反复，但不可变对象的主要优点是它们无法更改。当对象可以改变时，你必须考虑它们可能会发生什么。你必须考虑如何、何时以及为何要改变它们。您必须考虑应用程序中的哪些其他代码可能可以访问同一对象，以及它可能会在您不知情的情况下更改哪些内容。不可变对象有效地减少了您必须在系统中处理的“移动部件”的数量（和粒度），让您的生活更轻松。