Em Java, uma lista imutável é uma lista que não pode ser modificada depois de criada. Uma tentativa de adicionar, remover ou modificar elementos na Lista após sua criação gerará uma exceção.
O principal benefício de usar listas imutáveis é que elas fornecem segurança ao thread e tornam o código mais robusto. Como a Lista não pode ser modificada depois de criada, não há risco de vários threads tentarem modificá-la simultaneamente e causarem problemas. Além disso, listas imutáveis podem ser facilmente compartilhadas entre diferentes partes do programa, sem medo de serem modificadas involuntariamente.
No geral, o uso de listas imutáveis em Java pode melhorar a segurança e a robustez de um programa, especialmente em ambientes multithread onde estruturas de dados compartilhadas podem causar problemas.
Declaração de Classe
Em Java, o Lista Imutável aula faz parte Goiaba biblioteca, que fornece várias classes de coleção imutáveis. Usar Lista Imutável , primeiro importamos o com.google.common.collect o pacote que contém o Lista Imutável aula.
A declaração de classe de Lista Imutável é o seguinte:
public abstract class ImmutableList extends ImmutableCollection implements List
Lista Imutável estende o Coleção Imutável classe e implementa o Lista interface. É uma classe genérica, o que significa que podemos criar um Lista Imutável de qualquer tipo de dados. O E na declaração representa o parâmetro de tipo, que podemos substituir por qualquer nome de classe ou interface.
converter inteiro em string java
Hierarquia de classes
O Lista Imutável classe implementa o Lista interface e representa uma lista que não pode ser modificada depois de criada.
A hierarquia de classes de Lista Imutável é o seguinte:
java.lang.Object com.google.common.collect.ImmutableCollection com.google.common.collect.ImmutableList
Aqui, Coleção Imutável é uma classe abstrata que fornece uma implementação esquelética do Coleção Imutável interface, que Lista Imutável estende.
No geral, o Lista Imutável class fornece uma maneira conveniente e eficiente de criar e usar listas imutáveis em Java.
tamanho do meu monitor
Criando lista imutável
Existem diferentes maneiras de criar um ImmutableList em Java, dependendo da versão do Java que você está usando e das bibliotecas disponíveis. aqui estão alguns exemplos:
1. Usando o método Java 9 of():
Java 9 introduziu um novo método chamado of() na interface List, que cria listas imutáveis de forma mais concisa e legível. O método of() é um método de fábrica que recebe um número variável de argumentos e retorna uma lista imutável contendo esses elementos. Ele pode ser usado com qualquer classe que implemente a interface List, incluindo ArrayList, LinkedList e ImmutableList. Uma vantagem de usar o método of() é que ele é muito mais conciso e fornece segurança em tempo de compilação, realizando inferência de tipo nos argumentos, garantindo que apenas objetos do tipo correto sejam adicionados à Lista. No geral, o método of() simplifica a criação de listas imutáveis em Java.
As etapas para encontrar a solução são mencionadas abaixo.
- Importe a classe List do pacote Java.util: que permite ao programa usar a interface List para criar e manipular listas de objetos.
- Crie uma lista imutável usando o método de fábrica Java 9: O código usa o método List.of() para criar uma lista imutável de strings com quatro elementos.
- Tentativa de modificar a lista: O programa tenta adicionar um elemento à lista imutável usando o método add(), que não é permitido em listas imutáveis. Como resultado, o programa captura UnsupportedOperationException lançada pelo método add() e imprime uma mensagem indicando que a lista não pode ser modificada.
Nome do arquivo: ImmutableListExample.java
// Import the required List class from the Java.util package import java.util.List; // Define the class name public class ImmutableListExample { public static void main(String[] args) { // Create an immutable list using the Java 9 factory of() method List fruits = List.of('apple', 'banana', 'orange', 'grape'); // Print the elements of the List System.out.println('Fruits: ' + fruits); // Try to modify the List (will throw UnsupportedOperationException) try { fruits.add('pineapple'); } catch (UnsupportedOperationException ex) { System.out.println('Cannot modify immutable list.'); } } } Saída:
Fruits: [apple, banana, orange, grape] Cannot modify immutable List.
2. Usando a classe ImmutableList.Builder da biblioteca Guava:
Adicionar elementos à Lista em um estilo fluente, tornando-o conveniente para a criação incremental de uma lista.
Independentemente do método usado, a ImmutableList resultante pode ser acessada e iterada como qualquer outra lista, mas seu conteúdo não pode ser modificado.
Aqui está a solução passo a passo para o código fornecido:
- Importe as classes necessárias: importe a interface List e a classe ImmutableList do pacote com.google.common.collect.
- Crie uma lista imutável usando o construtor: Crie uma lista imutável usando o construtor ImmutableList. Use o método add() para adicionar elementos à lista e chame o método build() para criar uma lista imutável.
- Crie uma lista imutável a partir de uma lista existente: Crie um objeto List com os elementos desejados. Em seguida, chame o método ImmutableList.copyOf(), passando List como parâmetro, para criar uma lista imutável.
- Adicionando mais elementos: Use o construtor ImmutableList para adicionar mais elementos usando o método addAll() e chame o método build() para criar uma lista imutável.
- Imprima as listas: Use o método System.out.println() para imprimir o conteúdo das listas imutáveis.
Implementação:
Nome do arquivo: ImmutableListExample.java
import java.util.List; import com.google.common.collect.ImmutableList; public class ImmutableListExample { public static void main(String[] args) { // Creating an immutable list using the builder ImmutableList immutableList1 = ImmutableListbuilder() .add('Welcome') .add('to') .add('home') .build(); // Creating an immutable list from an existing list List existingList = List.of('Welcome', 'to', 'home', 'Think'); ImmutableList immutableList2 = ImmutableList.copyOf(existingList); // Creating an immutable list from an existing list and adding more elements ImmutableList immutableList3 = ImmutableList.builder() .addAll(existingList) .add('Big') .build(); // Let's print the lists System.out.println('Immutable List 1: ' + immutableList1); System.out.println('Immutable List 2: ' + immutableList2); System.out.println('Immutable List 3: ' + immutableList3); } } Saída:
Immutable List 1: [Welcome, to, home] Immutable List 2: [Welcome, to, home, Think] Immutable List 3: [Welcome, to, home, Think, Big]
3. Usando o método of() da classe ImmutableList
O método of() da classe ImmutableList na biblioteca Guava permite criar uma lista imutável com um número fixo de elementos. Depois que a Lista for criada, você não poderá adicionar, remover ou modificar seus elementos.
Nome do arquivo: ImmutableListExample.java
import com.google.common.collect.ImmutableList; import java.util.List; class ImmutableListExample { public static void main(String[] args) { // Create an immutable list using the Guava library's ImmutableList class ImmutableList fruits = ImmutableList.of('apple', 'banana', 'orange', 'grape'); // Print the contents of the immutable List System.out.println('Fruits: ' + fruits); } } Saída:
Fruits: [apple, banana, orange, grape]
4. Usando o método copyOf()
Em Java, o método copyOf() cria um novo array que copia um array existente com um comprimento especificado. O método leva dois argumentos: o array a ser copiado e o comprimento do novo array.
Nome do arquivo: ImmutableListExample.java
diferença entre empresa e empresa
import com.google.common.collect.ImmutableList; import java.util.*; class ImmutableListExample { public static void main(String[] args) { // Create an ArrayList and add elements to it List myArrayList = new ArrayList(); myArrayList.add('Java'); myArrayList.add('Python'); myArrayList.add('C++'); // Create an immutable list using the Guava library's ImmutableList class and the copyOf() method ImmutableList immutableList1 = ImmutableList.copyOf(myArrayList); // Create an array and convert it to a list String[] myArray = {'Learning', 'Web', 'Development', 'is', 'Fun'}; List myList = Arrays.asList(myArray); // Create an immutable list using the Guava library's ImmutableList class and the copyOf() method ImmutableList immutableList2 = ImmutableList.copyOf(myList); // Print the contents of the immutable lists System.out.println('Immutable List 1: ' + immutableList1); System.out.println('Immutable List 2: ' + immutableList2); } } Saída:
Immutable List 1: [Java, Python, C++] Immutable List 2: [Learning, Web, Development, is, Fun]
5. UnsupportedOperationException
O programa ilustra a criação de uma lista imutável em Java usando o método Collections.unmodifiableList. Além disso, mostra como lidar com UnsupportedOperationException lançada ao tentar modificar a Lista.
As etapas para encontrar a solução são mencionadas abaixo:
- Primeiro, criamos um mutável ListaArray contendo alguns elementos iniciais usando o de método, que retorna uma lista imutável. Nós então passamos isso ListaArray para o Coleções.lista não modificável método, que retorna uma visão imutável da Lista.
- Tentamos modificar a lista imutável usando o adicionar, remover , e definir Como a Lista é imutável, tentar modificá-la gerará um UnsupportedOperationException .
- Nós pegamos o UnsupportedOperationException que é lançada e imprime uma mensagem no console indicando qual operação foi tentada e não teve êxito.
Observe que o Coleções.lista não modificável O método cria apenas uma visão imutável da lista original. A visão imutável refletirá essas alterações se a Lista original for modificada. Para criar uma lista verdadeiramente imutável que não pode ser modificada de forma alguma, você pode usar uma implementação personalizada do Lista interface que lança uma exceção ao tentar modificar a Lista.
mylivecricket.in
Implementação:
Nome do arquivo: ImmutableListExample.java
import java.util.ArrayList; import java.util.Collections; import java.util.List; public class ImmutableListExample { public static void main(String[] args) { // Create an immutable list using Collections.unmodifiableList List immutableList = Collections.unmodifiableList(new ArrayList(List.of('foo', 'bar', 'baz'))); // Attempt to modify the immutable List using various methods try { immutableList.add('qux'); System.out.println('Successfully added element to immutable list!'); } catch (UnsupportedOperationException e) { System.out.println('UnsupportedOperationException: ' + e.getMessage()); } try { immutableList.remove(0); System.out.println('Successfully removed element from immutable list!'); } catch (UnsupportedOperationException e) { System.out.println('UnsupportedOperationException: ' + e.getMessage()); } try { immutableList.set(0, 'qux'); System.out.println('Successfully modified element in immutable list!'); } catch (UnsupportedOperationException e) { System.out.println('UnsupportedOperationException: ' + e.getMessage()); } } } Saída:
UnsupportedOperationException: null UnsupportedOperationException: null UnsupportedOperationException: null
6. Coleções.unmodifiableList()
Coleções.unmodifiableList() é um método no Java Collections Framework que cria uma visão não modificável de uma lista existente. Pode-se inferir que tentar modificar a Lista não modificável levará à ocorrência de uma UnsupportedOperationException. A Lista original ainda pode ser modificada e quaisquer alterações serão refletidas na Lista não modificável.
O programa mostra como utilizar o método Collections.unmodifiableList() para gerar uma representação não modificável de uma lista mutável.
As etapas para encontrar a solução são mencionadas abaixo:
- Crie uma lista mutável lista mutável e adicione alguns elementos a ele usando o adicionar() método do ListaArray
- Crie uma visualização não modificável da lista mutável lista mutável usando o Lista não modificável() método e atribuí-lo à variável Lista não modificável .
- Tentativa de modificar a lista não modificável Lista não modificável usando o adicionar() Como a lista não modificável é somente leitura, isso gerará um UnsupportedOperationException . Uma mensagem é impressa no console após capturar essa exceção.
- Modifique a lista mutável original lista mutável adicionando outro elemento usando o adicionar()
- Imprima as listas mutáveis e não modificáveis no console para mostrar que a lista não modificável reflete as alterações feitas na lista mutável original.
Nome do arquivo: Não modificávelListExample.java
import java.util.ArrayList; import java.util.Collections; import java.util.List; public class UnmodifiableListExample { public static void main(String[] args) { List mutableList = new ArrayList(); mutableList.add('apple'); mutableList.add('banana'); mutableList.add('orange'); // Create an unmodifiable view of the mutableList List unmodifiableList = Collections.unmodifiableList(mutableList); // Attempt to modify the unmodifiableList will throw UnsupportedOperationException try { unmodifiableList.add('pear'); } catch (UnsupportedOperationException e) { System.out.println('Attempt to modify unmodifiableList failed: ' + e.getMessage()); } // The original mutableList can still be modified mutableList.add('pear'); // The unmodifiableList will reflect the changes made to the original mutableList System.out.println('mutableList: ' + mutableList); // [apple, banana, orange, pear] System.out.println('unmodifiableList: ' + unmodifiableList); // [apple, banana, orange, pear] } } Saída:
Attempt to modify unmodifiableList failed: null mutableList: [apple, banana, orange, pear] unmodifiableList: [apple, banana, orange, pear]
Vantagens da lista imutável
ImmutableList tem várias vantagens, incluindo: