java list methods sort list
Este tutorial explica vários métodos de lista Java, como classificar lista, lista contém, adicionar lista, remover lista, tamanho da lista, adicionar tudo, remover tudo, lista reversa e muito mais:
Já discutimos a interface de lista em geral em nosso tutorial anterior. A interface de lista possui vários métodos que são usados para manipular o conteúdo da lista. Usando esses métodos, você pode inserir / excluir, classificar e pesquisar elementos na lista.
Neste tutorial, discutiremos todos os métodos fornecidos pela interface de lista.
=> Verifique aqui para ver A-Z dos tutoriais de treinamento de Java aqui.
Para iterar pela lista, a interface da lista usa o iterador da lista. Este iterador de lista se estende da interface do iterador. Em nosso próximo tutorial, exploraremos mais sobre o iterador de lista.
O que você aprenderá:
- Métodos de lista em Java
- Remova duplicatas de uma lista em Java
- perguntas frequentes
- Conclusão
- Leitura recomendada
Métodos de lista em Java
A tabela a seguir mostra várias funções fornecidas pela interface de lista em Java.
| Método de lista | Protótipo de Método | Descrição |
|---|---|---|
| contém | boolean contém (objeto o) | Verifica se o elemento especificado está presente na lista e retorna verdadeiro se presente |
| Tamanho | tamanho interno () | Retorna o tamanho da lista, ou seja, o número de elementos na Lista ou o comprimento da lista. |
| Claro | void clear () | Limpa a lista removendo todos os elementos da lista |
| adicionar | void add (int index, Object element) | Adiciona o elemento fornecido à lista no índice fornecido |
| boolean add (Object o) | Adiciona o elemento fornecido no final da lista | |
| addAll | boolean addAll (coleção c) | Acrescenta toda a coleção fornecida ao final da lista |
| boolean addAll (int index, Collection c) | Insere a coleção fornecida (todos os elementos) na lista no índice especificado | |
| containsAll | boolean containsAll (coleção c) | Verifica se a coleção especificada (todos os elementos) faz parte da lista. Retorna verdadeiro para sim. |
| é igual a | boolean equals (objeto o) | Compara o objeto especificado para igualdade com os elementos da lista |
| Obter | Object get (int index) | Retorna o elemento na lista especificada por índice |
| hashCode | int hashCode () | Retorna o valor do código hash da Lista. |
| indexOf` | int indexOf (Object o) | Encontra a primeira ocorrência do elemento de entrada e retorna seu índice |
| está vazia | boolean isEmpty () | Verifica se a lista está vazia |
| lastIndexOf | int lastIndexOf (Object o) | Encontra a última ocorrência do elemento de entrada na lista e retorna seu índice |
| retirar | Remoção de objeto (índice interno) | Remove o elemento no índice especificado |
| boolean remove (objeto o) | Remove o elemento na sua primeira ocorrência na lista | |
| deletar tudo | boolean removeAll (coleção c) | Remove todos os elementos contidos na coleção especificada da lista |
| reter tudo | boolean reterAll (coleção c) | Oposto de removeAll. Retém o elemento especificado na coleção de entrada na lista. |
| Definir | Conjunto de objetos (índice interno, elemento de objeto) | Altera o elemento no índice especificado configurando-o com o valor especificado |
| subList | List subList (int fromIndex, int toIndex) | Retorna a sublista de elementos entre fromIndex (inclusivo) e toIndex (exclusivo). |
| organizar | void sort (Comparador c) | Classifica o elemento da lista de acordo com o comparador especificado para fornecer uma lista ordenada |
| toArray | Object () toArray () | Retorna a representação da matriz da lista |
| Object () toArray (Object () a) | Retorna a representação da matriz cujo tipo de tempo de execução é o mesmo que um argumento de matriz especificado | |
| iterador | Iterator iterator () | Retorna um Iterador para a lista |
| listIterator | ListIterator listIterator () | Retorna um ListIterator para a lista |
| ListIterator listIterator (índice interno) | Retorna um ListIterator começando no índice especificado na lista |
A seguir, discutiremos essas funções junto com seus exemplos.
Tamanho
Protótipo: tamanho interno ()
Parâmetros: NADA
Valor de retorno: int => Número de elementos na lista ou, em outras palavras, o comprimento da lista.
Descrição: O size () retorna o número de elementos ou o tamanho da lista. Ele também pode ser chamado de comprimento em termos simples.
Claro
Protótipo: void clear ()
Parâmetros: NADA
Valor de retorno: Sem valor de retorno
Descrição: Limpa a lista removendo todos os elementos da lista. Lança “UnSupportedException” se a operação não for compatível com a lista.
O exemplo a seguir demonstrará os métodos size () e clear ().
import java.util.*; public class Main { public static void main(String() args) { List strList = new ArrayList(); // Creating a list //add items to list strList.add('Java'); strList.add('C++'); //print the size of list System.out.println('Size of list:' + strList.size()); //add more items to list strList.add('Ruby'); strList.add('Python'); strList.add('C#'); //print the size of list again System.out.println('Size of list after adding more elements:' + strList.size()); //clear method strList.clear(); System.out.println('List after calling clear() method:' + strList); } } Resultado:
adicionar
Protótipo: void add (int index, Object element)
Parâmetros: índice - uma posição na qual o elemento deve ser adicionado.
Elemento - o elemento a ser adicionado
Valor de retorno: vazio
Descrição: Adiciona o elemento fornecido à lista no índice fornecido. Os elementos subsequentes são deslocados para a direita.
As seguintes exceções são lançadas:
IndexOutOfBoundsException: O índice da lista está fora do intervalo
UnsupportedOperationException: A operação Adicionar não é suportada pela Lista.
ClassCastException: O elemento não pode ser adicionado à lista devido à classe dos elementos especificados.
Exceção de argumento ilegal: O elemento especificado ou algum aspecto não está correto.
Adicionar
Protótipo: boolean add (Object o)
Parâmetros: o => Elemento a ser adicionado à lista
Valor de retorno: true => Elemento adicionado com sucesso
Falso => Adicionar sem sucesso
Descrição: Este método adiciona o elemento fornecido no final da lista.
Esta operação pode lançar as seguintes exceções.
UnsupportedOperationException: Operação de adição não suportada por esta lista.
ClassCastException: O elemento especificado não pode ser adicionado por causa de sua classe
Exceção de argumento ilegal: O elemento especificado ou algum aspecto não está correto.
addAll
Protótipo: boolean addAll (coleção c)
Parâmetros: c => Coleção cujos elementos devem ser adicionados à lista
Valor de retorno: true => Execução do método com sucesso
Descrição: O método addAll pega todos os elementos da coleção ce os anexa ao final da lista, mantendo a ordem que foi definida.
Este método exibe um comportamento não especificado se a coleção for alterada quando a operação estiver em andamento.
O método lança as seguintes exceções:
UnsupportedOperationException: Operação de adição não suportada por esta lista.
ClassCastException: O elemento especificado não pode ser adicionado por causa de sua classe.
Exceção de argumento ilegal: O elemento especificado ou algum aspecto não está correto.
addAll
Protótipo: boolean addAll (int index, Collection c)
Parâmetros: índice => Posição em que a coleção deve ser inserida.
C => Coleção que deve ser inserida na lista.
Valor de retorno: true => Se os elementos da coleção forem adicionados com sucesso à lista.
Descrição: O método addAll insere todos os elementos da coleção especificada na lista do índice especificado. Os elementos subsequentes são então deslocados para a direita. Como no caso da sobrecarga anterior de addAll, o comportamento não é especificado se a coleção for alterada quando a operação estiver em andamento.
As exceções lançadas por este método são:
UnsupportedOperationException: Operação de adição não suportada por esta lista.
ClassCastException: O elemento especificado não pode ser adicionado por causa de sua classe.
Exceção de argumento ilegal: O elemento especificado ou algum aspecto não está correto.
IndexOutOfBoundsException: Índice fora do intervalo.
O programa abaixo mostra a demonstração dos métodos add e addAll da lista.
import java.util.*; public class Main { public static void main(String() args) { List strList = new ArrayList(); // Creating a list strList.add('Java'); strList.add('C++'); //print the list System.out.println('List after adding two elements:' + strList); List llist = new ArrayList(); // Create another list llist.add('Ruby'); llist.add('Python'); llist.add('C#'); // addAll method - add llist to strList strList.addAll(llist); System.out.println('List after addAll:'+ strList); } } Resultado:
contém
Protótipo: boolean contém (objeto o)
Parâmetros: o => Elemento a ser pesquisado na lista.
Valor de retorno: true => Se a lista contém o elemento especificado.
Descrição: O método ‘contém’ verifica se o elemento especificado está presente na lista e retorna um valor booleano verdadeiro se o elemento estiver presente. Caso contrário, ele retorna falso.
containsAll
Protótipo: boolean containsAll (coleção c)
Parâmetros: c => Coleção a ser pesquisada na lista.
Valor de retorno: true => Se todos os elementos da coleção especificada estiverem presentes na lista.
Descrição: O método “containsAll” verifica se todos os elementos presentes na coleção especificada estão presentes na lista. Se presente, ele retorna um valor verdadeiro e falso caso contrário.
O seguinte programa Java demonstra o uso dos métodos 'contém' e 'contémAll' da lista.
import java.util.*; public class Main { public static void main(String() args) { //define list of strings List list = new ArrayList(); //initialize list to strings list.add('Java'); list.add('Xml'); list.add('Python'); list.add('Ruby'); list.add('JavaScript'); //contains method demo if(list.contains('C')==true) System.out.println('Given list contains string 'C''); else if(list.contains('Java')==true) System.out.println('Given list contains string 'Java' but not string 'C''); //containsAll method demo List myList = new ArrayList(); myList.add('Ruby'); myList.add('Python'); if(list.containsAll(myList)==true) System.out.println('List contains strings 'Ruby' and 'Python''); } }Resultado:
A lista fornecida contém a string ‘Java’, mas não a string ‘C’
A lista contém strings ‘Ruby’ e ‘Python’
é igual a
Protótipo: boolean equals (objeto o)
Parâmetros: o => O objeto que deve ser testado quanto à igualdade.
Valor de retorno: true => Se o objeto fornecido for igual à lista.
Descrição: Este método é usado para comparar o objeto fornecido com a lista de igualdade. Se o objeto especificado for uma lista, o método retornará verdadeiro. Ambas as listas são consideradas iguais se e somente se forem do mesmo tamanho e os elementos correspondentes nas duas listas forem iguais e na mesma ordem.
Uma demonstração do método equals é fornecida abaixo:
import java.util.LinkedList; import java.util.List; public class Main { public static void main(String() args) { //define lists List first_list= new LinkedList(); List second_list = new LinkedList(); List third_list = new LinkedList(); //initialize lists with values for (int i=0;i<11;i++){ first_list.add(i); second_list.add(i); third_list.add(i*i); } //print each list System.out.println('First list: ' + first_list); System.out.println('Second list: ' + second_list); System.out.println('Third list: ' + third_list); //use equals method to check equality with each list to other if (first_list.equals(second_list) == true) System.out.println('
first_list and second_list are equal.
'); else System.out.println('first_list and second_list are not equal.
'); if(first_list.equals(third_list)) System.out.println('first_list and third_list are equal.
'); else System.out.println('first_list and third_list are not equal.
'); if(second_list.equals(third_list)) System.out.println('second_list and third_list are equal.
'); else System.out.println('second_list and third_list are not equal.
'); } } Resultado:
Obter
Protótipo: Object get (int index)
Parâmetros: índice => Posição em que o elemento deve ser retornado.
Valor de retorno: objeto => Elemento na posição especificada.
Descrição: O método get () retorna o elemento na posição fornecida.
Este método lança “indexOutOfBoundsException” se o índice especificado estiver fora do intervalo da lista.
Definir
Protótipo: Conjunto de objetos (índice interno, elemento de objeto)
Parâmetros: índice => Posição na qual o novo elemento deve ser definido.
elemento => Novo elemento a ser colocado na posição dada pelo índice.
Valor de retorno: Objeto => Elemento que foi substituído
Descrição: O método set () substitui o elemento no índice fornecido por outro valor fornecido por elemento.
O método pode lançar as seguintes exceções:
UnsupportedOperationException: A operação de definição não é suportada pela lista.
ClassCastException: A operação não pode ser realizada por causa da classe do elemento
Exceção de argumento ilegal: Argumento ou algum aspecto dele é ilegal
IndexOutOfBoundsException: Índice fora do intervalo.
O programa a seguir mostra um exemplo dos métodos get () e set ().
import java.util.*; public class Main { public static void main(String() args) { //define list List listA = new ArrayList(); listA.add('Java'); listA.add('C++'); listA.add('Python'); //access list elements using index with get () method System.out.println('Element at index 0:' + listA.get(0)); System.out.println('Element at index 1:' + listA.get(1)); System.out.println('Element at index 2:' + listA.get(2)); //set element at index 1 to Ruby listA.set(1,'Ruby'); System.out.println('Element at index 1 changed to :' + listA.get(1) ); } } Resultado:
hashCode
Protótipo: int hashCode ()
Parâmetros: NADA
Valor de retorno: int => hashCode da lista
Descrição: O método ‘hashCode ()’ retorna o hashCode da lista, que é um valor inteiro.
Exemplo:
qual é o melhor software de cópia de dvd
import java.util.*; public class Main { public static void main(String() args) { // Initializing a list of type Linkedlist List mylist = new LinkedList(); mylist.add(1); mylist.add(3); mylist.add(5); mylist.add(7); //print the list System.out.println('The list:' + mylist); //use hashCode() method to find hashcode of list int hash = mylist.hashCode(); System.out.println('Hashcode for list:' + hash); } } Resultado:
está vazia
Protótipo: boolean isEmpty ()
Parâmetros: NADA
Valor de retorno: verdadeiro => A lista está vazia
Descrição: O método ‘isEmpty ()’ verifica se a lista está vazia. O método IsEmpty é usado para verificar se a lista contém algum elemento antes de você começar a processar esses elementos.
índice de
Protótipo: int indexOf (Object o)
Parâmetros: o => elemento a ser pesquisado na lista
Valor de retorno: int => o índice ou posição da primeira ocorrência do elemento fornecido na lista. Retorna -1 se o elemento não estiver presente.
Descrição: O método ‘indexOf ()’ retorna o índice da primeira ocorrência do elemento o fornecido na lista. Se o elemento não for encontrado, ele retorna -1.
lastIndexOf
Protótipo: int lastIndexOf (Object o)
Parâmetros: o => Objeto cujo índice deve ser pesquisado
Valor de retorno: int => Índice da última ocorrência do elemento dado na lista, -1 caso contrário.
Descrição: O método ‘lastIndexOf ()’ retorna o índice da última ocorrência do elemento o na lista. Se o elemento não for encontrado, o método retorna -1.
O programa Java abaixo demonstra o uso dos métodos indexOf e lastIndexOf da lista.
import java.util.*; public class Main { public static void main(String() args) { // define an integer array List intList = new ArrayList(5); //add elements to the list intList.add(10); intList.add(20); intList.add(30); intList.add(10); intList.add(20); //print the list System.out.println('The list of integers:' + intList); // Use indexOf() and lastIndexOf() methods of list to find first and last index System.out.println('first index of 20:' + intList.indexOf(20)); System.out.println('last index of 10:' + intList.lastIndexOf(10)); } } Resultado:
retirar
Protótipo: Remoção de objeto (índice interno)
Parâmetros: índice => Índice ou posição na lista em que o elemento deve ser removido
Valor de retorno: Objeto => Elemento removido
Descrição: O método ‘remove ()’ remove o elemento na posição fornecida da lista. Após a exclusão, os elementos próximos ao elemento excluído são deslocados para a esquerda.
Este método pode lançar as seguintes exceções:
UnsupportedOperationException: Remover não é compatível com a lista.
IndexOutOfBoundsException: O índice especificado está fora do intervalo
retirar
Protótipo: boolean remove (objeto o)
Parâmetros: o => Elemento a ser removido da lista
Valor de retorno: true => Elemento removido com sucesso.
Descrição: Essa versão sobrecarregada do método remove () remove a primeira ocorrência de um determinado elemento o da lista. Se o elemento fornecido não estiver presente na lista, ele permanecerá inalterado.
Este método pode lançar a seguinte exceção:
UnsupportedOperationException: Remover não é compatível com a lista.
deletar tudo
Protótipo: boolean removeAll (coleção c)
Parâmetros: c => Uma coleção que contém elementos que são removidos da lista.
Valor de retorno: true => Se a chamada do método for bem-sucedida e todos os elementos especificados na coleção c forem removidos da lista.
Descrição: O método ‘removeAll ()’ é usado para remover todos os elementos da lista que são especificados na coleção c que é passada como um argumento.
Este método pode lançar a seguinte exceção:
UnsupportedOperationException: removeAll não é compatível com a lista.
Vejamos um exemplo dos métodos remove e removeAll.
import java.util.*; public class Main { public static void main(String() args) { // Creating a list List oddList = new ArrayList(); //add elements to the list oddList.add(1); oddList.add(3); oddList.add(5); oddList.add(7); oddList.add(9); oddList.add(11); //print the original list System.out.println('Original List:' + oddList); // Removes element from index 1 oddList.remove(1); System.out.println('Oddlist after removing element at index 1:' + oddList); //removeAll method List c1 = new ArrayList(); c1.add(1); c1.add(5); c1.add(11); oddList.removeAll(c1); System.out.println('Oddlist after removing elements {1,5,11}}:' + oddList); } } Resultado:
reter tudo
Protótipo: boolean reterAll (coleção c)
Parâmetros: c => Coleção que contém elementos que devem ser retidos na lista.
Valor de retorno: true => Se a chamada do método mudou a lista.
Descrição: Este método remove todos os elementos da lista, exceto aqueles que estão presentes na coleção c. Em outras palavras, esse método retém todos os elementos da lista que estão presentes na coleção ce remove os outros elementos.
Este método pode lançar a seguinte exceção:
UnsupportedOperationException: holdingAll não é compatível com a lista.
import java.util.*; public class Main { public static void main(String() args) { // Creating a list List oddList = new ArrayList(); //add elements to the list oddList.add(1); oddList.add(3); oddList.add(5); oddList.add(7); oddList.add(9); oddList.add(11); //print the original list System.out.println('Original List:' + oddList); //retainAll method List c1 = new ArrayList(); c1.add(1); c1.add(5); c1.add(11); oddList.retainAll(c1); System.out.println('Oddlist after call to retainAll (1,5,11):' + oddList); } } Resultado:
subList
Protótipo: List subList (int fromIndex, int toIndex)
Parâmetros: fromIndex => Índice inferior da lista (inclusivo)
toIndex => Índice mais alto da lista (exclusivo)
Valor de retorno: Lista => Uma sub-lista da lista fornecida
Descrição: O método sublist () retorna a visualização parcial da lista, também conhecida como sublista de ‘fromIndex’ para ‘toIndex’. A sublista retornada é apenas uma visualização da lista pai e, portanto, quaisquer alterações feitas em qualquer lista refletem em todos os lugares.
Da mesma forma, todas as operações da lista também funcionam em uma sublista.
O método pode lançar a seguinte exceção:
IndexOutOfBoundsException: Valor toIndex ilegal.
Um exemplo de programa para o método de sublista é fornecido abaixo.
import java.util.*; public class Main { public static void main(String() args) { // define a string list List strList = new ArrayList(5); //add elements to the list strList.add('Java'); strList.add('Tutorials'); strList.add('Collection'); strList.add('Framework'); strList.add('Series'); //print the original list System.out.println('The original list=>strList: ' + strList); //define another list List subList = new ArrayList(); // take a sublist of elements from 2 to 4 from strList subList = strList.subList(2, 4); //print the sublist System.out.println('The sublist of strList:' + subList); } } Resultado:
lista de classificação
Protótipo: void sort (Comparador c)
Parâmetros: c => Comparador com base no qual a lista é classificada.
Valor de retorno: NADA
Descrição: O método ‘sort ()’ é usado para classificar a lista. O método usa o comparador especificado para classificar a lista.
Vamos ver um exemplo do método de classificação . Nós o comparamos com o método Collections.sort que classifica os elementos em uma seqüência natural. A saída do programa é uma lista ordenada.
import java.util.Collections; import java.util.ArrayList; import java.util.List; import java.util.Random; public class Main { public static void main(String() args) { //define list List intArray = new ArrayList(); Random random = new Random(); //populate the list with random numbers <20 for (int i = 0; i {return (o2-o1);}); //comparator to sort in reverse System.out.println('Reverse List sorted using comparator:
'+intArray); } }Resultado:
toArray
Protótipo: Object () toArray ()
Parâmetros: NADA
Valor de retorno: Objeto () => Representação de array da lista
Descrição: O método toArray () retorna a representação da matriz da lista em uma seqüência adequada.
toArray
Protótipo: Object () toArray (Object () a)
Parâmetros: a => Tipo de matriz que deve ser correspondido aos tipos de elemento da lista ao converter a lista em uma matriz.
Valor de retorno: Objeto () => Representação de array da lista.
Descrição: Essa sobrecarga do método toArray () retorna a matriz que contém elementos na lista que têm o mesmo tipo de tempo de execução da matriz a.
Este método pode lançar a seguinte exceção:
ArrayStoreException: O tipo de tempo de execução de cada elemento da lista não é um subtipo do tipo de tempo de execução de cada elemento desta Lista.
A seguir está um exemplo da implementação do método toArray.
import java.util.*; public class Main { public static void main(String() args) { // create list ArrayList colorsList = new ArrayList(7); // add colors to colorsList colorsList.add('Violet'); colorsList.add('Indigo'); colorsList.add('Blue'); colorsList.add('Green'); colorsList.add('Yellow'); colorsList.add('Orange'); colorsList.add('Red'); System.out.println('Size of the colorsList: ' + colorsList.size()); // Print the colors in the list System.out.println('Contents of colorsList:'); for (String value : colorsList){ System.out.print(value + ' '); } // Create an array from the list using toArray method String colorsArray() = new String(colorsList.size()); colorsArray = colorsList.toArray(colorsArray); // Display the contents of the array System.out.println('
Printing elements of colorsArray:' + Arrays.toString(colorsArray)); } }Resultado:
Iterator
Protótipo: Iterator iterator ()
Parâmetros: NADA
Valor de retorno: Iterator => Iterator para iterar sobre os elementos da lista
Descrição: Este método retorna o iterador que itera sobre os elementos da lista.
Programa Java para demonstrar o uso de iterador.
import java.util.*; public class Main { public static void main(String() args) { // create list ArrayList colorsList = new ArrayList(7); // add colors to colorsList colorsList.add('Violet'); colorsList.add('Indigo'); colorsList.add('Blue'); colorsList.add('Green'); colorsList.add('Yellow'); colorsList.add('Orange'); colorsList.add('Red'); System.out.println('ColorList using iterator:'); //define iterator for colorsList Iterator iterator = colorsList.iterator(); //iterate through colorsList using iterator and print each item while(iterator.hasNext()){ System.out.print(iterator.next() + ' '); } } } Resultado:
listIterator
Protótipo: ListIterator listIterator ()
Parâmetros: NADA
Valor de retorno: ListIterator => Listiterator dos elementos da lista.
Descrição: O método listIterator () retorna o objeto ListIterator dos elementos da lista. Este iterador começa no início da lista, ou seja, índice 0.
listIterator
Protótipo: ListIterator listIterator (índice interno)
Parâmetros: index => Posição na qual listIterator começa.
Valor de retorno: ListIterator => objeto ListIterator no índice especificado na lista.
Descrição: A sobrecarga do método listIterator () retorna um listIterator que começa na posição fornecida na lista. O índice fornecido indica que ele será o primeiro elemento que será retornado pela primeira chamada ao método nextElement () de ListIterator.
O método pode lançar IndexOutOfBoundsException para o valor inválido do índice.
servidor privado vanilla world of warcraft
O exemplo a seguir demonstra o uso de listIterator.
import java.util.*; public class Main { public static void main(String() args) { //define list & add items to list List nameList = new LinkedList(); nameList.add('Java'); nameList.add('C++'); nameList.add('Python'); // get listIterator for the list ListIterator namesIterator = nameList.listIterator(); // Traverse list using listiterator and print each item System.out.println('Contents of list using listIterator:'); while(namesIterator.hasNext()){ System.out.print(namesIterator.next() + ' '); } } } Resultado:
Discutiremos ListIterator em detalhes posteriormente.
Vamos agora discutir algumas das operações diversas que podem ser feitas em listas, mas métodos para os quais não são fornecidos na interface de lista.
Copiar lista em Java
Para copiar elementos de uma lista para outra lista, você deve usar o método copy () fornecido pelo framework Collections.
O método Collections.copy () copia todos os elementos da lista fornecida como segundo argumento, para a lista fornecida como primeiro argumento. Observe que a lista para a qual o conteúdo de outra lista está sendo copiado deve ser grande o suficiente para acomodar os elementos copiados.
Se a lista não for grande o suficiente, o método de cópia gerará “indexOutOfBoundsEexception”.
O programa a seguir copia o conteúdo de uma lista para outra.
import java.util.*; public class Main { public static void main(String() args) { //create first ArrayList object List aList_1 = new ArrayList(); //Add elements to first ArrayList aList_1.add('R'); aList_1.add('G'); aList_1.add('B'); //print the List System.out.println('The first list:' + aList_1); //create second ArrayList object List aList_2 = new ArrayList(); //Add elements to second Arraylist aList_2.add('Red'); aList_2.add('Green'); aList_2.add('Blue'); aList_2.add('Yellow'); aList_2.add('Brown'); System.out.println('The second list: ' + aList_2); //use Collections.copy() method to copy elements of first list to second list. Collections.copy(aList_2,aList_1); //print the resultant second Arraylist System.out.println('
The second list after copying first list to second list: ' + aList_2); } } Resultado:
Remova duplicatas de uma lista em Java
Uma determinada lista pode ou não ter elementos repetitivos ou duplicados. Se a lista com a qual você está trabalhando possui elementos duplicados e você deseja todos os elementos distintos na lista, existem dois métodos para remover duplicatas da lista com suporte em Java.
Usando Java 8 stream
O primeiro método para remover duplicatas da lista é usando o método distinto () fornecido pelo fluxo Java 8. Aqui, a lista contendo duplicatas invoca o método stream () .distinct e, em seguida, o valor de retorno é convertido em uma nova lista que terá apenas os elementos distintos.
O programa a seguir demonstra o uso do método distinto ().
import java.util.*; import java.util.stream.Collectors; class Main { public static void main(String() args) { // original list List intlist = new ArrayList( Arrays.asList(1, 1, 1, 2, 2, 3, 3, 3, 4, 5, 5,6,5,3,4)); // Print the list System.out.println('Original ArrayList: ' + intlist); // using distinct() method of Java 8 stream remove duplicates from original List //and generate a new list without duplicates List distinct_list = intlist.stream().distinct() .collect(Collectors.toList()); // Print the new list System.out.println('ArrayList after removing duplicates: ' + distinct_list); } } Resultado:
Usando abordagem Iterator
Remover duplicatas da lista usando o iterador é uma abordagem longa e primitiva. Nessa abordagem, você deve percorrer a lista e colocar a primeira ocorrência de cada elemento em uma nova lista. Cada elemento subsequente é verificado se é uma duplicata.
O programa abaixo consegue isso.
import java.util.*; public class Main { public static void main(String args()) { // create original list ArrayList aList = new ArrayList( Arrays.asList(1, 1, 1, 2, 2, 3, 3, 3, 4, 5, 5, 6, 5, 3, 4)); // Print the original list System.out.println('Original List: '+ aList); // Create a new list ArrayList new_List = new ArrayList(); // Traverse through the original list to remove duplicates for (Integer element : aList) { // check if element is present in new_List, else add it if (!new_List.contains(element)) { new_List.add(element); } } // Print the new list without duplicates System.out.println('List after removing duplicates: '+ new_List); } } Resultado:
perguntas frequentes
P # 1) Qual é o método get na lista em Java?
Responda: O método Get da lista é usado para recuperar um elemento específico da lista com base no índice. Você passa o índice necessário para o método get e o método get retornará o valor do elemento nesse índice.
P # 2) Qual é o método toArray em Java?
Responda: O método toArray () é usado para obter a representação da matriz da lista.
P # 3) Como você classifica uma lista em Java?
Responda: Em Java, uma lista pode ser classificada usando o método de classificação da lista. Você pode passar seus próprios critérios de classificação usando a interface do comparador que é passada para o método de classificação como um parâmetro.
Você também pode usar coleções. Método de classificação para classificar a lista. Este método classifica a lista de acordo com a ordem natural.
Q # 4) O que é Arrays.asList () em Java?
Responda: O método ‘asList’ de array retorna a lista de elementos apoiados por um array.
Conclusão
Neste tutorial, aprendemos todos os métodos que uma lista fornece. A lista Java fornece vários métodos usando os quais você pode manipular e processar listas, incluindo pesquisa, classificação, etc. Explicamos cada método com exemplos de programação apropriados aqui.
Em nosso próximo tutorial, discutiremos o ListIterator em detalhes.
=> Explore a série de treinamento simples em Java aqui.
Leitura recomendada
- Lista Java - Como criar, inicializar e usar a lista em Java
- Lista secreta para matriz e outras coleções em Java
- Python Advanced List Tutorial (List Sort, Reverse, Index, Copy, Join, Soma)
- Lista Python - criar, acessar, dividir, adicionar ou excluir elementos
- Threads Java com métodos e ciclo de vida
- Remover / excluir um elemento de um array em Java
- Tutorial de Java String | Métodos Java String com exemplos
- Lista de endereços IP do roteador padrão para marcas comuns de roteadores sem fio