Menú

Java ArrayList: com declarar, inicialitzar i imprimir una llista de matrius

  • Principal
  • Altres
  • Java ArrayList: com declarar, inicialitzar i imprimir una llista de matrius

java arraylist how declare

Proveu El Nostre Instrument Per Eliminar Problemes

Aquest tutorial explica com declarar, inicialitzar i imprimir Java ArrayList amb exemples de codi. També coneixereu 2ra Arraylist i la implementació d'ArrayList a Java:

Java Collections Framework i la interfície de la llista es van explicar amb detall als nostres tutorials anteriors. ArrayList és una estructura de dades que forma part del marc de col·leccions i que es pot veure similar a matrius i vectors.

ArrayList es pot percebre com una matriu dinàmica que us permet afegir o eliminar elements en qualsevol moment o simplement dir-ho de forma dinàmica.

=> Feu una ullada a la guia per a principiants de Java aquí.

ArrayList a Java

En altres paraules, la seva mida pot augmentar o disminuir dinàmicament a diferència de matrius la mida dels quals es manté estàtica un cop declarada.

Què aprendreu:

Classe ArrayList a Java

L’estructura de dades ArrayList a Java està representada per la classe ArrayList que forma part de la java.util ”Paquet.

A continuació es mostra la jerarquia de la classe ArrayList.

Jerarquia per a la classe ArrayList

Com podeu veure, la classe ArrayList implementa la interfície de la llista que al seu torn s'estén des de la interfície de col·lecció.

A continuació es dóna la definició general de la classe ArrayList:

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

Aquí hi ha algunes de les característiques distintives d’ArrayList:

  • La classe ArrayList de Java emmagatzema elements mantenint l’ordre d’inserció.
  • L'ArrayList permet duplicar elements emmagatzemats.
  • ArrayList no està sincronitzat, el punt principal que diferencia l'ArrayList de la classe Vector de Java.
  • ArrayList a Java és més idèntic a Vectors a C ++.
  • L'ArrayList de Java també utilitza índexs com ara matrius i admet l'accés aleatori.
  • Les operacions que manipulen els elements de l'ArrayList són lentes, ja que cal fer molts canvis d'elements si es vol eliminar algun element de l'ArrayList.
  • La classe ArrayList no pot contenir tipus primitius, sinó només objectes. En aquest cas, normalment l’anomenem com a ‘ArrayList d’objectes’. Per tant, si voleu emmagatzemar tipus d’elements enters, heu d’utilitzar l’objecte Integer de la classe wrapper i no el tipus int primitiu.

Crea i declara ArrayList

Per utilitzar la classe ArrayList al vostre programa, heu d'incloure-la primer al programa mitjançant la directiva 'importació', tal com es mostra a continuació:

import java.util.ArrayList;

O

import java.util.*; //this will include all classes from java.util package

Un cop hàgiu importat la classe ArrayList al programa, podeu crear un objecte ArrayList.

La sintaxi general de creació d'ArrayList és:

ArrayList arrayList = new ArrayList ();

A part de la declaració anterior que utilitza el constructor per defecte, la classe ArrayList també proporciona altres constructors sobrecarregats que podeu utilitzar per crear l'ArrayList.

Mètodes constructors

La classe ArrayList a Java proporciona els següents mètodes constructors per crear ArrayList.

Mètode núm. 1: ArrayList ()

Aquest mètode utilitza el constructor per defecte de la classe ArrayList i s’utilitza per crear un ArrayList buit.

La sintaxi general d’aquest mètode és:

ArrayList list_name = new ArrayList();

Per exemple, podeu crear una ArrayList genèrica de tipus String mitjançant la següent sentència.

ArrayList arraylist = new ArrayList();

Això crearà una ArrayList buida anomenada 'arraylist' del tipus String.

Mètode 2: ArrayList (capacitat int)

Aquest constructor sobrecarregat es pot utilitzar per crear una ArrayList amb la mida o capacitat especificada proporcionada com a argument per al constructor.

La sintaxi general d’aquest mètode és:

ArrayList list_name = new ArrayList(int capacity);

Exemple:

ArrayList arraylist = new ArrayList(10);

L'afirmació anterior crea un ArrayList buit anomenat 'arraylist' de tipus Integer amb capacitat 10.

Mètode 3: ArrayList (col·lecció c)

