arraylist methods java tutorial with example programs
Neste tutorial, discutiremos os métodos Java ArrayList, como add, addAll, remove, removeAll, size, contém, retémAll, Classifica, Reverter, etc. com exemplos:
No tutorial anterior, exploramos a estrutura de dados ArrayList e a classe ArrayList fornecida para essa estrutura / coleção de dados em Java. Aprendemos a criação, inicialização, etc. dos objetos ArrayList.
Além desses recursos que nos ajudam a definir ArrayList, a classe ArrayList em Java também fornece uma API de função completa que consiste em métodos usados para manipular objetos ArrayList.
=> Verifique TODOS os tutoriais Java aqui.
Esses métodos nos permitem adicionar, excluir, pesquisar elementos no ArrayList, bem como recuperar o comprimento / tamanho dos elementos ArrayList, etc.
Neste tutorial, discutiremos esses métodos em detalhes com exemplos de programação simples.
O que você aprenderá:
- Métodos ArrayList em Java
- ArrayList add
- ArrayList addAll
- ArrayList Adicionar à Frente
- ArrayList remove
- ArrayList removeAll
- ArrayList removeRange
- Tamanho de ArrayList (comprimento)
- ArrayList contém
- ArrayList get
- Conjunto de ArrayList (Substituir elemento)
- ArrayList limpo
- ArrayList isEmpty
- ArrayList indexOf
- ArrayList lastIndexOf
- ArrayList toArray
- Clone ArrayList
- ArrayList subList
- ArrayList retêmAll
- ArrayList Iterator
- ArrayList listIterator
- Adicionar Array a ArrayList em Java
- Classificar ArrayList em Java
- Reverter um ArrayList em Java
- Remover duplicatas de um ArrayList em Java
- Shuffle (Randomize) Um ArrayList em Java
- perguntas frequentes
- Conclusão
Métodos ArrayList em Java
A tabela a seguir lista todos os métodos fornecidos pela classe ArrayList.
Método | Protótipo de Método | Descrição do Método |
---|---|---|
Contém | boolean contém (objeto o) | Verifica se a lista contém o elemento ‘o’ fornecido. Retorna verdadeiro se o elemento estiver presente. |
Adicionar | adição booleana (E e) | Adiciona o elemento e fornecido ao final da lista. |
void add (int índice, elemento E) | Adiciona determinado elemento ‘elemento’ na posição especificada ‘índice’. | |
AddAll | boolean addAll (coleção c) | Adiciona todos os elementos da coleção c fornecida ao final da lista. |
boolean addAll (int index, Collection c) | Adiciona todos os elementos da coleção c fornecida na posição especificada pelo ‘índice’ na lista. | |
Claro | void clear () | Limpa a lista removendo todos os elementos da lista. |
Clone | Clone de objeto () | Faz uma cópia superficial do ArrayList fornecido. |
garantir a capacidade | void garantirCapacity (int minCapacity) | Aumenta a capacidade do ArrayList para garantir que ele tenha minCapacity. |
Obter | E get (índice interno) | Retorna o elemento na lista presente na posição especificada por ‘índice’. |
índice de | int indexOf (Object o) | Retorna o índice da primeira ocorrência do elemento o na lista. -1 se o elemento o não estiver presente na lista. |
está vazia | boolean isEmpty () | Verifica se a lista fornecida está vazia. |
Iterator | Iterator iterator () | Retorna um iterador para percorrer os elementos da lista na sequência adequada. |
lastIndexOf | int lastIndexOf (Object o) | Retorna o índice da última ocorrência do elemento especificado o na lista. -1 se o elemento não estiver presente na lista. |
listIterator | ListIterator listIterator () | Retorna o iterador de lista para percorrer os elementos da lista fornecida. |
ListIterator listIterator (índice interno) | Retorna o iterador da lista a partir da posição especificada 'índice' para percorrer os elementos da lista fornecida. | |
retirar | E remove (índice interno) | Exclui o elemento no ‘índice’ na ArrayList. |
boolean remove (objeto o) | Exclui a primeira ocorrência do elemento o da lista. | |
deletar tudo | boolean removeAll (coleção c) | Remove todos os elementos da lista que correspondem aos elementos de determinada coleção c. |
removeRange | protected void removeRange (int fromIndex, int toIndex) | Remove os elementos especificados no intervalo fornecido, fromIndex (inclusivo) a toIndex (exclusivo) da lista. |
reter tudo | boolean reterAll (coleção c) | Retém os elementos da lista que correspondem aos elementos da coleção fornecida c. |
definir | E conjunto (índice interno, elemento E) | Define o valor do elemento em determinado 'índice' para o novo valor fornecido por 'elemento'. |
Tamanho | tamanho interno () | Retorna o número total de elementos ou comprimento da lista. |
subList | List subList (int fromIndex, int toIndex) | Retorna uma subList entre o intervalo fornecido, deIndex a toIndex para a lista fornecida. |
toArray | Object [] toArray () | Converte a lista fornecida em uma matriz. |
T [] toArray (T [] a) | Converte a lista fornecida em uma matriz do tipo fornecido por a. | |
trimToSize | void trimToSize () | Reduz a capacidade de ArrayList para o tamanho ou número de elementos presentes na lista. |
A seguir, discutiremos cada um desses métodos da API de função ArrayList em detalhes e apresentaremos exemplos de programação. Depois de discutir todos os métodos listados acima, também abordaremos algumas operações específicas que são realizadas usando ArrayLists que não fazem parte da API de função ArrayList.
ArrayList add
eu
Protótipo: adição booleana (E e)
Parâmetros: e => Elemento a ser adicionado ao ArrayList.
Valor de retorno: true => Elemento adicionado com sucesso.
Descrição: Adiciona o elemento e fornecido ao final da lista.
II.
como eu abro um arquivo torrent
Protótipo: void add (int índice, elemento E)
Parâmetros:
índice => Posição em que o elemento deve ser adicionado.
Elemento => Elemento a ser adicionado ao ArrayList.
Valor de retorno: vazio
Descrição: Adiciona determinado elemento ‘elemento’ na posição especificada ‘índice’ deslocando o elemento nessa posição e os elementos subsequentes para a direita.
Exceções: IndexOutOfBoundsException => Se o índice especificado estiver fora do intervalo.
ArrayList addAll
eu
Protótipo: boolean addAll (coleção c)
Parâmetros: c => Coleção cujos elementos devem ser adicionados ao ArrayList.
Valor de retorno: true => Se a operação alterou o ArrayList.
Descrição: Adiciona todos os elementos da coleção c fornecida ao final da lista. O resultado da operação é indefinido se a coleção for alterada durante o andamento da operação.
Exceções: NullPointerException => Se a coleção fornecida c for nula.
il
Protótipo: boolean addAll (int index, Collection c)
Parâmetros: índice => Posição na qual os elementos da coleção dada devem ser adicionados.
Valor de retorno: true => Se a lista mudou como resultado da operação.
Descrição: Adiciona todos os elementos da coleção c fornecida na posição especificada pelo ‘índice’ na lista. O elemento no índice especificado e os elementos subsequentes são deslocados para a direita. O resultado da operação é indefinido se a coleção que está sendo adicionada for alterada quando a operação estiver em andamento.
Exceções: IndexOutOfBoundsException: se o índice onde a coleção deve ser adicionada estiver fora dos limites
NullPointerException: se a coleção fornecida c for nula.
O programa Java a seguir demonstra o uso dos métodos add e addAll.
import java.util.*; class Main{ public static void main(String args[]){ //create an ArrayList ArrayList city_List=new ArrayList(); //add elements to the ArrayList using add method city_List.add('Delhi'); city_List.add('Mumbai'); city_List.add('Chennai'); city_List.add('Kolkata'); //print the list System.out.println('Initial ArrayList:' + city_List); //add an element at index 1 using add method overload city_List.add(1, 'NYC'); //print the list System.out.println('
rrayList after adding element at index 1:' + city_List); //define a second list ArrayList more_Cities = new ArrayList(Arrays.asList('Pune', 'Hyderabad')); //use addAll method to add the list to ArrayList at index 4 city_List.addAll(4,more_Cities); //print the list System.out.println('
ArrayList after adding list at index 4:' + city_List); } }
Resultado:
ArrayList inicial: [Delhi, Mumbai, Chennai, Kolkata]
rrayList após adicionar elemento no índice 1: [Delhi, NYC, Mumbai, Chennai, Kolkata]
ArrayList após adicionar lista no índice 4: [Delhi, NYC, Mumbai, Chennai, Pune, Hyderabad, Kolkata]
O programa acima usa ambas as versões do método add para adicionar elementos à lista. Ele também adiciona uma coleção à lista no índice especificado. Observe o deslocamento dos elementos à direita da ArrayList, conforme evidente na saída do programa.
ArrayList Adicionar à Frente
Como já mencionado, a primeira versão do método add adiciona os elementos ao final da lista. Se você quiser adicionar os elementos no início da ArrayList, terá que usar a segunda versão do método add. Este método add leva um índice como parâmetro. Este índice é a posição na qual o elemento deve ser adicionado.
Assim, para adicionar o elemento no início da lista, você deve especificar o índice como 0, que é o início da lista.
O programa a seguir adiciona um elemento à frente da ArrayList.
import java.util.ArrayList; public class Main { public static void main(String[] args) { //define new ArrayList and initialize it ArrayList numList = new ArrayList(); numList.add(5); numList.add(7); numList.add(9); //print the ArrayList System.out.println('Initial ArrayList:'); System.out.println(numList); //use add method with index=0 to add elements to the beginning of the list numList.add(0, 3); numList.add(0, 1); System.out.println('ArrayList after adding elements at the beginning:'); //print ArrayList System.out.println(numList); } }
Resultado:
ArrayList inicial:
[5, 7, 9]
ArrayList após adicionar elementos no início:
[1, 3, 5, 7, 9]
ArrayList remove
EU.
Protótipo: E remove (índice interno)
Parâmetros: index => Posição na qual o elemento deve ser removido do ArrayList.
Valor de retorno: E => Elemento que foi excluído
Descrição: Exclui o elemento no ‘índice’ na ArrayList e move os elementos subsequentes para a esquerda.
Exceções: IndexOutOfBoundsException => Índice especificado está fora do intervalo.
II.
Protótipo: boolean remove (objeto o)
Parâmetros: o => Elemento que deve ser removido da ArrayList.
Valor de retorno: true => se o elemento estiver presente na lista.
Descrição: Exclui a primeira ocorrência do elemento o da lista. Se o elemento não estiver presente na lista, não haverá efeito desta operação. Depois que o elemento é excluído, os elementos subsequentes são deslocados para a esquerda.
ArrayList removeAll
Protótipo: boolean removeAll (coleção c)
Parâmetros: c => Coleção cujos elementos correspondem aos de ArrayList e devem ser removidos.
Valor de retorno: true => Se o ArrayList for alterado pela operação.
Descrição: Remove todos os elementos da lista que correspondem aos elementos da coleção fornecida c. Como resultado, os elementos restantes são deslocados para a esquerda da lista.
Exceções: ClassCastException => Class não é a mesma da coleção especificada, o que implica que a classe é incompatível.
NullPointerException => Se a coleção fornecida c for nula; ou se c tiver um elemento nulo e não for permitido pela coleção.
ArrayList removeRange
Protótipo: protected void removeRange (int fromIndex, int toIndex)
Parâmetros: fromIndex => Índice do elemento inicial do intervalo a ser removido.
toIndex => Índice do elemento após o último elemento no intervalo a ser removido.
Valor de retorno: vazio
Descrição: Remove os elementos especificados no intervalo fornecido, fromIndex (inclusivo) a toIndex (exclusivo) da lista. Esta operação reduz o comprimento da lista em (toIndex-fromIndex). Esta operação não tem efeito no caso de fromIndex = toIndex.
Exceções: IndexOutOfBoundsException => Se algum dos índices (fromIndex ou toIndex) estiver fora dos limites.
Vamos implementar um programa Java para demonstrar alguns desses métodos de remoção que discutimos acima.
import java.util.*; class Main{ public static void main(String args[]){ //create an ArrayList ArrayList city_List=new ArrayList(Arrays.asList('Delhi','Mumbai','Chennai', 'Kolkata', 'Pune', 'Hyderabad')); //print the list System.out.println('Initial ArrayList:' + city_List); //remove element at index 2 city_List.remove(2); //print the list System.out.println('
ArrayList after removing element at index 2:' + city_List); //remove the element 'Kolkata' city_List.remove('Kolkata'); //print the list System.out.println('
ArrayList after removing element -> Kolkata:' + city_List); //create new list ArrayList newCities=new ArrayList(Arrays.asList('Delhi','Hyderabad')); //call removeAll to remove elements contained in newCities list. city_List.removeAll(newCities); //print the list System.out.println('
ArrayList after call to removeAll:' + city_List); } }
Resultado:
ArrayList inicial: [Delhi, Mumbai, Chennai, Kolkata, Pune, Hyderabad
ArrayList após remover o elemento no índice 2: [Delhi, Mumbai, Kolkata, Pune, Hyderabad]
ArrayList após a remoção do elemento -> Calcutá: [Delhi, Mumbai, Pune, Hyderabad]
ArrayList após chamada para removeAll: [Mumbai, Pune]
Tamanho de ArrayList (comprimento)
Protótipo: tamanho interno ()
Parâmetros: NADA
Valor de retorno: int => Número de elementos em ArrayList.
Descrição: Retorna o número total de elementos ou o comprimento da ArrayList.
VerifyCapacity
Protótipo: void garantirCapacity (int minCapacity)
Parâmetros: minCapacity => A capacidade mínima desejada para o ArrayList.
Valor de retorno: vazio
Descrição: Aumenta a capacidade do ArrayList para garantir que ele tenha minCapacity.
trimToSize
Protótipo: void trimToSize ()
Parâmetros: NADA
Valor de retorno: vazio
Descrição: Reduz a capacidade de ArrayList para o tamanho ou número de elementos presentes na lista.
O exemplo de programação a seguir demonstra os métodos size (), verifyCapacity () e trimToSize ().
import java.util.ArrayList; public class Main { public static void main(String [] args) { //Create and initialize Arraylist ArrayList evenList=new ArrayList(5); System.out.println('Initial size: '+evenList.size()); evenList.add(2); evenList.add(4); evenList.add(6); evenList.add(8); evenList.add(10); //print the list and size System.out.println('Original List: ' + evenList); System.out.println('ArrayList Size after add operation: '+evenList.size()); //call ensureCapacity () with minimum capacity =10 evenList.ensureCapacity(10); //add two more elements evenList.add(12); evenList.add(14); //print the size again System.out.println('ArrayList Size after ensureCapacity() call and add operation: '+evenList.size()); //call trimToSize() evenList.trimToSize(); //print the size and the ArrayList System.out.println('ArrayList Size after trimToSize() operation: '+evenList.size()); System.out.println('ArrayList final: '); for(int num: evenList){ System.out.print(num + ' '); } } }
Resultado:
Tamanho inicial: 0
Lista Original: [2, 4, 6, 8, 10]
Tamanho da ArrayList após a operação de adição: 5
Tamanho de ArrayList após a chamada de verifyCapacity () e operação de adição: 7
Tamanho de ArrayList após a operação trimToSize (): 7
Final ArrayList:
2 4 6 8 10 12 14
ArrayList contém
Protótipo: boolean contém (objeto o)
Parâmetros: o => Elemento que deve ser verificado se estiver presente no ArrayList.
Valor de retorno: true => Se o ArrayList contém o elemento o.
Descrição: Verifica se a lista contém o elemento ‘o’ fornecido. Retorna verdadeiro se o elemento estiver presente.
Usamos o método ‘contém’ no programa a seguir.
import java.util.ArrayList; public class Main { public static void main(String[] args) { //create and initialize colorsList ArrayList colorsList = new ArrayList(); colorsList.add('Red'); colorsList.add('Green'); colorsList.add('Blue'); colorsList.add('White'); //call contains method to check if different strings are present in ArrayList System.out.println('ArrayList contains ('Red Green'): ' +colorsList.contains('Red Green')); System.out.println('ArrayList contains ('Blue'): ' +colorsList.contains('Blue')); System.out.println('ArrayList contains ('Yellow'): ' +colorsList.contains('Yellow')); System.out.println('ArrayList contains ('White'): ' +colorsList.contains('White')); } }
Resultado:
ArrayList contém (‘Red Green’): false
ArrayList contém (‘Blue’): verdadeiro
ArrayList contém (‘Amarelo’): falso
ArrayList contém ('Branco'): verdadeiro
tutorial do servidor de 2015 da equipe do visual studio
Conforme mostrado na saída acima, o método ‘contém’ verifica se o argumento fornecido está presente na ArrayList e retorna verdadeiro ou falso.
ArrayList get
Protótipo: E get (índice interno)
Parâmetros: index => Índice no qual o elemento deve ser recuperado do ArrayList.
Valor de retorno: E => Valor do elemento no índice fornecido na ArrayList.
Descrição: Retorna o elemento na lista presente na posição especificada por ‘índice’.
Exceções: IndexOutOfBoundsException => Se o índice estiver fora dos limites.
Conjunto de ArrayList (Substituir elemento)
Protótipo: E conjunto (índice interno, elemento E)
Parâmetros: índice => Índice no qual o elemento deve ser substituído.
Elemento => Novo elemento a ser definido no índice especificado.
Valor de retorno: E => Elemento que é substituído pela operação de ajuste.
Descrição: Define o valor do elemento no 'índice' fornecido para o novo valor fornecido por 'elemento'.
Exceções: IndexOutOfBoundsException => Se o índice estiver fora dos limites
O programa Java abaixo usa os métodos get () e set () para recuperar e substituir valores na ArrayList.
import java.util.ArrayList; public class Main { public static void main(String[] args) { //create and initialize colorsList ArrayList colorsList = new ArrayList(); colorsList.add('Red'); colorsList.add('Green'); colorsList.add('Blue'); colorsList.add('White'); //call get () method to retrieve value at index 2 System.out.println('Entry at index 2 before call to set: ' + colorsList.get(2)); //replace the value at index 2 with new value colorsList.set(2,'Yellow'); //print the value at index 2 again System.out.println('Entry at index 2 after call to set: ' + colorsList.get(2)); } }
Resultado:
Entrada no índice 2 antes da chamada para definir: Azul
Entrada no índice 2 após chamada para definir: Amarelo
ArrayList limpo
Protótipo: void clear ()
Parâmetros: NADA
Valor de retorno: vazio
Descrição: Limpa a lista removendo todos os elementos da lista.
ArrayList isEmpty
Protótipo: boolean isEmpty ()
Parâmetros: NADA
Valor de retorno: verdadeiro => se a lista estiver vazia
Descrição: Verifica se a lista fornecida está vazia.
As funções Clear () e isEmpty () são demonstradas a seguir.
import java.util.ArrayList; public class Main { public static void main(String[] args) { //create and initialize colorsList ArrayList colorsList = new ArrayList(); colorsList.add('Red'); colorsList.add('Green'); colorsList.add('Blue'); colorsList.add('White'); //print the ArrayList System.out.println('The ArrayList: ' + colorsList); //call clear() nethod on ArrayList colorsList.clear(); //check if ArrayList is empty using isEmpty() method System.out.println('Is ArrayList empty after clear ()? :' + colorsList.isEmpty()); } }
Resultado:
The ArrayList: [Red, Green, Blue, White]
ArrayList está vazio após clear ()? :verdade
ArrayList indexOf
Protótipo: int indexOf (Object o)
Parâmetros: o => Elemento cujo índice se encontra na ArrayList.
Valor de retorno: int => Índice da primeira ocorrência do elemento na lista.
Descrição: Retorna o índice da primeira ocorrência do elemento o na lista. -1 se o elemento o não estiver presente na lista.
ArrayList lastIndexOf
Protótipo: int lastIndexOf (Object o)
Parâmetros: o => O elemento a ser pesquisado.
Valor de retorno: int => Índice da última ocorrência do elemento na lista.
Descrição: Retorna o índice da última ocorrência do elemento especificado o na lista. -1 se o elemento não estiver presente na lista.
O programa Java abaixo demonstra os métodos indexOf e lastIndexOf de ArrayList.
import java.util.ArrayList; public class Main { public static void main(String[] args) { //create and initialize intList ArrayList intList = new ArrayList(); intList.add(1); intList.add(1); intList.add(2); intList.add(3); intList.add(5); intList.add(3); intList.add(2); intList.add(1); intList.add(1); //print the ArrayList System.out.println('The ArrayList: ' + intList); //call indexOf() and lastIndexOf() methods to check the indices of specified elements System.out.println('indexOf(1) : ' + intList.indexOf(1)); System.out.println('lastIndexOf(1) : ' + intList.lastIndexOf(1)); System.out.println('indexOf(2) : ' + intList.indexOf(2)); System.out.println('lastIndexOf(2) : ' + intList.lastIndexOf(2)); System.out.println('indexOf(3) : ' + intList.indexOf(3)); System.out.println('lastIndexOf(3) : ' + intList.lastIndexOf(3)); System.out.println('indexOf(5) : ' + intList.indexOf(5)); System.out.println('lastIndexOf(5) : ' + intList.lastIndexOf(5)); } }
Resultado:
The ArrayList: [1, 1, 2, 3, 5, 3, 2, 1, 1]
indexOf (1): 0
lastIndexOf (1): 8
indexOf (2): 2
lastIndexOf (2): 6
indexOf (3): 3
lastIndexOf (3): 5
indexOf (5): 4
lastIndexOf (5): 4
ArrayList toArray
Protótipo: Object [] toArray ()
Parâmetros: NADA
Valor de retorno: Objeto [] => uma matriz. Este array retornado contém todos os elementos da lista em uma seqüência apropriada.
Descrição: Converte a lista fornecida em uma matriz.
Protótipo: T [] toArray (T [] a)
Parâmetros: a => Array para armazenar elementos da lista. Se o tamanho do array não for suficiente para os elementos da lista, outro array com o mesmo tipo de a é criado para armazenar os elementos.
Valor de retorno: T [] => Array que contém todos os elementos da lista.
Descrição: Converte a lista fornecida em uma matriz do tipo fornecido por a.
Exceções: ArrayStoreException => Se houver uma incompatibilidade no tipo de tempo de execução da matriz e tipo de tempo de execução ou supertipo de seus elementos.
NullPointerException => A matriz fornecida é nula
O programa Java abaixo demonstra o método toArray de ArrayList.
import java.util.*; public class Main { public static void main(String[] args) { // define and initialize ArrayList ArrayList intList = new ArrayList(); intList.add(10); intList.add(20); intList.add(30); intList.add(40); intList.add(50); // print ArrayList System.out.println('ArrayList: ' + intList); //declare array Integer myArray[] = new Integer[intList.size()]; //use toArray method to convert ArrayList to Array myArray = intList.toArray(myArray); //print the Array System.out.println('Array from ArrayList:' + Arrays.toString(myArray)); } }
Resultado:
ArrayList: [10, 20, 30, 40, 50]
Array de ArrayList: [10, 20, 30, 40, 50]
Clone ArrayList
Protótipo: Clone de objeto ()
Parâmetros: NADA
Valor de retorno: Objeto => Clone da instância ArrayList.
Descrição: Faz uma cópia superficial do ArrayList fornecido.
import java.util.ArrayList; public class Main { public static void main(String a[]){ ArrayList fruitsList = new ArrayList(); //Adding elements to the ArrayList fruitsList.add('Apple'); fruitsList.add('Orange'); fruitsList.add('Melon'); fruitsList.add('Grapes'); System.out.println('Original ArrayList: '+fruitsList); ArrayList clone_list = (ArrayList)fruitsList.clone(); System.out.println('Cloned ArrayList: '+ clone_list); //add one elmeent & remove one element from original arraylist fruitsList.add('Mango'); fruitsList.remove('Orange'); //print original and cloned ArrayList again System.out.println('
Original ArrayList after add & remove:'+fruitsList); System.out.println('Cloned ArrayList after original changed:'+clone_list); } }
Resultado:
ArrayList original: [maçã, laranja, melão, uvas]
Cloned ArrayList: [Apple, Orange, Melon, Grapes]
ArrayList original após adicionar e remover: [Apple, Melon, Grapes, Mango]
ArrayList clonado após alteração original: [Maçã, Laranja, Melão, Uvas]
A partir da saída do programa acima, você pode ver que a ArrayList clonada é uma cópia superficial da ArrayList original. Isso significa que quando o ArrayList original é alterado, essas alterações não se refletem no ArrayList clonado, pois não compartilham as localizações de memória de cada elemento.
Para fazer uma cópia profunda do Array, o ArrayList original precisa ser percorrido e cada um de seus elementos precisa ser copiado para o ArrayList de destino.
ArrayList subList
Protótipo: List subList (int fromIndex, int toIndex)
Parâmetros: fromIndex => Índice inicial do intervalo (inclusive)
toIndex => Índice final do intervalo (exclusivo)
Valor de retorno: Lista => Sublista da lista no intervalo determinado.
Descrição: Retorna uma subList entre um determinado intervalo, deIndex ao índice para a lista fornecida. Observe que esta sublista ou a visualização da lista no intervalo fornecido oferece suporte a todas as operações suportadas pela lista. Nenhuma visualização é retornada se fromIndex = toIndex.
Exceções: IndexOutOfBoundsException => Lançado quando toIndex está fora do intervalo.
IllegalArgumentException => If fromIndex> toIndex, ou seja, os índices estão fora de ordem.
Vejamos um exemplo do método subList.
import java.util.ArrayList; import java.util.List; class Main{ public static void main(String a[]){ //create and initialize the ArrayList ArrayList intList = new ArrayList(); intList.add(5); intList.add(10); intList.add(15); intList.add(20); intList.add(25); intList.add(30); intList.add(35); intList.add(40); intList.add(45); intList.add(50); //print the ArrayList System.out.println('Original ArrayList: '+intList); //create a sublist for the given ArrayList ArrayList sub_ArrayList = new ArrayList(intList.subList(2, 6)); //print the sublist System.out.println('Sublist of given ArrayList: '+sub_ArrayList); } }
Resultado:
ArrayList original: [5, 10, 15, 20, 25, 30, 35, 40, 45, 50]
Sublista de determinada ArrayList: [15, 20, 25, 30]
ArrayList retêmAll
Protótipo: boolean reterAll (coleção c)
Parâmetros: c => Coleção com elementos que devem ser retidos na lista.
Valor de retorno: true => Se ArrayList mudou como resultado da operação.
Descrição: Retém os elementos da lista que correspondem aos elementos da coleção fornecida c.
Exceções: ClassCastException => O tipo de coleção e o tipo de lista não correspondem
NullPointerException => A coleção fornecida é nula ou a lista contém elemento nulo e a coleção não permite nulos.
O programa a seguir demonstra o método holdingAll.
import java.util.*; class Main{ public static void main(String args[]){ //create and initialize ArrayList ArrayList colorsList=new ArrayList(); colorsList.add('Red'); colorsList.add('Green'); colorsList.add('Blue'); colorsList.add('Yellow'); //print the ArrayList System.out.println('Original ArrayList:' + colorsList); //define another collection ArrayList color_collection=new ArrayList(); color_collection.add('Red'); color_collection.add('Blue'); System.out.println('Collection elements to be retained in the list:' + color_collection); //call retainAll method with above collection as an argument colorsList.retainAll(color_collection); //print the ArrayList after retainAll call. System.out.println('ArrayList after retainAll call:' + colorsList); } }
Resultado:
ArrayList original: [vermelho, verde, azul, amarelo]
Elementos da coleção a serem mantidos na lista: [Vermelho, Azul]
ArrayList após a chamada reterAll: [Red, Blue]
ArrayList Iterator
Protótipo: Iterator iterator ()
Parâmetros: NADA
Valor de retorno: Iterator => iterador sobre os elementos da lista.
Descrição: Retorna um iterador para percorrer os elementos da lista na sequência adequada.
ArrayList listIterator
EU.
Protótipo: ListIterator listIterator ()
Parâmetros: NADA
Valor de retorno: ListIterator => listIterator sobre os elementos da lista.
Descrição: Retorna o iterador de lista para percorrer os elementos da lista fornecida.
II.
Protótipo: ListIterator listIterator (índice interno)
Parâmetros: index => Posição do primeiro elemento no listIterator.
Valor de retorno: ListIterator => ListIterator para a lista do índice especificado.
Descrição: Retorna o iterador da lista a partir da posição especificada 'índice' para percorrer os elementos da lista fornecida.
Exceções: IndexOutOfBoundsException => O índice fornecido está fora do intervalo.
Exemplo de métodos iterator () e listIterator ().
import java.util.*; class Main{ public static void main(String args[]){ //create ArrayList and initialize it ArrayList cities=new ArrayList(); cities.add('Mumbai'); cities.add('Pune'); cities.add('Hyderabad'); cities.add('Delhi'); //use iterator() method to traverse through the list System.out.println('List contents using Iterator () method:'); Iterator iter=cities.iterator(); while(iter.hasNext()){ System.out.print(iter.next() + ' '); } //use listIterator() method to traverse through the list System.out.println('
List contents using listIterator () method:'); ListIterator list_iter=cities.listIterator(); while(list_iter.hasNext()) { System.out.print(list_iter.next() + ' '); } } }
Resultado:
Liste o conteúdo usando o método Iterator ():
Mumbai Pune Hyderabad Delhi
Liste o conteúdo usando o método listIterator ():
Mumbai Pune Hyderabad Delhi
Adicionar Array a ArrayList em Java
ArrayList oferece suporte ao método addAll para adicionar elementos da coleção ao ArrayList. De maneira semelhante, você também pode adicionar um Array ao ArrayList. Isso é feito usando o método ‘Collections.addAll’.
Exemplo de adição de um Array ao ArrayList.
import java.util.*; class Main{ public static void main(String args[]){ //create an ArrayList ArrayList city_List=new ArrayList(); //add elements to the ArrayList using add method city_List.add('Delhi'); city_List.add('Mumbai'); city_List.add('Chennai'); city_List.add('Kolkata'); //print ArrayList System.out.println('
Initial ArrayList :' + city_List); //define an array. String[] myArray = new String[]{'Cochin', 'Goa'}; //add the array to the ArrayList Collections.addAll(city_List,myArray); //print the ArrayList System.out.println('
ArrayList after adding array :' + city_List); } }
Resultado:
ArrayList inicial: [Delhi, Mumbai, Chennai, Kolkata]
ArrayList após adicionar a matriz: [Delhi, Mumbai, Chennai, Kolkata, Cochin, Goa]
Classificar ArrayList em Java
ArrayList usa o método Collections.sort para classificar seus elementos. Por padrão, a lista é classificada em ordem crescente pelo método Collections.sort. Se a ArrayList deve ser classificada em ordem decrescente, você deve fornecer um parâmetro para o método de classificação ‘Collections.reverseOrder ()’.
A seguir está um programa para classificar uma ArrayList em ordem crescente e decrescente:
import java.util.*; public class Main { public static void main(String args[]){ //Create and initialize an ArrayList ArrayList colorsList = new ArrayList(); colorsList.add('Red'); colorsList.add('Green'); colorsList.add('Blue'); colorsList.add('Yellow'); //print initial ArrayList System.out.println('Initial ArrayList:' + colorsList); //sort ArrayList in ascending order Collections.sort(colorsList); //print sorted ArrayList System.out.println('
ArrayList sorted in ascending order:'); System.out.println(colorsList); //sort ArrayList in reverse(desending) order Collections.sort(colorsList, Collections.reverseOrder()); //print sorted list System.out.println('
ArrayList sorted in descending order:'); System.out.println(colorsList); } }
Resultado:
ArrayList inicial: [vermelho, verde, azul, amarelo]
ArrayList classificada em ordem crescente:
[Azul, Verde, Vermelho, Amarelo]
ArrayList classificado em ordem decrescente:
[Amarelo, Vermelho, Verde, Azul]
No caso de ArrayList conter outros objetos de classe como elementos, você pode usar as interfaces Comparable e Comparator. Mais detalhes sobre interfaces serão abordados em nossos tutoriais posteriores.
Reverter um ArrayList em Java
Você também pode reverter um ArrayList em Java. Um método para fazer isso é usar o método tradicional de percorrer o ArrayList na ordem inversa e copiar cada elemento para um novo ArrayList.
Outro método é usar a classe Collections, que fornece o método ‘reverso’ usado para reverter uma coleção.
perguntas da entrevista em html e css
O programa para reverter um ArrayList usando a classe Collections é fornecido abaixo.
import java.io.*; import java.util.*; public class Main { public static void main(String[] args) { // create and initialize an ArrayList ArrayList oddList = new ArrayList(); oddList.add(1); oddList.add(3); oddList.add(5); oddList.add(7); oddList.add(9); System.out.print('Initial ArrayList: ' + oddList); // use Collections.reverse method to reverse the ArrayList Collections.reverse(oddList); //print the ArrayList System.out.print('
Reversed ArrayList: ' + oddList); } }
Resultado:
ArrayList inicial: [1, 3, 5, 7, 9]
ArrayList invertido: [9, 7, 5, 3, 1]
Remover duplicatas de um ArrayList em Java
Para remover duplicatas do ArrayList, você pode mais uma vez recorrer ao método tradicional de usar um iterador para percorrer o ArrayList e armazenar apenas a primeira ocorrência do elemento em um ArrayList diferente.
Ainda outro método é usando o método 'distinto ()' da classe stream (). Este método retorna um fluxo de elementos distintos. O recurso stream () está disponível em Java a partir do Java 8 em diante.
A implementação do método stream () .distinct () é fornecida abaixo:
import java.util.*; import java.util.stream.Collectors; public class Main { public static void main(String[] args) { // Create an ArrayList of numbers ArrayList numList = new ArrayList (Arrays.asList(1, 2, 3, 1, 3, 5, 5, 6, 6, 7, 7, 8, 8)); //print the original ArrayList System.out.println('Original ArrayList:' + numList); //Use Java 8 stream().distinct() method to remove duplicates from the list List distinctList = numList.stream().distinct().collect(Collectors.toList()); //print the new list System.out.println('ArrayList without duplicates:' + distinctList); } }
Resultado:
ArrayList original: [1, 2, 3, 1, 3, 5, 5, 6, 6, 7, 7, 8, 8]
ArrayList sem duplicatas: [1, 2, 3, 5, 6, 7, 8]
Shuffle (Randomize) Um ArrayList em Java
Você também pode 'embaralhar' ou randomizar os elementos ArrayList. Isso é feito usando o método Collections.shuffle (). Usando este método, você pode embaralhar a ArrayList com as configurações padrão ou fornecer uma função random () que irá randomizar os elementos de acordo com o valor aleatório fornecido.
Um programa Java para fazer isso é fornecido abaixo.
import java.util.*; public class Main { public static void main(String[] args) { //create and initialize a String ArrayList ArrayList strlist = new ArrayList(); strlist.add('east'); strlist.add('west'); strlist.add('north'); strlist.add('south'); strlist.add('southwest'); strlist.add('northeast'); //print the original list System.out.println('Original ArrayList :
' + strlist); //shuffle the ArrayList without random function Collections.shuffle(strlist); System.out.println('
Shuffled ArrayList without Random() :
' + strlist); // shuffle the ArrayList with random() function Collections.shuffle(strlist, new Random()); System.out.println('
Shuffled ArrayList with Random() :
' + strlist); // use random (2) to shuffle the ArrayList Collections.shuffle(strlist, new Random(2)); System.out.println('
Shuffled ArrayList with Random(2) :
' + strlist); } }
Resultado:
ArrayList original: [leste, oeste, norte, sul, sudoeste, nordeste] ArrayList aleatório sem Random (): [norte, nordeste, leste, sudoeste, sul, oeste]
ArrayList embaralhado com Random (): [sul, leste, norte, nordeste, oeste, sudoeste]
ArrayList embaralhado com Random (2): [sudoeste, sul, leste, nordeste, norte, oeste]
perguntas frequentes
P # 1) Qual é a diferença entre contêineres homogêneos e heterogêneos em Java?
Responda: Os recipientes homogêneos contêm objetos / elementos do mesmo tipo. Por outro lado, contêineres heterogêneos têm objetos de tipo misto.
Q # 2) ArrayList em Java é heterogêneo?
Responda: sim. Como ArrayLists oferece suporte a genéricos e, portanto, a eliminação de tipo, pode conter objetos mistos quando implementado como um ArrayList genérico.
Q # 3) ArrayList pode armazenar int?
Responda: Não. ArrayLists não pode armazenar valores como int, mas pode armazenar objetos Integer, pois ArrayLists pode conter apenas objetos. Assim, para armazenar tipos primitivos, você deve usar classes de wrapper como Integer para ints.
Q # 4) O que acontece quando ArrayList está cheio?
Responda: Cada objeto ArrayList tem um recurso denominado ‘capacidade’. Quando a ArrayList está cheia, a capacidade da ArrayList aumenta automaticamente para abrir espaço para mais elementos.
Q # 5) Qual é a diferença entre o método removeAll e reterAll em ArrayList?
Responda: Os métodos ArrayList 'removeAll' e 'reterAll' exibem comportamento oposto.
Enquanto o método removeAll remove todos os elementos da lista que correspondem à coleção passada como um argumento para este método, retémAll, por outro lado, retém todos os elementos da lista que correspondem aos da coleção.
Conclusão
Neste tutorial, discutimos os métodos ArrayList em detalhes com um exemplo.
Também consideramos alguns casos especiais, como adicionar elementos à frente da lista. Também discutimos outras operações em ArrayList, como classificação, reversão e embaralhamento de ArrayList.
Em nosso próximo tutorial, discutiremos algumas das conversões de ArrayList.
=> Veja a série de treinamento simples em Java aqui.
Leitura recomendada
- Tutorial de reflexão Java com exemplos
- Tutorial de Java String | Métodos Java String com exemplos
- Métodos de lista Java - Classificar lista, contém, adicionar lista, remover lista
- Java ArrayList - Como declarar, inicializar e imprimir uma ArrayList
- Conversões Java ArrayList para outras coleções
- Tutorial Java SWING: Container, Componentes e Manipulação de Eventos
- Reverter uma matriz em Java - 3 métodos com exemplos
- Tutorial de JAVA para iniciantes: mais de 100 tutoriais práticos em vídeo Java