引用Java™教程:

Unlike synchronization wrappers, which add functionality to the wrapped collection, the unmodifiable wrappers take functionality away. In particular, they take away the ability to modify the collection by intercepting all the operations that would modify the collection and throwing an UnsupportedOperationException. Unmodifiable wrappers have two main uses, as follows: To make a collection immutable once it has been built. In this case, it's good practice not to maintain a reference to the backing collection. This absolutely guarantees immutability. To allow certain clients read-only access to your data structures. You keep a reference to the backing collection but hand out a reference to the wrapper. In this way, clients can look but not modify, while you maintain full access.

(强调我的)

这真的很概括。

不可修改的集合通常是其他代码仍然可以访问的可修改集合的包装器。因此，如果您仅拥有对不可修改集合的引用，则不能对其进行任何更改，但不能指望内容不会更改。

不可变集合保证没有任何东西可以再改变集合。如果它包装了一个可修改的集合，它将确保没有其他代码可以访问该可修改的集合。注意，尽管没有代码可以改变集合包含引用的对象，但对象本身仍然可能是可变的——创建一个不可变的StringBuilder集合并不会以某种方式“冻结”那些对象。

基本上，区别在于其他代码是否能够在您背后更改集合。

我认为主要的区别是，可变集合的所有者可能希望向其他一些代码提供对集合的访问，但通过不允许其他代码修改集合的接口提供这种访问(同时将这种能力保留给所有者代码)。因此集合不是不可变的，但某些用户不允许更改集合。

Oracle的Java Collection Wrapper教程有这样说(强调添加):

不可修改的包装器有以下两个主要用途: 使集合在构建后不可变。在这种情况下，最好不要维护对后台的引用 收集。这绝对保证了不变性。 允许某些客户端只读访问您的数据结构。您保留了对备份集合的引用 输出对包装器的引用。这样，客户可以看，但不能看 修改，同时保持完全访问权限。

基本上不可修改集合是一个视图，所以它仍然可以间接地从其他一些可修改的引用中“修改”。也因为它只是另一个集合的只读视图，当源集合发生变化时，不可修改集合将始终显示最新的值。

然而，不可变集合可以被视为另一个集合的只读副本，不能被修改。在这种情况下，当源集合发生变化时，不可变集合不反映这些变化

下面是一个测试用例来可视化这种差异。

@Test
public void testList() {

    List<String> modifiableList = new ArrayList<String>();
    modifiableList.add("a");

    System.out.println("modifiableList:"+modifiableList);
    System.out.println("--");


    //unModifiableList

    assertEquals(1, modifiableList.size());

    List<String> unModifiableList=Collections.unmodifiableList(
                                        modifiableList);

    modifiableList.add("b");

    boolean exceptionThrown=false;
    try {
        unModifiableList.add("b");
        fail("add supported for unModifiableList!!");
    } catch (UnsupportedOperationException e) {
        exceptionThrown=true;
        System.out.println("unModifiableList.add() not supported");
    }
    assertTrue(exceptionThrown);

    System.out.println("modifiableList:"+modifiableList);
    System.out.println("unModifiableList:"+unModifiableList);

    assertEquals(2, modifiableList.size());
    assertEquals(2, unModifiableList.size());
            System.out.println("--");



            //immutableList


    List<String> immutableList=Collections.unmodifiableList(
                            new ArrayList<String>(modifiableList));

    modifiableList.add("c");

    exceptionThrown=false;
    try {
        immutableList.add("c");
        fail("add supported for immutableList!!");
    } catch (UnsupportedOperationException e) {
        exceptionThrown=true;
        System.out.println("immutableList.add() not supported");
    }
    assertTrue(exceptionThrown);


    System.out.println("modifiableList:"+modifiableList);
    System.out.println("unModifiableList:"+unModifiableList);
    System.out.println("immutableList:"+immutableList);
    System.out.println("--");

    assertEquals(3, modifiableList.size());
    assertEquals(3, unModifiableList.size());
    assertEquals(2, immutableList.size());

}

输出

modifiableList:[a]
--
unModifiableList.add() not supported
modifiableList:[a, b]
unModifiableList:[a, b]
--
immutableList.add() not supported
modifiableList:[a, b, c]
unModifiableList:[a, b, c]
immutableList:[a, b]
--

Java™教程介绍了以下内容:

Unlike synchronization wrappers, which add functionality to the wrapped collection, the unmodifiable wrappers take functionality away. In particular, they take away the ability to modify the collection by intercepting all the operations that would modify the collection and throwing an UnsupportedOperationException. Unmodifiable wrappers have two main uses, as follows: To make a collection immutable once it has been built. In this case, it's good practice not to maintain a reference to the backing collection. This absolutely guarantees immutability. To allow certain clients read-only access to your data structures. You keep a reference to the backing collection but hand out a reference to the wrapper. In this way, clients can look but not modify, while you maintain full access.

我认为这是一个很好的解释，足以理解其中的区别。

    // normal list
    List list1 = new ArrayList();
    list1.add(1);

    // unmodifiable list
    List list2 = Collections.unmodifiableList(list1);

    // immutable list
    List list3 = Collections.unmodifiableList(new ArrayList<>(list1));

    list1.add(2);
    list1.add(3);

    System.out.println(list1);
    System.out.println(list2);
    System.out.println(list3);

输出:

[1, 2, 3]
[1, 2, 3]
[1]