Menu

Java ArrayList - Jak deklarovat, inicializovat a vytisknout seznam ArrayList

  • Hlavní
  • Jiný
  • Java ArrayList - Jak deklarovat, inicializovat a vytisknout seznam ArrayList

java arraylist how declare

Vyzkoušejte Náš Nástroj Pro Odstranění Problémů

Tento výukový program vysvětluje, jak deklarovat, inicializovat a vytisknout seznam Java ArrayList s příklady kódu. Dozvíte se také o 2D Arraylist & Implementation of ArrayList v Javě:

V našem předchozím kurzu jsme podrobně vysvětlili rámec Java Collections Framework a rozhraní List. ArrayList je datová struktura, která je součástí kolekce Framework a lze ji považovat za podobnou polím a vektorům.

ArrayList lze vnímat jako dynamické pole, které vám umožňuje přidávat nebo odebírat prvky z něj kdykoli nebo jednoduše řečeno, dynamicky.

=> Prohlédněte si příručku Java Beginners Guide zde.

ArrayList v Javě

Jinými slovy, jeho velikost se může dynamicky zvětšovat nebo zmenšovat na rozdíl od polí, jejichž velikost zůstává po deklaraci statická.

Co se naučíte:

Třída ArrayList v Javě

Datová struktura ArrayList v Javě je reprezentována třídou ArrayList, která je součástí „ java.util ”Balíček.

Hierarchie pro třídu ArrayList je uvedena níže.

Hierarchie pro třídu ArrayList

Jak vidíte, třída ArrayList implementuje rozhraní List, které se zase rozšiřuje z rozhraní Collection.

Obecná definice třídy ArrayList je uvedena níže:

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

Zde jsou některé z charakteristických rysů ArrayList:

  • Třída ArrayList Java ukládá prvky udržováním pořadí vložení.
  • ArrayList umožňuje duplikovat prvky uložené v něm.
  • ArrayList není synchronizován, hlavní bod, který odlišuje ArrayList od třídy Vector v Javě.
  • ArrayList v Javě je více identický s vektory v C ++.
  • ArrayList v Javě také používá indexy jako pole a podporuje náhodný přístup.
  • Operace, které manipulují s prvky v ArrayList, jsou pomalé, protože je třeba provést mnoho posunů prvků, pokud má být z ArrayList odebrán jakýkoli prvek.
  • Třída ArrayList nemůže obsahovat primitivní typy, ale pouze objekty. V tomto případě to obvykle nazýváme „ArrayList objektů“. Pokud tedy chcete uložit celočíselný typ prvků, musíte použít objekt Integer třídy wrapper a nikoli primitivní typ int.

Vytvořit a deklarovat ArrayList

Chcete-li ve svém programu použít třídu ArrayList, musíte ji nejprve zahrnout do svého programu pomocí směrnice „import“, jak je uvedeno níže:

import java.util.ArrayList;

NEBO

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

Jakmile importujete třídu ArrayList do svého programu, můžete vytvořit objekt ArrayList.

Obecná syntaxe vytváření ArrayList je:

ArrayList arrayList = new ArrayList ();

Kromě výše uvedeného příkazu, který používá výchozí konstruktor, poskytuje třída ArrayList také další přetížené konstruktory, které můžete použít k vytvoření ArrayList.

Konstruktorové metody

Třída ArrayList v Javě poskytuje následující metody konstruktoru k vytvoření ArrayList.

Metoda č. 1: ArrayList ()

Tato metoda používá výchozí konstruktor třídy ArrayList a používá se k vytvoření prázdného ArrayList.

Obecná syntaxe této metody je:

ArrayList list_name = new ArrayList();

Například, můžete vytvořit obecný ArrayList typu String pomocí následujícího příkazu.

ArrayList arraylist = new ArrayList();

Tím se vytvoří prázdný ArrayList s názvem „arraylist“ typu String.

Metoda č. 2: ArrayList (int kapacita)

Tento přetížený konstruktor lze použít k vytvoření ArrayList se zadanou velikostí nebo kapacitou poskytnutou jako argument konstruktoru.

Obecná syntaxe pro tuto metodu je:

ArrayList list_name = new ArrayList(int capacity);

Příklad:

ArrayList arraylist = new ArrayList(10);

