Coleção imutável vs não modificável

Na visão geral da estrutura de coleções :

Coleções que não suportam operações de modificação (como add, removee clear) são referidas como não modificáveis . Coleções que não são modificáveis são modificáveis .

As coleções que garantem adicionalmente que nenhuma alteração no Collectionobjeto será visível são chamadas de imutáveis . Coleções que não são imutáveis ​​são mutáveis .

Não consigo entender a distinção.
Qual é a diferença entre unmodifiable e immutable aqui?

Uma coleção não modificável geralmente é um invólucro em torno de uma coleção modificável à qual outro código ainda pode ter acesso . Portanto, embora não seja possível fazer alterações se você tiver apenas uma referência à coleção não modificável, não poderá confiar no conteúdo que não está sendo alterado.

Uma coleção imutável garante que nada mais pode mudar a coleção. Se agrupar uma coleção modificável, garante que nenhum outro código tenha acesso a essa coleção modificável. Observe que, embora nenhum código possa alterar a quais objetos a coleção contém referências, os próprios objetos ainda podem ser mutáveis ​​- criar uma coleção imutável de StringBuilderalguma forma "congela" esses objetos.

Basicamente, a diferença é se outro código poderá alterar a coleção pelas suas costas.

Basicamente, unModifiableColeção é uma visão. Portanto, indiretamente, ainda pode ser 'modificada' a partir de alguma outra referência que seja modificável. Também como apenas uma visualização somente leitura de outra coleção, quando a coleção de origem muda, a Coleção não modificável sempre apresentará os valores mais recentes.

No entanto, a immutablecoleção pode ser tratada como uma cópia somente leitura de outra coleção e não pode ser modificada. Nesse caso, quando a coleção de origem é alterada, a coleção imutável não reflete as alterações

Aqui está uma caixa de teste para visualizar essa diferença.

@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());

}

Resultado

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]
--

Eu acho que a principal diferença é que o proprietário de uma coleção mutável pode querer fornecer acesso à coleção para algum outro código, mas fornecer esse acesso por meio de uma interface que não permita que outro código modifique a coleção (enquanto reserva esse recurso para o código proprietário). Portanto, a coleção não é imutável, mas alguns usuários não têm permissão para alterar a coleção.

O tutorial do Java Collection Wrapper da Oracle tem a dizer (ênfase adicionada):

Os invólucros não modificáveis ​​têm dois usos principais, a seguir:

• Tornar uma coleção imutável depois de construída. Nesse caso, é uma boa prática não manter uma referência à coleção de backup. Isso absolutamente garante imutabilidade.
• Permitir que determinados clientes tenham acesso somente leitura às suas estruturas de dados. Você mantém uma referência à coleção de backup, mas distribui uma referência ao wrapper. Dessa maneira, os clientes podem olhar, mas não podem modificar, enquanto você mantém o acesso total .

Se estamos falando de JDK Unmodifiable*x goiaba Immutable*, na verdade a diferença também está no desempenho . Coleções imutáveis pode ser tanto mais rápido e mais eficiente para a memória se eles são não invólucros em torno coleções regulares (implementações JDK são wrappers). Citando a equipe da goiaba :

O JDK fornece métodos Collections.unmodifiableXXX, mas em nossa opinião, eles podem ser

<...>

• ineficiente: as estruturas de dados ainda têm toda a sobrecarga de coleções mutáveis, incluindo verificações de modificação simultâneas, espaço extra em tabelas de hash, etc.

Para citar os Tutoriais Java ™ :

Ao contrário dos wrappers de sincronização, que adicionam funcionalidade à coleção empacotada, os invólucros não modificáveis ​​retiram a funcionalidade. Em particular, eles eliminam a capacidade de modificar a coleção interceptando todas as operações que modificariam a coleção e lançando uma UnsupportedOperationException . Os invólucros não modificáveis ​​têm dois usos principais, a seguir:

• Tornar uma coleção imutável depois de construída. Nesse caso, é uma boa prática não manter uma referência à coleção de backup. Isso absolutamente garante imutabilidade.

• Permitir que determinados clientes tenham acesso somente leitura às suas estruturas de dados. Você mantém uma referência à coleção de backup, mas distribui uma referência ao wrapper. Dessa maneira, os clientes podem olhar, mas não podem modificar, enquanto você mantém acesso total.

^{(ênfase minha)}

Isso realmente resume tudo.

Como observado acima, não modificável não é imutável porque uma coleção não modificável pode ser alterada se, por exemplo, uma coleção não modificável tiver uma coleção delegada subjacente que é referenciada por outro objeto e esse objeto a altera.

Em relação ao imutável, nem está bem definido. No entanto, geralmente significa que o objeto "não será alterado", mas isso precisaria ser definido recursivamente. Por exemplo, eu posso definir imutável em classes cujas variáveis ​​de instância são todas primitivas e cujos métodos todos não contêm argumentos e retornam primitivas. Os métodos permitem recursivamente que as variáveis ​​da instância sejam imutáveis ​​e todos os métodos contenham argumentos que sejam imutáveis ​​e que retornem valores imutáveis. Os métodos devem ter a garantia de retornar o mesmo valor ao longo do tempo.

Supondo que possamos fazer isso, também existe o thread de conceito seguro. E você pode ser levado a acreditar que imutável (ou não mutável ao longo do tempo) também implica na segurança de threads. No entanto, esse não é o casoe esse é o ponto principal que estou apresentando aqui que ainda não foi mencionado em outras respostas. Posso construir um objeto imutável que sempre retorna os mesmos resultados, mas que não é seguro para threads. Para ver isso, suponha que eu construa uma coleção imutável mantendo adições e exclusões ao longo do tempo. Agora, a coleção imutável retorna seus elementos olhando para a coleção interna (que pode estar mudando com o tempo) e depois (internamente) adicionando e excluindo os elementos que foram adicionados ou excluídos após a criação da coleção. Claramente, embora a coleção sempre retorne os mesmos elementos, ela não é segura para threads apenas porque nunca alterará o valor.

Agora podemos definir imutáveis ​​como objetos que são seguros para threads e nunca serão alterados. Existem diretrizes para a criação de classes imutáveis ​​que geralmente levam a essas classes, no entanto, lembre-se de que pode haver maneiras de criar classes imutáveis, que requerem atenção à segurança do encadeamento, por exemplo, conforme descrito no exemplo da coleção "snapshot" acima.

Os tutoriais Java ™ dizem o seguinte:

Ao contrário dos wrappers de sincronização, que adicionam funcionalidade à coleção empacotada, os invólucros não modificáveis ​​retiram a funcionalidade. Em particular, eles eliminam a capacidade de modificar a coleção interceptando todas as operações que modificariam a coleção e lançando uma UnsupportedOperationException. Os invólucros não modificáveis ​​têm dois usos principais, a seguir:

Tornar uma coleção imutável depois de construída. Nesse caso, é uma boa prática não manter uma referência à coleção de backup. Isso absolutamente garante imutabilidade.

Permitir que determinados clientes tenham acesso somente leitura às suas estruturas de dados. Você mantém uma referência à coleção de backup, mas distribui uma referência ao wrapper. Dessa maneira, os clientes podem olhar, mas não podem modificar, enquanto você mantém acesso total.

Eu acho que é uma explicação boa o suficiente para entender a diferença.