Java ListaArray classe usa um dinâmico variedade para armazenar os elementos. É como uma matriz, mas há sem limite de tamanho . Podemos adicionar ou remover elementos a qualquer momento. Portanto, é muito mais flexível que o array tradicional. É encontrado no java.util pacote. É como o vetor em C++.

O ArrayList em Java também pode ter elementos duplicados. Ele implementa a interface List para que possamos usar todos os métodos da interface List aqui. O ArrayList mantém o pedido de inserção internamente.

Ele herda a classe AbstractList e implementa Interface de lista .

como converter inteiro em string java

Os pontos importantes sobre a classe Java ArrayList são:

• A classe Java ArrayList pode conter elementos duplicados.
• A classe Java ArrayList mantém o pedido de inserção.
• A classe Java ArrayList não é sincronizado .
• Java ArrayList permite acesso aleatório porque o array funciona com base em índice.
• No ArrayList, a manipulação é um pouco mais lenta do que no LinkedList em Java porque muitas mudanças precisam ocorrer se algum elemento for removido da lista do array.
• Não podemos criar uma lista de arrays de tipos primitivos, como int, float, char, etc. É necessário usar a classe wrapper necessária em tais casos. Por exemplo:

 ArrayList al = ArrayList(); // does not work ArrayList al = new ArrayList(); // works fine 

• Java ArrayList é inicializado pelo tamanho. O tamanho é dinâmico na lista de arrays, que varia de acordo com os elementos adicionados ou removidos da lista.

Hierarquia da classe ArrayList

Conforme mostrado no diagrama acima, a classe Java ArrayList estende a classe AbstractList que implementa a interface List. A interface List estende o Coleção e interfaces iteráveis ​​em ordem hierárquica.

Declaração de classe ArrayList

Vamos ver a declaração da classe java.util.ArrayList.

 public class ArrayList extends AbstractList implements List, RandomAccess, Cloneable, Serializable 

Construtores de ArrayList

Métodos de ArrayList

Java não genérico vs. Coleção genérica

A estrutura de coleta Java não era genérica antes do JDK 1.5. Desde 1.5, é genérico.

A nova coleção genérica Java permite que você tenha apenas um tipo de objeto em uma coleção. Agora é seguro para o tipo, portanto a conversão de tipo não é necessária em tempo de execução.

Vejamos o antigo exemplo não genérico de criação de uma coleção Java.

 ArrayList list=new ArrayList();//creating old non-generic arraylist 

Vamos ver o novo exemplo genérico de criação de coleção java.

 ArrayList list=new ArrayList();//creating new generic arraylist 

Em uma coleção genérica, especificamos o tipo entre colchetes angulares. Agora ArrayList é forçado a ter o único tipo de objeto especificado nele. Se você tentar adicionar outro tipo de objeto, isso dará uma erro em tempo de compilação .

Para obter mais informações sobre genéricos Java, clique aqui Tutorial de genéricos Java .

Exemplo de ArrayList Java