Výše uvedený příkaz vytvoří prázdný ArrayList s názvem „arraylist“ typu Integer s kapacitou 10.

Metoda č. 3: ArrayList (kolekce c)

Třetí přetížený konstruktor pro ArrayList třídu vezme již existující kolekci jako argument a vytvoří ArrayList s prvky ze zadané kolekce c jako počáteční prvky.

Obecná syntaxe pro inicializaci ArrayList pomocí tohoto konstruktoru je:

ArrayList list_name = new ArrayList (Collection c)

Například, pokud intList je existující kolekce s prvky {10,20,30,40,50}, pak následující příkaz vytvoří seznam „arraylist“ s obsahem intList jako jeho počátečních prvků.

ArrayList ArrayList = new ArrayList(intList);

Třída ArrayList také podporuje různé metody, které lze použít k manipulaci s obsahem seznamu. Těmto metodám se budeme podrobně věnovat v našem připravovaném výukovém programu „Metody ArrayList v Javě“.

Inicializovat ArrayList v Javě

Jakmile je ArrayList vytvořen, existuje několik způsobů, jak ArrayList inicializovat pomocí hodnot. V této části budeme diskutovat o těchto způsobech.

# 1) Používání Arrays.asList

Tady můžete předat pole převedené na seznam pomocí metody asList třídy Arrays k inicializaci ArrayList.

Obecná syntaxe:

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

Příklad:

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

Výstup:

Inicializujte ArrayList v Javě

# 2) Použití anonymní metody vnitřní třídy

Tady používáme anonymní vnitřní třídu k inicializaci ArrayList na hodnoty.

Obecná syntaxe pro použití anonymní vnitřní třídy pro inicializaci ArrayList je následující:

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

Příklad:

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

Výstup:

Použití anonymní metody vnitřní třídy

# 3) Použití metody přidání

Toto je běžná metoda pro přidání prvků do jakékoli kolekce.

Obecná syntaxe pro použití metody add pro přidání prvků do ArrayList je:

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

Příklad programování:

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

Výstup:

Pomocí metody přidání

# 4) Použití metody Collection.nCopies

Tato metoda se používá k inicializaci ArrayList se stejnými hodnotami. Metodě poskytujeme počet prvků, které mají být inicializovány, a počáteční hodnotu.

Obecná syntaxe inicializace je:

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

Níže uvedený příklad ukazuje inicializaci pole pomocí metody 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); } }

Výstup:

Použití metody Collection.nCopies

Iterace prostřednictvím ArrayList

Máme následující způsoby, jak procházet nebo procházet smyčkou přes ArrayList:

  1. Pomocí smyčky for
  2. By for-each loop (enhanced for-loop).
  3. Pomocí rozhraní Iterator.
  4. Rozhraní ListIterator.
  5. Metodou forEachRemaining ().

Ve skutečnosti se tyto metody obecně používají k iteraci kolekcí. V tomto kurzu uvidíme příklady každé z metod s ohledem na ArrayList.

# 1) Použití pro smyčku

Pro procházení ArrayList a tisk jeho prvků lze použít smyčku for založenou na indexu.

Následuje příklad pro procházení a tisk ArrayList pomocí smyčky 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

Výstup:

Metodou forEachRemaining ()

Toto je nejjednodušší a nejjednodušší způsob procházení a tisku prvků ArrayList a funguje stejně i v případě jiných sbírek.

# 2) By for-each loop (enhanced for loop)

Můžete také procházet ArrayList pomocí smyčky pro každou nebo vylepšenou smyčku pro. Před verzí Java 8 neobsahoval výrazy lambda. Ale od Javy 8 a dále můžete do smyčky pro každou zahrnout i výrazy Lambda.

Níže uvedený program ukazuje procházení a tisk ArrayList pomocí pro každou smyčku a výraz 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 + ' '); }); } }

Výstup:

Pro každou smyčku

# 3) Používání rozhraní Iterator

Rozhraní Iterátoru jsme viděli podrobně v našich předchozích tématech. Rozhraní Iterator lze použít k iteraci ArrayList a tisku jeho hodnot.

Následující program to ukazuje.

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

Výstup:

Pomocí rozhraní Iterator

# 4) Podle rozhraní ListIterator

