Collections.unmodificSet() 在 Java 中做什么？

Question

我可以看到 Collections.unmodifyingSet 返回给定集合的不可修改视图，但我不明白为什么我们不能仅使用 final 修饰符来完成此操作。

根据我的理解，final 声明了一个常量：无法修改的东西。因此，如果一个集合被声明为常量，那么它就不能被修改：不能从集合中删除任何内容，也不能添加任何内容。

为什么我们需要Collections.unmodifyingSet？

Answer 1

final 声明一个无法修改的对象引用，例如

private final Foo something = new Foo();

创建一个新的Foo 并将该引用放置在something 中。此后，无法更改 something 以指向 Foo 的不同实例。

这不会阻止修改对象的内部状态。我仍然可以调用 Foo 上相关范围可访问的任何方法。如果这些方法中的一个或多个修改了该对象的内部状态，则 final 不会阻止这种情况。

因此，以下内容：

private final Set<String> fixed = new HashSet<String>();

是否不创建一个无法添加或以其他方式更改的Set？它只是意味着 fixed 将仅引用该实例。

相比之下，执行以下操作：

private Set<String> fixed = Collections.unmodifiableSet( new HashSet<String>() );

创建一个 Set 实例，如果尝试调用 fixed.add() 或 ，它将抛出 UnsupportedOperationException例如，fixed.remove() - 对象本身将保护其内部状态并防止其被修改。

为了完整起见：

private final Set<String> fixed = Collections.unmodifiableSet( new HashSet<String>() );

创建一个 Set 实例，该实例不允许更改其内部状态，并且也意味着 fixed 只会指向该实例放。

final 之所以可以用来创建基元常量，是基于其值无法更改的事实。请记住，上面的 fixed 只是一个引用 - 一个包含无法更改的地址的变量。好吧，对于原语，例如

private final int ANSWER = 42;

ANSWER 的值是 42。由于 ANSWER 无法更改，因此它的值永远只有 42。

这个例子模糊了所有内容这些行将是这样的：

private final String QUESTION = "The ultimate question";

根据上述规则，QUESTION 包含代表“终极问题”的 String 实例的地址，并且该地址无法更改。这里要记住的是，String 本身是不可变的 - 您不能对 String 的实例执行任何更改它的操作，也不能执行任何其他操作（例如 replace、substring 等）返回对完全不同的 String 实例的引用。

Answer 2

final 仅保证对变量所代表的对象的引用不能更改，它对对象的实例及其可变性没有任何作用。

final Set s = new Set(); 只是保证您不能再次执行 s = new Set(); 。它不会使集合不可修改，如果是的话，您一开始就无法向其中添加任何内容。因此，为了明确起见，final 仅影响变量 reference，而不影响引用指向的对象。

我可以执行以下操作：

final List<String> l = new ArrayList<String>();
l.add("hello");
l.add("world");
l.remove(0);

但我不能执行此操作。

l = new ArrayList<String>();

再次因为 final 我无法修改变量 l 指向的内容。

您必须执行以下三件事之一才能使 Collection 容器线程安全。

java.util.Collections.syncronizedXXX();

或

java.util.Collections.unmodifiableXXX();

或
使用 java.util.concurrency.* 包中的适当容器之一。

如果我有一个 Person 对象并执行了 final Person p = new Person("me"); 这意味着我无法将 p 重新分配给指向另一个 Person 对象。我仍然可以做 p.setFirstName("you");

令人困惑的是，它

final int PI = 3.14;
final String greeting = "Hello World!";

看起来像 C++ 中的 const，而实际上它们指向的对象是不可变的/本质上不可修改。具有可以更改对象内部状态的 mutator 方法的容器或对象不是 const，只是对这些对象的引用是 final 并且可以'不能重新分配引用另一个对象。

Answer 3

Collections.unmodifyingSet(Set) 将在原始集合上创建包装器。该包装器集无法修改。但原始设置仍然可以修改。

示例：

 Set<String> actualSet=new HashSet<String>(); //Creating set

添加一些元素

actualSet.add("aaa");
actualSet.add("bbb");

打印添加的元素

System.out.println(actualSet);   //[aaa, bbb]

将 actualSet 放入不可修改的集合中，并分配给新引用 (wrapperSet)。

Set<String> wrapperSet=Collections.unmodifiableSet(orginalSet);

打印包装器集。因此它将具有 actualSet 值，

System.out.println(wrapperSet);   //[aaa, bbb]

让我们尝试在 wrapperSet 上删除/添加一个元素。

wrapperSet.remove("aaa");   //UnSupportedOperationException 

中添加一个元素

    actualSet .add("ccc");

在 actualSet Print actualSet 和 wrapperSet 。两组值相同。因此，如果您在实际集上添加/删除任何元素，则更改也将反映在包装集上。

    System.out.println(actualSet);  //[aaa, ccc, bbb]
    System.out.println(wrapperSet);  // [aaa, ccc, bbb]

用法：

此Collections.unmodifyingSet(Set)用于防止修改任何对象的 Set 的 getter 方法。让我们说

public class Department{

    private Set<User> users=new HashSet<User>();

    public Set<User> getUsers(){
        return Collections.unmodifiableSet(users); 
    }
}

Answer 4

final 不是（C++ 风格）const。与 C++ 不同，Java 没有 const 方法或类似的东西，可以通过 Final 引用调用可以更改对象的方法。

Collections.unmodifying* 是一个包装器，它强制（仅在运行时，而不是在编译时）相关集合的只读性。

Answer 5

总结一下我们能做和不能做的：

准备工作：

private Set<String> words = new HashSet<>(Arrays.asList("existing word"));

通过引用最终

private final Set<String> words = new HashSet<>();

可以：

words.add("new word");

不能：

words = new HashSet<>(); //compilation error

通过引用最终，并且不能通过集合修改。

私人最终设置单词= Collections.unmodifyingSet（单词）;

can：

String word = words.iterator().next();

不能

words = new HashSet<>(); // compilation error
words.add("new word"); // runtime error UnsupportedOperationException

cant：通过引用最终确定，

被集合修改，但作为集合的对象是可变的。 但是如果您有 mutual< 的集合/a> 对象，您可以更改该对象的内部状态。

 class A {
       public int a; //mutable field. I can change it after initialization
       public A(int a) {this.a = a;}
     }
    
 private final Set<A> set = Collections.unmodifiableSet(Arrays.asList(new A(25)));

还是不能

set = new HashSet<>(); // compilation error
set.add(new A(777)); // runtime error UnsupportedOperationException

但是可以

 A custom = words.iterator().next(); //here custom.a = 25;
 custom.a = 777; //here first element of **final, unmodifible** collection 
    //was changed from 25 to 777