Nome do arquivo: ArrayListExample1.java

 import java.util.*; public class ArrayListExample1{ public static void main(String args[]){ ArrayList list=new ArrayList();//Creating arraylist list.add('Mango');//Adding object in arraylist list.add('Apple'); list.add('Banana'); list.add('Grapes'); //Printing the arraylist object System.out.println(list); } } 

Saída:

[Mango, Apple, Banana, Grapes] 

Iterando ArrayList usando Iterator

Vejamos um exemplo para percorrer elementos ArrayList usando a interface Iterator.

Nome do arquivo: ArrayListExample2.java

 import java.util.*; public class ArrayListExample2{ public static void main(String args[]){ ArrayList list=new ArrayList();//Creating arraylist list.add('Mango');//Adding object in arraylist list.add('Apple'); list.add('Banana'); list.add('Grapes'); //Traversing list through Iterator Iterator itr=list.iterator();//getting the Iterator while(itr.hasNext()){//check if iterator has the elements System.out.println(itr.next());//printing the element and move to next } } } 

Saída:

Mango Apple Banana Grapes 

Iterando ArrayList usando loop For-each

Vamos ver um exemplo para percorrer os elementos ArrayList usando o loop for-each

Nome do arquivo: ArrayListExample3.java

 import java.util.*; public class ArrayListExample3{ public static void main(String args[]){ ArrayList list=new ArrayList();//Creating arraylist list.add('Mango');//Adding object in arraylist list.add('Apple'); list.add('Banana'); list.add('Grapes'); //Traversing list through for-each loop for(String fruit:list) System.out.println(fruit); } } 

Saída:

Mango Apple Banana Grapes 

Obter e definir ArrayList

O método get() retorna o elemento no índice especificado, enquanto o método set() altera o elemento.

Nome do arquivo: ArrayListExample4.java

 import java.util.*; public class ArrayListExample4{ public static void main(String args[]){ ArrayList al=new ArrayList(); al.add('Mango'); al.add('Apple'); al.add('Banana'); al.add('Grapes'); //accessing the element System.out.println('Returning element: '+al.get(1));//it will return the 2nd element, because index starts from 0 //changing the element al.set(1,'Dates'); //Traversing list for(String fruit:al) System.out.println(fruit); } } 

Saída:

Returning element: Apple Mango Dates Banana Grapes 

Como classificar ArrayList

O java.util pacote fornece uma classe de utilitário Coleções , que possui o método estático sort(). Usando o Coleções.sort() método, podemos classificar facilmente o ArrayList.

Nome do arquivo: SortArrayList.java

 import java.util.*; class SortArrayList{ public static void main(String args[]){ //Creating a list of fruits List list1=new ArrayList(); list1.add('Mango'); list1.add('Apple'); list1.add('Banana'); list1.add('Grapes'); //Sorting the list Collections.sort(list1); //Traversing list through the for-each loop for(String fruit:list1) System.out.println(fruit); System.out.println('Sorting numbers...'); //Creating a list of numbers List list2=new ArrayList(); list2.add(21); list2.add(11); list2.add(51); list2.add(1); //Sorting the list Collections.sort(list2); //Traversing list through the for-each loop for(Integer number:list2) System.out.println(number); } } 

Saída:

tutorial de microsserviços

Apple Banana Grapes Mango Sorting numbers... 1 11 21 51 

Maneiras de iterar os elementos da coleção em Java

Existem várias maneiras de percorrer os elementos da coleção:

1. Pela interface do Iterador.
2. Por loop para cada.
3. Pela interface ListIterator.
4. Por loop for.
5. Pelo método forEach().
6. Pelo método forEachRemaining().

Iterando a coleção pelas formas restantes

Vamos ver um exemplo para percorrer os elementos ArrayList de outras maneiras

Nome do arquivo: ArrayList4.java

 import java.util.*; class ArrayList4{ public static void main(String args[]){ ArrayList list=new ArrayList();//Creating arraylist list.add(&apos;Ravi&apos;);//Adding object in arraylist list.add(&apos;Vijay&apos;); list.add(&apos;Ravi&apos;); list.add(&apos;Ajay&apos;); System.out.println(&apos;Traversing list through List Iterator:&apos;); //Here, element iterates in reverse order ListIterator list1=list.listIterator(list.size()); while(list1.hasPrevious()) { String str=list1.previous(); System.out.println(str); } System.out.println(&apos;Traversing list through for loop:&apos;); for(int i=0;i<list.size();i++) { system.out.println(list.get(i)); } system.out.println('traversing list through foreach() method:'); the method is a new feature, introduced in java 8. list.foreach(a->{ //Here, we are using lambda expression System.out.println(a); }); System.out.println(&apos;Traversing list through forEachRemaining() method:&apos;); Iterator itr=list.iterator(); itr.forEachRemaining(a-&gt; //Here, we are using lambda expression { System.out.println(a); }); } } </list.size();i++)>

Saída:

Traversing list through List Iterator: Ajay Ravi Vijay Ravi Traversing list through for loop: Ravi Vijay Ravi Ajay Traversing list through forEach() method: Ravi Vijay Ravi Ajay Traversing list through forEachRemaining() method: Ravi Vijay Ravi Ajay 

Objetos de classe definidos pelo usuário em Java ArrayList

Vamos ver um exemplo onde armazenamos o objeto da classe Student em uma lista de array.

Nome do arquivo: ArrayList5.java

 class Student{ int rollno; String name; int age; Student(int rollno,String name,int age){ this.rollno=rollno; this.name=name; this.age=age; } } 

 import java.util.*; class ArrayList5{ public static void main(String args[]){ //Creating user-defined class objects Student s1=new Student(101,'Sonoo',23); Student s2=new Student(102,'Ravi',21); Student s2=new Student(103,'Hanumat',25); //creating arraylist ArrayList al=new ArrayList(); al.add(s1);//adding Student class object al.add(s2); al.add(s3); //Getting Iterator Iterator itr=al.iterator(); //traversing elements of ArrayList object while(itr.hasNext()){ Student st=(Student)itr.next(); System.out.println(st.rollno+' '+st.name+' '+st.age); } } } 

Saída:

 101 Sonoo 23 102 Ravi 21 103 Hanumat 25 

Exemplo de serialização e desserialização Java ArrayList

Vamos ver um exemplo para serializar um objeto ArrayList e depois desserializá-lo.

Nome do arquivo: ArrayList6.java

 import java.io.*; import java.util.*; class ArrayList6 { public static void main(String [] args) { ArrayList al=new ArrayList(); al.add('Ravi'); al.add('Vijay'); al.add('Ajay'); try { //Serialization FileOutputStream fos=new FileOutputStream('file'); ObjectOutputStream oos=new ObjectOutputStream(fos); oos.writeObject(al); fos.close(); oos.close(); //Deserialization FileInputStream fis=new FileInputStream('file'); ObjectInputStream ois=new ObjectInputStream(fis); ArrayList list=(ArrayList)ois.readObject(); System.out.println(list); }catch(Exception e) { System.out.println(e); } } } 

Saída:

 [Ravi, Vijay, Ajay] 

Exemplo Java ArrayList para adicionar elementos

Aqui, vemos diferentes maneiras de adicionar um elemento.

Nome do arquivo: ArrayList7.java

urfi javed

 import java.util.*; class ArrayList7{ public static void main(String args[]){ ArrayList al=new ArrayList(); System.out.println('Initial list of elements: '+al); //Adding elements to the end of the list al.add('Ravi'); al.add('Vijay'); al.add('Ajay'); System.out.println('After invoking add(E e) method: '+al); //Adding an element at the specific position al.add(1, 'Gaurav'); System.out.println('After invoking add(int index, E element) method: '+al); ArrayList al2=new ArrayList(); al2.add('Sonoo'); al2.add('Hanumat'); //Adding second list elements to the first list al.addAll(al2); System.out.println('After invoking addAll(Collection c) method: '+al); ArrayList al3=new ArrayList(); al3.add('John'); al3.add('Rahul'); //Adding second list elements to the first list at specific position al.addAll(1, al3); System.out.println('After invoking addAll(int index, Collection c) method: '+al); } } 

Saída:

Initial list of elements: [] After invoking add(E e) method: [Ravi, Vijay, Ajay] After invoking add(int index, E element) method: [Ravi, Gaurav, Vijay, Ajay] After invoking addAll(Collection c) method: [Ravi, Gaurav, Vijay, Ajay, Sonoo, Hanumat] After invoking addAll(int index, Collection c) method: [Ravi, John, Rahul, Gaurav, Vijay, Ajay, Sonoo, Hanumat] 

Exemplo Java ArrayList para remover elementos

Aqui, vemos diferentes maneiras de remover um elemento.

Nome do arquivo: ArrayList8.java

 import java.util.*; class ArrayList8 { public static void main(String [] args) { ArrayList al=new ArrayList(); al.add('Ravi'); al.add('Vijay'); al.add('Ajay'); al.add('Anuj'); al.add('Gaurav'); System.out.println('An initial list of elements: '+al); //Removing specific element from arraylist al.remove('Vijay'); System.out.println('After invoking remove(object) method: '+al); //Removing element on the basis of specific position al.remove(0); System.out.println('After invoking remove(index) method: '+al); //Creating another arraylist ArrayList al2=new ArrayList(); al2.add('Ravi'); al2.add('Hanumat'); //Adding new elements to arraylist al.addAll(al2); System.out.println('Updated list : '+al); //Removing all the new elements from arraylist al.removeAll(al2); System.out.println('After invoking removeAll() method: '+al); //Removing elements on the basis of specified condition al.removeIf(str -> str.contains('Ajay')); //Here, we are using Lambda expression System.out.println('After invoking removeIf() method: '+al); //Removing all the elements available in the list al.clear(); System.out.println('After invoking clear() method: '+al); } } 

Saída:

An initial list of elements: [Ravi, Vijay, Ajay, Anuj, Gaurav] After invoking remove(object) method: [Ravi, Ajay, Anuj, Gaurav] After invoking remove(index) method: [Ajay, Anuj, Gaurav] Updated list : [Ajay, Anuj, Gaurav, Ravi, Hanumat] After invoking removeAll() method: [Ajay, Anuj, Gaurav] After invoking removeIf() method: [Anuj, Gaurav] After invoking clear() method: [] 

Exemplo Java ArrayList do método retainAll()

Nome do arquivo: ArrayList9.java

 import java.util.*; class ArrayList9{ public static void main(String args[]){ ArrayList al=new ArrayList(); al.add('Ravi'); al.add('Vijay'); al.add('Ajay'); ArrayList al2=new ArrayList(); al2.add('Ravi'); al2.add('Hanumat'); al.retainAll(al2); System.out.println('iterating the elements after retaining the elements of al2'); Iterator itr=al.iterator(); while(itr.hasNext()){ System.out.println(itr.next()); } } } 

Saída:

 iterating the elements after retaining the elements of al2 Ravi 

Exemplo Java ArrayList do método isEmpty()

Nome do arquivo: ArrayList4.java

 import java.util.*; class ArrayList10{ public static void main(String [] args) { ArrayList al=new ArrayList(); System.out.println('Is ArrayList Empty: '+al.isEmpty()); al.add('Ravi'); al.add('Vijay'); al.add('Ajay'); System.out.println('After Insertion'); System.out.println('Is ArrayList Empty: '+al.isEmpty()); } } 

Saída:

Is ArrayList Empty: true After Insertion Is ArrayList Empty: false 

Exemplo Java ArrayList: Livro

Vamos ver um exemplo de ArrayList onde adicionamos livros à lista e imprimimos todos os livros.

Nome do arquivo: ArrayListExample20.java

 import java.util.*; class Book { int id; String name,author,publisher; int quantity; public Book(int id, String name, String author, String publisher, int quantity) { this.id = id; this.name = name; this.author = author; this.publisher = publisher; this.quantity = quantity; } } public class ArrayListExample20 { public static void main(String[] args) { //Creating list of Books List list=new ArrayList(); //Creating Books Book b1=new Book(101,'Let us C','Yashwant Kanetkar','BPB',8); Book b2=new Book(102,'Data Communications and Networking','Forouzan','Mc Graw Hill',4); Book b3=new Book(103,'Operating System','Galvin','Wiley',6); //Adding Books to list list.add(b1); list.add(b2); list.add(b3); //Traversing list for(Book b:list){ System.out.println(b.id+' '+b.name+' '+b.author+' '+b.publisher+' '+b.quantity); } } } 

Saída:

101 Let us C Yashwant Kanetkar BPB 8 102 Data Communications and Networking Forouzan Mc Graw Hill 4 103 Operating System Galvin Wiley 6 

Tamanho e capacidade de um ArrayList

Tamanho e capacidade de uma lista de array são os dois termos que os iniciantes consideram confusos. Vamos entender nesta seção com a ajuda de alguns exemplos. Considere o seguinte trecho de código.

Nome do arquivo: SizeCapacity.java

1 milhão quantos 0

 import java.util.*; public class SizeCapacity { public static void main(String[] args) throws Exception { ArrayList al = new ArrayList(); System.out.println('The size of the array is: ' + al.size()); } } 

Saída:

 The size of the array is: 0 

Explicação: A saída faz sentido porque não fizemos nada com a lista de arrays. Agora observe o seguinte programa.

Nome do arquivo: SizeCapacity1.java

 import java.util.*; public class SizeCapacity1 { public static void main(String[] args) throws Exception { ArrayList al = new ArrayList(10); System.out.println('The size of the array is: ' + al.size()); } } 

Saída:

 The size of the array is: 0 

Explicação: Vemos que o tamanho ainda é 0, e a razão por trás disso é que o número 10 representa a capacidade e não o tamanho. Na verdade, o tamanho representa o número total de elementos presentes no array. Como não adicionamos nenhum elemento, portanto, o tamanho da lista de arrays é zero em ambos os programas.

A capacidade representa o número total de elementos que a lista do array pode conter. Portanto, a capacidade de uma lista de arrays é sempre maior ou igual ao tamanho da lista de arrays. Quando adicionamos um elemento à lista do array, ele verifica se o tamanho da lista do array tornou-se igual à capacidade ou não. Se sim, então a capacidade da lista de arrays aumenta. Portanto, no exemplo acima, a capacidade será de 10 até que 10 elementos sejam adicionados à lista. Quando somamos os 11^ºelemento, a capacidade aumenta. Observe que em ambos os exemplos, a capacidade da lista de array é 10. No primeiro caso, a capacidade é 10 porque a capacidade padrão da lista de array é 10. No segundo caso, mencionamos explicitamente que a capacidade do array lista é 10.

Nota: Não existe nenhum método padrão para saber como a capacidade aumenta na lista de arrays. Na verdade, a forma como a capacidade aumenta varia de uma versão do GDK para outra versão. Portanto, é necessário verificar a forma como o código de aumento de capacidade é implementado no GDK. Não existe nenhum método predefinido na classe ArrayList que retorne a capacidade da lista de arrays. Portanto, para melhor compreensão, utilize o métodocapacidade() da classe Vector. A lógica do tamanho e da capacidade é a mesma na classe ArrayList e na classe Vector.

Tópicos relacionados

Como classificar ArrayList em Java

Diferença entre Array e ArrayList

Quando usar ArrayList e LinkedList em Java

Diferença entre ArrayList e LinkedList

alternativa mylivecricket

Diferença entre ArrayList e Vetor

Como comparar dois ArrayList em Java

Como reverter ArrayList em Java

Quando usar ArrayList e LinkedList em Java

Como tornar ArrayList somente leitura

Diferença entre comprimento do array e tamanho() de ArrayList em Java

Como sincronizar ArrayList em Java

Como converter ArrayList em Array e Array em ArrayList em java

Array vs ArrayList em Java

Como classificar Java ArrayList em ordem decrescente

Como remover duplicatas de ArrayList em Java