El tercer constructor sobrecarregat de la classe ArrayList pren una col·lecció ja existent com a argument i crea una ArrayList amb els elements de la col·lecció c especificada com a elements inicials.

La sintaxi general per a la inicialització ArrayList mitjançant aquest constructor és:

ArrayList list_name = new ArrayList (Collection c)

Per exemple, si intList és una col·lecció existent amb elements {10,20,30,40,50}, la sentència següent crearà una llista ‘arraylist’ amb el contingut d’intList com a elements inicials.

ArrayList ArrayList = new ArrayList(intList);

La classe ArrayList també admet diversos mètodes que es poden utilitzar per manipular el contingut de la llista. Discutirem detalladament aquests mètodes al proper tutorial 'Mètodes ArrayList a Java'.

Inicialitzeu ArrayList a Java

Un cop es crea ArrayList, hi ha diverses maneres d'inicialitzar ArrayList amb valors. En aquesta secció, analitzarem aquestes maneres.

# 1) Utilitzant Arrays.asList

Aquí podeu passar un Array convertit a Llista mitjançant el mètode asList de la classe Arrays per inicialitzar l'ArrayList.

Sintaxi general:

ArrayList arrayListName = new ArrayList( Arrays.asList (Object o1, Object o2, …, Object on));

Exemple:

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); } }

Sortida:

Inicialitzeu ArrayList a Java

# 2) Ús del mètode de classe interna anònim

Aquí fem servir la classe interna anònima per inicialitzar ArrayList a valors.

La sintaxi general per utilitzar una classe interna anònima per a la inicialització d'ArrayList és la següent:

ArrayListarraylistName = new ArrayList(){{ add(Object o1); add (Object o2);… add (Object on);}};

Exemple:

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); } }

Sortida:

Utilització del mètode de classe interior anònim

# 3) Mitjançant el mètode add

Aquest és el mètode habitual per afegir elements a qualsevol col·lecció.

La sintaxi general per utilitzar el mètode add per afegir elements a ArrayList és:

ArrayListArraylistName = new ArrayList(); ArraylistName.add(value1); ArraylistName.add(value2); ArraylistName.add(value3);

Exemple de programació:

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); }

Sortida:

Mitjançant el mètode add

# 4) Ús del mètode Collection.nCopies

Aquest mètode s’utilitza per inicialitzar l’ArrayList amb els mateixos valors. Proporcionem el recompte d'elements a inicialitzar i el valor inicial del mètode.

La sintaxi general de la inicialització és:

ArrayList arrayListName = new ArrayList(Collections.nCopies(count, element));

L'exemple següent mostra la inicialització de matriu mitjançant el mètode 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); } }

Sortida:

Mitjançant el mètode Collection.nCopies

Iterant a través d'ArrayList

Tenim les maneres següents de recórrer o recórrer la llista ArrayList:

  1. Utilitzant el bucle
  2. Per cada bucle (millorat per al bucle).
  3. Utilitzant la interfície Iterator.
  4. Per interfície ListIterator.
  5. Pel mètode forEachRemaining ().

De fet, aquests mètodes s’utilitzen per recórrer les col·leccions en general. Veurem exemples de cadascun dels mètodes respecte a ArrayList en aquest tutorial.

# 1) Ús de bucle

Es pot utilitzar un bucle basat en índex per recórrer l'ArrayList i imprimir-ne els elements.

A continuació es mostra un exemple per recórrer i imprimir l'ArrayList mitjançant el bucle 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

Sortida:

Pel mètode forEachRemaining ()

Aquesta és la forma més senzilla i senzilla de recórrer i imprimir els elements d'ArrayList i funciona de la mateixa manera en el cas d'altres col·leccions.

# 2) Per cada bucle (millorat per al bucle)

També podeu recórrer l'ArrayList mitjançant un bucle per a cada bucle o el bucle millorat per a. Abans de Java 8, no incloïa expressions lambda. Però, a partir de Java 8, també podeu incloure expressions Lambda al bucle per a cada bucle.

El programa següent mostra el recorregut i la impressió d'ArrayList utilitzant per a cada bucle i expressió 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 + ' '); }); } }

Sortida:

Per cada bucle

# 3) Ús de la interfície iteradora

Hem vist la interfície Iterator en detall en els nostres temes anteriors. La interfície iteradora es pot utilitzar per iterar a través de l'ArrayList i imprimir-ne els valors.

El programa següent ho mostra.

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() + ' '); } } }

Sortida:

Utilitzant la interfície Iterator

# 4) Per la interfície ListIterator

També podeu recórrer l'ArrayList mitjançant ListIterator. ListIterator es pot utilitzar per recórrer ArrayList tant cap endavant com cap enrere.

Implantem un programa Java que demostri un exemple d’ús 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 + ' '); } } }

Sortida:

Per interfície ListIterator

Com es pot veure a la sortida, en el programa anterior l'ArrayList es recorre en direcció inversa mitjançant els mètodes hasPrevious () i previous () de ListIterator.

# 5) Per mètode forEachRemaining ()

Aquest és un dels mètodes per recórrer l'ArrayList i està disponible des de Java 8.

El programa següent mostra el mètode forEachRemaining () per recórrer 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 + ' '); }); } }

Sortida:

Pel mètode forEachRemaining ()

quin és el millor correu electrònic per utilitzar

Utilitzem el mètode forEachRemaining () juntament amb un iterador. És similar a cadascun i utilitzem l’expressió lambda dins d’aquest mètode.

Exemple de Java ArrayList

En aquesta secció, veurem la implementació ArrayList a Java. Com a exemple, implementarem un exemple complet de creació, inicialització i ús de Java ArrayList per realitzar diverses manipulacions.

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); } }

Sortida:

Exemple de Java ArrayList

ArrayList bidimensional a Java

Sabem que una ArrayList no té dimensions com Arrays. Però podem tenir nits ArrayLists que també s’anomenen 'Llistes Array 2D' o 'Llista Array de Llistes Array'.

La idea simple darrere d’aquestes ArrayLists imbricades és que, donada una ArrayList, cada element d’aquesta ArrayList és un altre ArrayList.

Entengem-ho mitjançant el següent 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

Sortida:

ArrayList bidimensional a Java

El programa anterior mostra 2D ArrayList. Aquí, primer, declarem una ArrayList de ArrayLists. A continuació, definim ArrayLists individuals que serviran com a elements individuals de ArrayList niat quan afegim cadascun d’aquests ArrayLists a Nested ArrayList.

Per accedir a cada element de l'ArrayList, hem de trucar al mètode get dues vegades. Primer per accedir a la fila de la llista de matriu imbricada i després per accedir a la intersecció individual de fila i columna.

Tingueu en compte que podeu augmentar els nivells imbricats d'ArrayList per definir ArrayLists multidimensionals. Per exemple, 3D ArrayList tindrà 2D ArrayLists com a elements, etc.

Preguntes freqüents

P # 1) Què és l'ArrayList a Java?

Resposta: Una ArrayList a Java és una matriu dinàmica. És de naturalesa redimensionable, és a dir, augmenta de mida quan s’afegeixen elements nous i es redueix quan se suprimeixen els elements.

Q # 2) Quina diferència hi ha entre Array i ArrayList?

Resposta: Una matriu té una estructura estàtica i la seva mida no es pot alterar un cop declarada. Un ArrayList és una matriu dinàmica que canvia la mida quan s’afegeixen o s’eliminen elements.

La matriu és una estructura bàsica a Java mentre que ArrayList forma part del Framework Framework a Java. Una altra diferència és que, mentre que Array utilitza el subíndex (()) per accedir als elements, ArrayList utilitza mètodes per accedir als seus elements.

P # 3) ArrayList és una llista?

Resposta: ArrayList és un subtipus de la llista. ArrayList és una classe mentre que List és una interfície.

P # 4) ArrayList és una col·lecció?

Resposta: No. ArrayList és una implementació de Collection que és una interfície.

P # 5) Com augmenta la seva mida ArrayList?

Resposta: Internament ArrayList s’implementa com a matriu. ArrayList té un paràmetre de mida. Quan s'afegeixen els elements a l'ArrayList i s'assoleix el valor de mida, ArrayList afegeix internament una altra matriu per acomodar elements nous.

Conclusió

Aquest va ser el tutorial sobre els conceptes bàsics de la classe ArrayList a Java. Hem vist la creació i inicialització de la classe ArrayList juntament amb una implementació de programació detallada d’ArrayList.

També vam discutir ArrayLists 2D i multidimensionals. La classe ArrayList admet els diversos mètodes que podem utilitzar per manipular els elements. Als nostres propers tutorials, prendrem aquests mètodes.

=> Llegiu la sèrie de formació Java fàcil.

Lectura recomanada

^