java arraylist how declare
Este tutorial explica como declarar, inicializar e imprimir Java ArrayList com exemplos de código. Você também aprenderá sobre Arraylist 2D e implementação de ArrayList em Java:
O Java Collections Framework e a interface List foram explicados em detalhes em nossos tutoriais anteriores. ArrayList é uma estrutura de dados que faz parte do Collections Framework e pode ser vista como semelhante a arrays e vetores.
ArrayList pode ser percebido como uma matriz dinâmica que permite adicionar ou remover elementos a qualquer momento ou simplesmente dizer, dinamicamente.
=> Dê uma olhada no guia para iniciantes em Java aqui.
Em outras palavras, seu tamanho pode aumentar ou diminuir dinamicamente, ao contrário dos arrays cujo tamanho permanece estático depois de declarado.
O que você aprenderá:
- Classe ArrayList em Java
- Conclusão
Classe ArrayList em Java
A estrutura de dados ArrayList em Java é representada pela classe ArrayList que é uma parte do “ java.util ' pacote.
A hierarquia da classe ArrayList é mostrada abaixo.
Como você pode ver, a classe ArrayList implementa a interface List que, por sua vez, se estende da interface Collection.
A definição geral da classe ArrayList é fornecida abaixo:
public class ArrayList extends AbstractList implements List,RandomAccess, Cloneable, Serializable
Aqui estão algumas das características distintivas de ArrayList:
- A classe ArrayList de Java armazena elementos mantendo a ordem de inserção.
- O ArrayList permite elementos duplicados armazenados nele.
- ArrayList não é sincronizado, o principal ponto que diferencia a classe ArrayList da classe Vector em Java.
- ArrayList em Java é mais idêntico a Vetores em C ++.
- O ArrayList em Java também usa índices como arrays e oferece suporte a acesso aleatório.
- As operações que manipulam os elementos na ArrayList são lentas, pois muitas mudanças de elementos precisam ser feitas se algum elemento for removido da ArrayList.
- A classe ArrayList não pode conter tipos primitivos, mas apenas objetos. Neste caso, normalmente o chamamos de ‘ArrayList of objects’. Portanto, se você quiser armazenar elementos do tipo inteiro, terá que usar o objeto Integer da classe wrapper e não o tipo int primitivo.
Criar e declarar ArrayList
Para usar a classe ArrayList em seu programa, você precisa incluí-la primeiro em seu programa usando a diretiva ‘import’ conforme mostrado abaixo:
import java.util.ArrayList;
OU
import java.util.*; //this will include all classes from java.util package
Depois de importar a classe ArrayList em seu programa, você pode criar um objeto ArrayList.
A sintaxe geral de criação de ArrayList é:
ArrayList arrayList = new ArrayList ();
Além da instrução acima que usa o construtor padrão, a classe ArrayList também fornece outros construtores sobrecarregados que você pode usar para criar a ArrayList.
Métodos de construtor
A classe ArrayList em Java fornece os seguintes métodos de construtor para criar a ArrayList.
Método # 1: ArrayList ()
Este método usa o construtor padrão da classe ArrayList e é usado para criar um ArrayList vazio.
A sintaxe geral deste método é:
ArrayList list_name = new ArrayList();
Por exemplo, você pode criar um ArrayList genérico do tipo String usando a seguinte instrução.
ArrayList arraylist = new ArrayList();
Isso criará uma ArrayList vazia chamada ‘arraylist’ do tipo String.
Método 2: ArrayList (capacidade interna)
Este construtor sobrecarregado pode ser usado para criar um ArrayList com o tamanho ou capacidade especificada fornecida como um argumento para o construtor.
A sintaxe geral para este método é:
ArrayList list_name = new ArrayList(int capacity);
Exemplo:
ArrayList arraylist = new ArrayList(10);
A instrução acima cria um ArrayList vazio chamado ‘arraylist’ do tipo Integer com capacidade 10.
Método # 3: ArrayList (coleção c)
O terceiro construtor sobrecarregado para a classe ArrayList pega uma coleção já existente como um argumento e cria uma ArrayList com os elementos da coleção especificada c como seus elementos iniciais.
A sintaxe geral para a inicialização de ArrayList usando este construtor é:
ArrayList list_name = new ArrayList (Collection c)
Por exemplo, se intList for uma coleção existente com elementos {10,20,30,40,50}, a instrução a seguir criará uma lista ‘arraylist’ com o conteúdo de intList como seus elementos iniciais.
ArrayList ArrayList = new ArrayList(intList);
A classe ArrayList também oferece suporte a vários métodos que podem ser usados para manipular o conteúdo da lista. Discutiremos esses métodos em detalhes em nosso próximo tutorial “Métodos ArrayList em Java”.
Inicializar ArrayList em Java
Depois que a ArrayList é criada, há várias maneiras de inicializar a ArrayList com valores. Nesta seção, discutiremos essas maneiras.
# 1) Usando Arrays.asList
Aqui, você pode passar um Array convertido em List usando o método asList da classe Arrays para inicializar o ArrayList.
Sintaxe geral:
ArrayList arrayListName = new ArrayList( Arrays.asList (Object o1, Object o2, …, Object on));
Exemplo:
import java.util.*; public class Main { public static void main(String args[]) { //create and initialize ArrayList object myList with Arrays.asList method ArrayList myList = new ArrayList( Arrays.asList('One', 'Two', 'Three')); //print the ArrayList System.out.println('List contents:'+myList); } }
Resultado:
# 2) Usando o método de classe interna anônimo
Aqui, usamos a classe interna anônima para inicializar o ArrayList para valores.
A sintaxe geral para usar uma classe interna anônima para inicialização de ArrayList é a seguinte:
ArrayListarraylistName = new ArrayList(){{ add(Object o1); add (Object o2);… add (Object on);}};
Exemplo:
import java.util.*; public class Main { public static void main(String args[]) { //create and initialize ArrayList with anonymous inner class calls ArrayList colors = new ArrayList(){{ add('Red'); add('Blue'); add('Purple'); }}; //print the ArrayList System.out.println('Content of ArrayList:'+colors); } }
Resultado:
# 3) Usando o método add
Este é o método comum para adicionar elementos a qualquer coleção.
A sintaxe geral para usar o método add para adicionar elementos a ArrayList é:
ArrayListArraylistName = new ArrayList(); ArraylistName.add(value1); ArraylistName.add(value2); ArraylistName.add(value3);
Exemplo de programação:
import java.util.*; public class Main { public static void main(String args[]) { //create ArrayList ArrayList colors = new ArrayList(); //add elements to the ArrayList using add method colors.add('Red'); colors.add('Green'); colors.add('Blue'); colors.add('Orange'); //print the ArrayList System.out.println('Content of ArrayList:'+colors); }
Resultado:
# 4) Usando o método Collection.nCopies
Este método é usado para inicializar o ArrayList com os mesmos valores. Fornecemos a contagem de elementos a serem inicializados e o valor inicial do método.
A sintaxe geral de inicialização é:
ArrayList arrayListName = new ArrayList(Collections.nCopies(count, element));
O exemplo a seguir demonstra a inicialização de Array usando o método Collections.nCopies.
import java.util.*; public class Main { public static void main(String args[]) { //create ArrayList with 10 elements //initialized to value 10 using Collections.nCopies ArrayList intList = new ArrayList(Collections.nCopies(10,10)); //print the ArrayList System.out.println('Content of ArrayList:'+intList); } }
Resultado:
Iterando por meio de ArrayList
Temos as seguintes maneiras de percorrer ou percorrer a ArrayList:
- Usando o loop for
- Por for-each loop (for-loop aprimorado).
- Usando a interface Iterator.
- Por interface ListIterator.
- Pelo método forEachRemaining ().
Na verdade, esses métodos são usados para iterar por meio de coleções em geral. Veremos exemplos de cada um dos métodos em relação a ArrayList neste tutorial.
# 1) Uso de loop for
Um loop for baseado em índice pode ser usado para percorrer o ArrayList e imprimir seus elementos.
A seguir está um exemplo para percorrer e imprimir a ArrayList usando o loop for.
import java.util.*; public class Main { public static void main(String[] args) { //create a list List intList = new ArrayList(); intList.add(10); intList.add(20); intList.add(30); intList.add(40); intList.add(50); //create & initialize a new ArrayList with previous list ArrayList arraylist = new ArrayList(intList); System.out.println('Contents of ArrayList using for-loop:'); //use for loop to traverse through its elements and print it for(int i=0;i Resultado:
Essa é a maneira mais simples e fácil de percorrer e imprimir os elementos de ArrayList e funciona da mesma maneira no caso de outras coleções.
# 2) Por loop for-each (aprimorado para loop)
Você também pode percorrer a ArrayList usando um loop for-each ou o loop for aprimorado. Antes do Java 8, ele não incluía expressões lambda. Mas, do Java 8 em diante, você também pode incluir expressões Lambda no loop for-each.
O programa abaixo demonstra o percurso e a impressão de ArrayList usando para cada loop e expressão lambda.
import java.util.*; public class Main { public static void main(String[] args) { //create a list List intList = new ArrayList(); intList.add(10); intList.add(20); intList.add(30); intList.add(40); intList.add(50); //create & initialize a new ArrayList with previous list ArrayList arraylist = new ArrayList(intList); System.out.println('Contents of ArrayList using for-each loop:'); //use for-each loop to traverse through its elements and print it intList.forEach(val ->{ System.out.print(val + ' '); }); } }
Resultado:
# 3) Usando a Interface do Iterador
Vimos a interface do Iterator em detalhes em nossos tópicos anteriores. A interface do iterador pode ser usada para iterar por meio de ArrayList e imprimir seus valores.
O programa a seguir mostra isso.
import java.util.*; public class Main { public static void main(String[] args) { //create a list List intList = new ArrayList(); intList.add(5); intList.add(10); intList.add(15); intList.add(20); intList.add(25); //create & initialize a new ArrayList with previous list ArrayList arraylist = new ArrayList(intList); System.out.println('Contents of ArrayList using Iterator interface:'); //Traverse through the ArrayList using iterator Iterator iter=arraylist.iterator(); while(iter.hasNext()){ System.out.print(iter.next() + ' '); } } }
Resultado:
# 4) Por interface ListIterator
Você também pode percorrer o ArrayList usando ListIterator. ListIterator pode ser usado para percorrer o ArrayList na direção para frente e para trás.
Vamos implementar um programa Java que demonstra um exemplo de uso de ListIterator.
import java.util.*; class Main{ public static void main(String args[]){ //create a list and initiliaze it List colors_list=new ArrayList();//Creating arraylist colors_list.add('Red'); colors_list.add('Green'); colors_list.add('Blue'); colors_list.add('Cyan'); colors_list.add('Magenta'); colors_list.add('Yellow'); System.out.println('The contents of the list using ListIterator:'); //Traverse the list using ListIterator ListIterator color_iter=colors_list.listIterator(colors_list.size()); while(color_iter.hasPrevious()) { String str=color_iter.previous(); System.out.print(str + ' '); } } }
Resultado:
Como você pode ver na saída, no programa acima, o ArrayList é percorrido na direção reversa usando os métodos hasPrevious () e previous () de ListIterator.
# 5) Por método forEachRemaining ()
Este é um dos métodos para percorrer a ArrayList e está disponível desde o Java 8.
O programa a seguir demonstra o método forEachRemaining () para atravessar ArrayList.
import java.util.*; class Main{ public static void main(String args[]){ //create a list and initiliaze it List colors_list=new ArrayList(); colors_list.add('Red'); colors_list.add('Green'); colors_list.add('Blue'); colors_list.add('Cyan'); colors_list.add('Magenta'); colors_list.add('Yellow'); System.out.println('The contents of the list using forEachRemaining() method:'); //Traverse the list using forEachRemaining () method Iterator itr=colors_list.iterator(); itr.forEachRemaining(val-> //lambda expression { System.out.print(val + ' '); }); } }
Resultado:
qual é o melhor downloader de música grátis?
Usamos o método forEachRemaining () junto com um Iterator. É semelhante a cada um e usamos a expressão lambda dentro desse método.
Exemplo de ArrayList Java
Nesta seção, veremos a implementação de ArrayList em Java. Como exemplo, implementaremos um exemplo completo de criação, inicialização e uso de Java ArrayList para realizar várias manipulações.
import java.util.ArrayList; class Main { public static void main(String[] args) { //Creating a generic ArrayList ArrayList newList = new ArrayList(); //Size of arrayList System.out.println('Original size of ArrayList at creation: ' + newList.size()); //add elements to it newList.add('IND'); newList.add('USA'); newList.add('AUS'); newList.add('UK'); //print the size after adding elements System.out.println('ArrayList size after adding elements: ' + newList.size()); //Print ArrayList contents System.out.println('Contents of the ArrayList: ' + newList); //Remove an element from the list newList.remove('USA'); System.out.println('ArrayList contents after removing element(USA): ' + newList); //Remove another element by index newList.remove(2); System.out.println('ArrayList contents after removing element at index 2: ' + newList); //print new size System.out.println('Size of arrayList: ' + newList.size()); //print list contents System.out.println('Final ArrayList Contents: ' + newList); } }
Resultado:
ArrayList bidimensional em Java
Sabemos que um ArrayList não tem dimensões como Arrays. Mas podemos ter ArrayLists aninhados, que também são chamados de ‘2D ArrayLists’ ou ‘ArrayList of ArrayLists’.
A ideia simples por trás desses ArrayLists aninhados é que, dado um ArrayList, cada elemento deste ArrayList é outro ArrayList.
Deixe-nos entender isso usando o seguinte programa.
import java.util.*; public class Main { public static void main(String[] args) { int num = 3; // declare an arrayList of ArrayLists or 2D ArrayList ArrayList intList = new ArrayList (num); // Create individual elements or ArrayLists and add them to intList as elements ArrayList list_elem1 = new ArrayList(); list_elem1.add(10); intList.add(list_elem1); ArrayList list_elem2 = new ArrayList(); list_elem2.add(20); list_elem2.add(30); intList.add(list_elem2); ArrayList list_elem3 = new (); list_elem3.add(40); list_elem3.add(50); list_elem3.add(60); intList.add(list_elem3); System.out.println('Contents of 2D ArrayList(Nested ArrayList):'); //print the 2D ArrayList or nested ArrayList for (int i = 0; i Resultado:
O programa acima mostra 2D ArrayList. Aqui, primeiro, declaramos um ArrayList de ArrayLists. Em seguida, definimos ArrayLists individuais que servirão como elementos individuais de ArrayList aninhada quando adicionamos cada uma dessas ArrayLists a ArrayList aninhada.
Para acessar cada elemento da ArrayList, precisamos chamar o método get duas vezes. Primeiro, para acessar a linha de Nested ArrayList e, em seguida, para acessar a interseção individual de linha e coluna.
Observe que você pode aumentar os níveis aninhados de ArrayList para definir ArrayLists multidimensionais. Por exemplo, 3D ArrayList terá 2D ArrayLists como seus elementos e assim por diante.
perguntas frequentes
P # 1) O que é ArrayList em Java?
Responda: Um ArrayList em Java é um array dinâmico. É redimensionável por natureza, ou seja, aumenta de tamanho quando novos elementos são adicionados e diminui quando os elementos são excluídos.
Q # 2) Qual é a diferença entre Array e ArrayList?
Responda: Um Array está em uma estrutura estática e seu tamanho não pode ser alterado depois de declarado. Um ArrayList é um array dinâmico e muda seu tamanho quando os elementos são adicionados ou removidos.
O array é uma estrutura básica em Java enquanto um ArrayList é uma parte do Collection Framework em Java. Outra diferença é que enquanto Array usa subscript ([]) para acessar os elementos, ArrayList usa métodos para acessar seus elementos.
Q # 3) ArrayList é uma lista?
Responda: ArrayList é um subtipo da lista. ArrayList é uma classe enquanto List é uma interface.
Q # 4) ArrayList é uma coleção?
Responda: Não. ArrayList é uma implementação de Collection que é uma interface.
Q # 5) Como ArrayList aumenta seu tamanho?
Responda: Internamente, ArrayList é implementado como um Array. ArrayList tem um parâmetro de tamanho. Quando os elementos são adicionados ao ArrayList e o valor do tamanho é alcançado, o ArrayList adiciona internamente outro array para acomodar novos elementos.
Conclusão
Este foi o tutorial sobre os fundamentos da classe ArrayList em Java. Vimos a criação e inicialização da classe ArrayList junto com uma implementação de programação detalhada de ArrayList.
Também discutimos ArrayLists 2D e multidimensionais. A classe ArrayList oferece suporte aos vários métodos que podemos usar para manipular os elementos. Em nossos próximos tutoriais, abordaremos esses métodos.
=> Leia a série de treinamento Easy Java.
Leitura recomendada
- Array Java - declarar, criar e inicializar um array em Java
- Array Java - como imprimir elementos de um array em Java?
- Implantação Java: Criação e execução de arquivo JAR Java
- Lista Java - Como criar, inicializar e usar a lista em Java
- Java Virtual Machine: como a JVM ajuda na execução de aplicativos Java
- Matriz de objetos em Java: como criar, inicializar e usar
- Modificadores de acesso em Java - Tutorial com exemplos
- Tutorial de reflexão Java com exemplos