ArrayList můžete také procházet pomocí ListIterator. ListIterator lze použít k procházení ArrayList ve směru dopředu i dozadu.

Pojďme implementovat program Java, který ukazuje příklad použití 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 + ' '); } } }

Výstup:

Rozhraní ListIterator

Jak vidíte z výstupu, ve výše uvedeném programu je ArrayList procházen zpětným směrem pomocí hasPrevious () a previous () metod ListIterator.

# 5) Metodou forEachRemaining ()

Toto je jedna z metod procházení ArrayList a je k dispozici od verze Java 8.

Následující program ukazuje metodu forEachRemaining () pro procházení 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 + ' '); }); } }

Výstup:

Metodou forEachRemaining ()

jak otevřete soubor bin

Používáme metodu forEachRemaining () spolu s Iterátorem. Je to podobné jako u každého a v této metodě používáme výraz lambda.

Příklad Java ArrayList

V této části uvidíme implementaci ArrayList v Javě. Jako příklad implementujeme kompletní příklad z vytváření, inicializace a používání Java ArrayList k provádění různých manipulací.

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

Výstup:

Příklad Java ArrayList

Dvourozměrný ArrayList v Javě

Víme, že ArrayList nemá dimenze jako Arrays. Ale můžeme mít vnořené ArrayLists, které se také nazývají „2D ArrayLists“ nebo „ArrayList of ArrayLists“.

Jednoduchá myšlenka za těmito vnořenými ArrayLists je, že vzhledem k ArrayList je každý prvek tohoto ArrayList dalším ArrayList.

Rozumíme tomu pomocí následujícího programu.

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

Výstup:

Dvourozměrný ArrayList v Javě

Výše uvedený program zobrazuje 2D ArrayList. Tady nejprve deklarujeme ArrayList of ArrayLists. Poté definujeme jednotlivé ArrayLists, které budou sloužit jako jednotlivé prvky vnořeného ArrayList, když přidáme každý z těchto ArrayLists do Nested ArrayList.

Pro přístup ke každému prvku ArrayList musíme dvakrát zavolat metodu get. Nejprve pro přístup k řádku Nested ArrayList a poté pro přístup k individuálnímu průsečíku řádku a sloupce.

Všimněte si, že můžete zvýšit vnořené úrovně ArrayList a definovat vícerozměrné ArrayLists. Například, 3D ArrayList bude mít jako prvky 2D ArrayLists a tak dále.

Často kladené otázky

Otázka č. 1) Co je ArrayList v Javě?

Odpovědět: ArrayList v Javě je dynamické pole. Je možné jej měnit v přírodě, tj. Zvětšovat se při přidávání nových prvků a zmenšovat se při mazání prvků.

Otázka 2) Jaký je rozdíl mezi Array a ArrayList?

Odpovědět: Pole je ve statické struktuře a jeho velikost nelze jednou deklarovat. ArrayList je dynamické pole a mění jeho velikost při přidávání nebo odebírání prvků.

Pole je základní strukturou v Javě, zatímco ArrayList je součástí Collection Framework v Javě. Další rozdíl spočívá v tom, že zatímco Array používá pro přístup k prvkům index (()), ArrayList používá pro přístup k svým prvkům metody.

Otázka č. 3) Je ArrayList seznam?

Odpovědět: ArrayList je podtypem seznamu. ArrayList je třída, zatímco List je rozhraní.

Otázka č. 4) Je ArrayList sbírka?

Odpovědět: Ne. ArrayList je implementace Collection, což je rozhraní.

Otázka č. 5) Jak ArrayList zvětší svou velikost?

Odpovědět: Interně je ArrayList implementován jako pole. ArrayList má parametr velikosti. Když jsou prvky přidány do ArrayList a je dosažena hodnota velikosti, ArrayList interně přidá další pole pro uložení nových prvků.

Závěr

Jednalo se o výuku základů třídy ArrayList v Javě. Viděli jsme vytvoření a inicializaci třídy ArrayList spolu s podrobnou implementací programování ArrayList.

Diskutovali jsme také o 2D a vícerozměrných seznamech polí. Třída ArrayList podporuje různé metody, které můžeme použít k manipulaci s prvky. V našich nadcházejících výukových programech tyto metody využijeme.

=> Přečtěte si řadu Easy Java Training Series.

Doporučené čtení

^