Metódy ArrayList v Jave

arraylist methods java tutorial with example programs

V tomto výučbe sa budeme diskutovať o metódach Java ArrayList, ako sú add, addAll, remove, removeAll, size, contains, keepAll, Sort, Reverse, atď. S príkladmi:

V predchádzajúcom tutoriáli sme preskúmali dátovú štruktúru ArrayList a triedu ArrayList poskytnutú pre túto dátovú štruktúru / zbierku v Jave. Naučili sme sa vytvárať, inicializovať atď. Objektov ArrayList.

Okrem týchto funkcií, ktoré nám pomáhajú definovať ArrayList, poskytuje trieda ArrayList v Jave aj plnohodnotné funkčné API, ktoré pozostáva z metód používaných na manipuláciu s objektmi ArrayList.

=> Skontrolujte VŠETKY návody Java tu.

Tieto metódy nám umožňujú pridávať, mazať, vyhľadávať prvky v zozname ArrayList, ako aj načítať dĺžku / veľkosť prvkov ArrayList atď.

Java ArrayList_Methods

V tomto výučbe sa budeme podrobne venovať týmto metódam na jednoduchých príkladoch programovania.

Čo sa dozviete:

V nasledujúcej tabuľke sú uvedené všetky metódy, ktoré poskytuje trieda ArrayList.

Metóda	Metóda Prototyp	Opis metódy
Obsahuje	boolean obsahuje (Objekt o)	Skontroluje, či zoznam obsahuje daný prvok „o“. Ak je prvok prítomný, vráti hodnotu true.
Pridať	boolovský prírastok (E e)	Pridá daný prvok e na koniec zoznamu.
Pridať	void add (int index, E element)	Pridá daný prvok „element“ na určenú pozíciu „index“.
Pridať všetko	boolean addAll (kolekcia c)	Na koniec zoznamu pridá všetky prvky v danej kolekcii c.
Pridať všetko	boolean addAll (int index, kolekcia c)	Pridá všetky prvky v danej kolekcii c na pozíciu určenú indexom v zozname.
jasný	prázdnota clear ()	Vymaže zoznam odstránením všetkých prvkov zo zoznamu.
Klonovať	Klon objektu ()	Vytvorí plytkú kópiu daného súboru ArrayList.
zabezpečiť kapacitu	void ensureCapacity (int minCapacity)	Zvyšuje kapacitu ArrayList, aby sa zabezpečilo, že má minCapacity.
Získajte	E get (int index)	Vráti prvok v zozname na pozícii určenej parametrom „index“.
indexOf	int indexOf (Objekt o)	Vráti index prvého výskytu prvku o v zozname. -1, ak prvok o nie je v zozname.
je prázdny	boolean isEmpty ()	Skontroluje, či je daný zoznam prázdny.
Iterátor	Iterátor iterátor ()	Vráti iterátor, ktorý má prechádzať prvkami zoznamu v správnom poradí.
lastIndexOf	int lastIndexOf (objekt o)	Vráti index posledného výskytu zadaného prvku o v zozname. -1, ak sa prvok v zozname nenachádza.
listIterator	ListIterator listIterator ()	Vráti iterátor zoznamu na prechádzanie prvkami daného zoznamu.
listIterator	ListIterator listIterator (int index)	Vráti iterátor zoznamu, ktorý začína od určenej polohy „index“ a prechádza cez prvky daného zoznamu.
odstrániť	E remove (int index)	Vymaže prvok z „indexu“ v zozname ArrayList.
odstrániť	boolean remove (Objekt o)	Vymaže prvý výskyt prvku o zo zoznamu.
odobrať všetky	boolean removeAll (kolekcia c)	Odstráni všetky prvky zo zoznamu, ktoré sa zhodujú s prvkami v danej kolekcii c.
removeRange	protected void removeRange (int fromIndex, int toIndex)	Odstráni zo zoznamu prvky zadané v danom rozsahu odIndex (vrátane) doIndex (výhradne).
keepAll	boolean keepAll (kolekcia c)	Zachová tie prvky v zozname, ktoré sa zhodujú s prvkami v danej kolekcii c.
nastaviť	Sada E (int index, prvok E)	Nastaví hodnotu prvku pri danom „indexe“ na novú hodnotu danú „prvkom“.
veľkosť	veľkosť int ()	Vráti celkový počet prvkov alebo dĺžku zoznamu.
podzoznam	Zoznam sublistov (int fromIndex, int toIndex)	Vráti podzoznam medzi daným rozsahom, od indexu do indexu pre daný zoznam.
toArray	Objekt [] toArray ()	Skonvertuje daný zoznam na pole.
toArray	T [] toArray (T [] a)	Skonvertuje daný zoznam na pole typu daného znakom a.
trimToSize	void trimToSize ()	Orezáva kapacitu poľa ArrayList na veľkosť alebo počet prvkov v zozname.

Ďalej si podrobne rozoberieme každú z týchto metód z funkčného API ArrayList a predstavíme príklady programovania. Po diskusii o všetkých vyššie uvedených metódach preberieme aj niektoré špecifické operácie, ktoré sa vykonávajú pomocou ArrayLists, ktoré nie sú súčasťou API funkcie ArrayList.

Pridať ArrayList

Prototyp: boolovský prírastok (E e)
Parametre: e => Element, ktorý sa má pridať do zoznamu ArrayList.
Návratová hodnota: true => Prvok bol úspešne pridaný.
Popis: Pridá daný prvok e na koniec zoznamu.

príklad pre abstraktné rozhranie v jave

II.

Prototyp: void add (int index, E element)

Parametre:

index => Poloha, v ktorej sa má prvok pridať.
Element => Element, ktorý sa má pridať do zoznamu ArrayList.

Návratová hodnota: neplatný

Popis: Pridá daný prvok „element“ na určenú pozíciu „index“ posunutím prvku v tejto polohe a následných prvkov doprava.

Výnimky: IndexOutOfBoundsException => Ak je zadaný index mimo rozsahu.

ArrayList addAll

Prototyp: boolean addAll (kolekcia c)
Parametre: c => Kolekcia, ktorej prvky sa majú pridať do zoznamu ArrayList.
Návratová hodnota: true => Ak operácia zmenila ArrayList.

Popis: Na koniec zoznamu pridá všetky prvky v danej kolekcii c. Výsledok operácie je nedefinovaný, ak sa kolekcia počas operácie zmení.

Výnimky: NullPointerException => Ak je uvedená kolekcia c má hodnotu null.

Prototyp: boolean addAll (int index, kolekcia c)
Parametre: index => Poloha, na ktorú sa majú pridať prvky v danej kolekcii.
Návratová hodnota: true => Ak sa zoznam zmenil v dôsledku operácie.

Popis: Pridá všetky prvky v danej kolekcii c na pozíciu určenú indexom v zozname. Prvok v zadanom indexe a nasledujúce prvky sú posunuté doprava. Výsledok operácie nie je definovaný, ak sa pridávaná kolekcia počas operácie zmení.

Výnimky: IndexOutOfBoundsException: ak je index, do ktorého sa má pridať kolekcia, za hranicami
NullPointerException: ak má daná kolekcia c hodnotu null.

Nasledujúci program Java demonštruje použitie metód add a 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); } }

Výkon:

Initial ArrayList: [Dillí, Bombaj, Chennai, Kalkata]
rrayList po pridaní prvku do indexu 1: [Dillí, NYC, Bombaj, Chennai, Kalkata]
ArrayList po pridaní zoznamu do indexu 4: [Dillí, NYC, Bombaj, Chennai, Pune, Hyderabad, Kalkata]

Výstup Java ArrayList addAll

Vyššie uvedený program používa na pridanie prvkov do zoznamu obe verzie metódy add. Pridá tiež kolekciu do zoznamu v zadanom indexe. Všimnite si posun prvkov vpravo od ArrayList, ako je zrejmé z výstupu programu.

ArrayList Pridať do popredia

Ako už bolo spomenuté, prvá verzia metódy pridávania pridáva prvky na koniec zoznamu. Ak chcete pridať prvky na začiatok zoznamu ArrayList, musíte použiť druhú verziu metódy pridania. Táto metóda pridania berie index ako parameter. Tento index je pozícia, na ktorú sa má prvok pridať.

Ak chcete teda pridať prvok na začiatok zoznamu, musíte určiť index ako 0, čo je začiatok zoznamu.

Nasledujúci program pridáva prvok do prednej časti 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); } }

Výkon:

Initial ArrayList:
[5, 7, 9]
ArrayList po pridaní prvkov na začiatku:
[1, 3, 5, 7, 9]

Výstup - ArrayList pridať do popredia

ArrayList odstrániť

Prototyp: E remove (int index)
Parametre: index => Poloha, v ktorej sa má prvok odstrániť zo zoznamu ArrayList.
Návratová hodnota: E => Element, ktorý je vymazaný
Popis: Vymaže prvok z „indexu“ v zozname ArrayList a nasledujúce prvky presunie doľava.
Výnimky: IndexOutOfBoundsException => Zadaný index je mimo rozsahu.

II.

Prototyp: boolean remove (Objekt o)
Parametre: o => Element, ktorý sa má odstrániť zo zoznamu ArrayList.
Návratová hodnota: true => Ak je prvok v zozname.

Popis: Vymaže prvý výskyt prvku o zo zoznamu. Ak sa prvok v zozname nenachádza, táto operácia nemá žiadny vplyv. Po odstránení prvku sa nasledujúce prvky posunú doľava.

ArrayList removeAll

Prototyp: boolean removeAll (kolekcia c)
Parametre: c => Zbierka, ktorej prvky sa zhodujú s prvkami ArrayList a majú byť odstránené.
Návratová hodnota: true => Ak je operácia zmenená na ArrayList.

Popis: Odstráni všetky prvky zo zoznamu, ktoré sa zhodujú s prvkami v danej kolekcii. C. Výsledkom je, že zvyšné prvky sa posunú doľava od zoznamu.

Výnimky: ClassCastException => Trieda nie je rovnaká ako trieda určenej kolekcie, čo znamená, že trieda je nekompatibilná.
NullPointerException => Ak má daná kolekcia c hodnotu null; alebo ak má c prázdny prvok a zbierka to neumožňuje.

ArrayList removeRange

Prototyp: protected void removeRange (int fromIndex, int toIndex)
Parametre: fromIndex => Index počiatočného prvku rozsahu, ktorý sa má odstrániť.
toIndex => Index prvku za posledným prvkom v rozsahu, ktorý sa má odstrániť.
Návratová hodnota: neplatný
Popis: Odstráni zo zoznamu prvky zadané v danom rozsahu odIndex (vrátane) doIndex (výhradne). Táto operácia skracuje dĺžku zoznamu o (toIndex-fromIndex). Táto operácia nemá žiadny vplyv v prípade fromIndex = toIndex.
Výnimky: IndexOutOfBoundsException => Ak je niektorý z indexov (fromIndex alebo toIndex) mimo medzí.

Implementujme program Java, aby sme demonštrovali niektoré z týchto metód odstránenia, o ktorých sme hovorili vyššie.

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

Výkon:

Initial ArrayList: [Dillí, Bombaj, Chennai, Kalkata, Pune, Hyderabad
ArrayList po odstránení prvku na indexe 2: [Dillí, Bombaj, Kalkata, Pune, Hajdarábad]
ArrayList po odstránení prvku -> Kalkata: [Dillí, Bombaj, Pune, Hyderabad]
ArrayList po volaní removeAll: [Mumbai, Pune]

Output- ArrayList removeAll range

Veľkosť zoznamu (dĺžka)

Prototyp: veľkosť int ()
Parametre: NIL
Návratová hodnota: int => Počet prvkov v zozname ArrayList.
Popis: Vráti celkový počet prvkov alebo dĺžku poľa ArrayList.

EnsureCapacity

Prototyp: void ensureCapacity (int minCapacity)
Parametre: minCapacity => Minimálna požadovaná kapacita pre ArrayList.
Návratová hodnota: neplatný
Popis: Zvyšuje kapacitu ArrayList, aby sa zabezpečilo, že má minCapacity.

trimToSize

Prototyp: void trimToSize ()
Parametre: NIL
Návratová hodnota: neplatný
Popis: Orezáva kapacitu poľa ArrayList na veľkosť alebo počet prvkov v zozname.

Nasledujúci príklad programovania demonštruje metódy size (), ensureCapacity () a 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 + ' '); } } }

Výkon:

Počiatočná veľkosť: 0
Pôvodný zoznam: [2, 4, 6, 8, 10]
Veľkosť poľa po pridaní: 5
Veľkosť ArrayList po zavolaní zaistenia Capacity () a pridaní: 7
Veľkosť poľa po operácii trimToSize (): 7
ArrayList final:
2 4 6 8 10 12 14

Výstup - veľkosť zoznamu (dĺžka)

ArrayList obsahuje

Prototyp: boolean obsahuje (Objekt o)
Parametre: o => Element, ktorý sa má skontrolovať, ak je prítomný v zozname ArrayList.
Návratová hodnota: true => Ak ArrayList obsahuje prvok o.
Popis: Skontroluje, či zoznam obsahuje daný prvok „o“. Ak je prvok prítomný, vráti hodnotu true.

V nasledujúcom programe používame metódu „obsahuje“.

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

Výkon:

ako zoradiť int pole v jave

ArrayList obsahuje („Red Green“): false
ArrayList obsahuje („modrý“): true
ArrayList obsahuje („žltý“): false
ArrayList obsahuje („Biela“): true

Výstup - ArrayList obsahuje

Ako je uvedené v predchádzajúcom výstupe, metóda „obsahuje“ kontroluje, či je poskytnutý argument v ArrayList, a vracia hodnotu true alebo false.

ArrayList dostať

Prototyp: E get (int index)
Parametre: index => Index, pri ktorom sa má prvok načítať z ArrayList.
Návratová hodnota: E => Hodnota prvku pri danom indexe v zozname ArrayList.
Popis: Vráti prvok v zozname na pozícii určenej parametrom „index“.
Výnimky: IndexOutOfBoundsException => Ak je index mimo medzí.

Sada ArrayList (Nahradiť prvok)

Prototyp: Sada E (int index, prvok E)
Parametre: index => Index, pri ktorom sa má prvok nahradiť.
Element => Nový prvok, ktorý sa má nastaviť v zadanom indexe.
Návratová hodnota: E => Prvok, ktorý je nahradený nastavenou operáciou.
Popis: Nastaví hodnotu prvku v danom indexe na novú hodnotu danú v prvku.
Výnimky: IndexOutOfBoundsException => Ak je index mimo medzí

Nižšie uvedený program Java používa na získanie a nahradenie hodnôt v zozname ArrayList metódu get () a set ().

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

Výkon:

Záznam na indexe 2 pred zavolaním do nastavenia: Modrý
Záznam na indexe 2 po vyvolaní nastavenia: Žltý

Výkon

ArrayList jasný

Prototyp: prázdnota clear ()
Parametre: NIL
Návratová hodnota: neplatný
Popis: Vymaže zoznam odstránením všetkých prvkov zo zoznamu.

ArrayList isEmpty

Prototyp: boolean isEmpty ()
Parametre: NIL
Návratová hodnota: true => ak je zoznam prázdny
Popis: Skontroluje, či je daný zoznam prázdny.

Funkcie Clear () a isEmpty () sú demonštrované nižšie.

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

Výkon:

Zoznam polí: [červená, zelená, modrá, biela]
Je ArrayList prázdny po clear ()? : pravda

Výstup - isEmpty ArrayList

ArrayList indexOf

Prototyp: int indexOf (Objekt o)
Parametre: o => Element, ktorého index sa nachádza v zozname ArrayList.
Návratová hodnota: int => Index prvého výskytu prvku v zozname.
Popis: Vráti index prvého výskytu prvku o v zozname. -1, ak sa prvok o v zozname nenachádza.

ArrayList lastIndexOf

Prototyp: int lastIndexOf (objekt o)
Parametre: o => Element, ktorý sa má vyhľadať.
Návratová hodnota: int => Index posledného výskytu prvku v zozname.
Popis: Vráti index posledného výskytu zadaného prvku o v zozname. -1, ak sa prvok v zozname nenachádza.

Nižšie uvedený program Java demonštruje metódy indexOf a lastIndexOf z 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)); } }

Výkon:

Zoznam polí: [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

Výkon

ArrayList toArray

Prototyp: Objekt [] toArray ()
Parametre: NIL
Návratová hodnota: Objekt [] => pole. Toto vrátené pole obsahuje všetky prvky zoznamu v správnom poradí.
Popis: Skonvertuje daný zoznam na pole.

Prototyp: T [] toArray (T [] a)

Parametre: a => Pole na uloženie prvkov zoznamu. Ak veľkosť poľa nie je dostatočná pre prvky zoznamu, vytvorí sa ďalšie pole rovnakého typu ako a na ukladanie prvkov.

Návratová hodnota: T [] => Pole, ktoré obsahuje všetky prvky zoznamu.
Popis: Skonvertuje daný zoznam na pole typu daného znakom a.

Výnimky: ArrayStoreException => Ak existuje nesúlad medzi runtime typom poľa a runtime typom alebo supertypom jeho prvkov.
NullPointerException => Dané pole má hodnotu Null

Program Java uvedený nižšie demonštruje metódu toArray z 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)); } }

Výkon:

ArrayList: [10, 20, 30, 40, 50]
Pole z ArrayList: [10, 20, 30, 40, 50]

Výstup - toArray ArrayList

Klon ArrayList

Prototyp: Klon objektu ()
Parametre: NIL
Návratová hodnota: Object => Klon inštancie ArrayList.
Popis: Vytvorí plytkú kópiu daného súboru ArrayList.

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

Výkon:

Originálny zoznam polí: [Apple, Orange, Melon, Grapes]
Cloned ArrayList: [Apple, Orange, Melon, Grapes]
Originálny zoznam ArrayList po pridaní a odstránení: [Apple, Melon, Grapes, Mango]
Klonovaný zoznam ArrayList po zmene originálu: [Apple, Orange, Melon, Grapes]

výstup - klon polia

Z vyššie uvedeného výstupu programu vidíte, že klonovaný ArrayList je plytkou kópiou pôvodného ArrayList. To znamená, že keď sa zmení pôvodný ArrayList, tieto zmeny sa neodrazia v klonovanom ArrayList, pretože nezdieľajú pamäťové polohy každého prvku.

Pre vytvorenie hlbokej kópie Array je potrebné prekonať pôvodný ArrayList a každý z jeho prvkov je potrebné skopírovať do cieľového ArrayList.

Podzoznam ArrayList

Prototyp: Zoznam sublistov (int fromIndex, int toIndex)
Parametre: fromIndex => Počiatočný index rozsahu (vrátane)
toIndex => Koncový index rozsahu (exkluzívne)
Návratová hodnota: Zoznam => Podzoznam zoznamu v danom rozsahu.

Popis: Vráti podzoznam medzi daným rozsahom, od indexu po index pre daný zoznam. Upozorňujeme, že tento podlist alebo zobrazenie zoznamu v danom rozsahu podporuje všetky operácie podporované zoznamom. Ak fromIndex = toIndex, nevráti sa žiadne zobrazenie.

Výnimky: IndexOutOfBoundsException => Vyvolá sa, keď je parameter toIndex mimo rozsahu.
IllegalArgumentException => Ak fromIndex> toIndex, t. J. Indexy sú mimo poradia.

Pozrime sa na príklad metódy 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); } }

Výkon:

Originálny zoznam polí: [5, 10, 15, 20, 25, 30, 35, 40, 45, 50]
Podzoznam daného poľa ArrayList: [15, 20, 25, 30]

Výkon

ArrayList keepAll

Prototyp: boolean keepAll (kolekcia c)
Parametre: c => Zbierka s prvkami, ktoré sa majú v zozname zachovať.
Návratová hodnota: true => Ak sa ArrayList zmenil v dôsledku operácie.
Popis: Zachová tie prvky v zozname, ktoré sa zhodujú s prvkami v danej kolekcii c.

Výnimky: ClassCastException => Typ zbierky a typ zoznamu sa nezhodujú
NullPointerException => Daná kolekcia má hodnotu Null alebo zoznam obsahuje prvok Null a kolekcia neumožňuje hodnoty Null.

Nasledujúci program demonštruje metódu keepAll.

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

Výkon:

Originálny zoznam polí: [červená, zelená, modrá, žltá]
Prvky kolekcie, ktoré sa majú v zozname zachovať: [červená, modrá]
ArrayList po keepAll call: [červená, modrá]

Výstup - metóda retailAll

Iterátor ArrayList

Prototyp: Iterátor iterátor ()
Parametre: NIL
Návratová hodnota: Iterator => iterátor nad prvkami zoznamu.
Popis: Vráti iterátor, ktorý má prechádzať prvkami zoznamu v správnom poradí.

ArrayList listIterator

Prototyp: ListIterator listIterator ()
Parametre: NIL
Návratová hodnota: ListIterator => listIterator nad prvkami zoznamu.
Popis: Vráti iterátor zoznamu na prechádzanie prvkami daného zoznamu.

II.

Prototyp: ListIterator listIterator (int index)
Parametre: index => Poloha prvého prvku v zoznameIterátor.
Návratová hodnota: ListIterator => ListIterator pre zoznam zo zadaného indexu.
Popis: Vráti iterátor zoznamu, ktorý začína od určenej polohy „index“ a prechádza cez prvky daného zoznamu.
Výnimky: IndexOutOfBoundsException => Daný index je mimo rozsahu.

Príklad metód iterator () a 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() + ' '); } } }

Výkon:

Vypísať obsah pomocou metódy Iterator ():
Bombaj Pune Hyderabad Dillí
Uveďte obsah pomocou metódy listIterator ():
Bombaj Pune Hyderabad Dillí

Výstup - Iterátorové a listIterátorové metódy

Pridajte pole do ArrayList v Jave

ArrayList podporuje metódu addAll na pridanie prvkov kolekcie do ArrayList. Podobným spôsobom môžete do poľa ArrayList pridať aj pole. To sa deje pomocou metódy ‘Collections.addAll’.

Príklad pridania poľa do zoznamu 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); } }

Výkon:

Initial ArrayList: [Dillí, Bombaj, Chennai, Kalkata]
ArrayList po pridaní poľa: [Dillí, Bombaj, Chennai, Kalkata, Kóčin, Goa]

výstup - Pridajte pole do zoznamu skladieb v Jave

Zoradiť ArrayList v Jave

ArrayList používa na triedenie svojich prvkov metódu Collections.sort. V predvolenom nastavení je zoznam zoradený vzostupne podľa metódy Collections.sort. Ak sa má zoznam ArrayList zoradiť zostupne, musíte metóde triedenia poskytnúť parameter „Collections.reverseOrder ()“.

Ďalej je uvedený program na triedenie ArrayList vzostupne a zostupne:

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

Výkon:

Initial ArrayList: [červená, zelená, modrá, žltá]
ArrayList zoradené vzostupne:
[Modrá, zelená, červená, žltá]
ArrayList zoradené zostupne:
[Žltá, červená, zelená, modrá]

Výstup - zoradenie arraylistu v Jave

V prípade, že ArrayList obsahuje ďalšie objekty triedy ako prvky, môžete využiť porovnateľné a komparátorové rozhrania. Viac podrobností o rozhraniach sa dozvieme v našich ďalších tutoriáloch.

Obrátiť zoznam ArrayList v Jave

ArrayList môžete tiež obrátiť v Jave. Jedným zo spôsobov, ako to urobiť, je použiť tradičnú metódu prechodu po zozname ArrayList v opačnom poradí a skopírovať každý prvok do nového zoznamu ArrayList.

Ďalšou metódou je použitie triedy Collections, ktorá poskytuje metódu „reverzu“, ktorá sa používa na obrátenie kolekcie.

Ďalej je uvedený program na obrátenie zoznamu ArrayList pomocou triedy Collections.

ako vyzerá modem a router

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

Výkon:

Initial ArrayList: [1, 3, 5, 7, 9]
Zoznam obrátených súborov: [9, 7, 5, 3, 1]

Výstup - spätný chod a zoznam polí

Odstrániť duplikáty z ArrayList v Jave

Ak chcete odstrániť duplikáty z ArrayList, môžete sa opäť uchýliť k tradičnej metóde používania iterátora na prechádzanie ArrayListom a ukladanie iba prvého výskytu prvku do iného ArrayList.

Ešte ďalšou metódou je použitie metódy „zreteľný ()“ triedy stream (). Táto metóda vracia prúd odlišných prvkov. Funkcia stream () je k dispozícii v prostredí Java od verzie Java 8.

Implementácia metódy stream () .distinct () je uvedená nižšie:

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

Výkon:

Originálny zoznam polí: [1, 2, 3, 1, 3, 5, 5, 6, 6, 7, 7, 8, 8]
ArrayList bez duplikátov: [1, 2, 3, 5, 6, 7, 8]

Výstup - Odstráňte duplikáty z ArrayList

Zamiešajte (náhodne) zoznam Array v jazyku Java

Môžete tiež „zamiešať“ alebo náhodne rozdeliť prvky ArrayList. To sa deje pomocou metódy Collections.shuffle (). Pri použití tejto metódy môžete ArrayList zamiešať s predvoleným nastavením alebo poskytnúť funkciu random (), ktorá náhodne rozdelí prvky podľa poskytnutej náhodnej hodnoty.

Program Java na dosiahnutie tohto cieľa je uvedený nižšie.

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

Výkon:

Originálny zoznam ArrayList: [východ, západ, sever, juh, juhozápad, severovýchod] Shuffled ArrayList bez náhodného výberu (): [sever, severovýchod, východ, juhozápad, juh, západ]
Shuffled ArrayList with Random (): [juh, východ, sever, severovýchod, západ, juhozápad]
Shuffled ArrayList with Random (2): [juhozápad, juh, východ, severovýchod, sever, západ]

Výstup - Zameniť (náhodne) zoznam ArrayList

často kladené otázky

Otázka 1) Aký je rozdiel medzi homogénnymi a heterogénnymi kontajnermi v Jave?

Odpoveď: Homogénne nádoby obsahujú predmety / prvky rovnakého typu. Na druhej strane heterogénne kontajnery majú objekty zmiešaného typu.

Otázka č. 2) Je ArrayList v Jave heterogénny?

Odpoveď: Áno. Pretože ArrayLists podporuje všeobecné a teda mazanie typu, môže obsahovať zmiešané objekty, ak je implementovaný ako všeobecný ArrayList.

Otázka č. 3) Môže ArrayList uložiť int?

Odpoveď: Nie. ArrayLists nemôže ukladať hodnoty ako int, ale môže ukladať celočíselné objekty, pretože ArrayLists môžu obsahovať iba objekty. Na ukladanie primitívnych typov by ste teda mali používať triedy wrapperov ako Integer for ints.

Otázka č. 4) Čo sa stane, keď je ArrayList plný?

Odpoveď: Každý objekt ArrayList má funkciu s názvom „kapacita“. Keď je ArrayList plný, kapacita ArrayList sa automaticky zvyšuje, aby sa vytvoril priestor pre ďalšie prvky.

Otázka č. 5) Aký je rozdiel medzi metódou removeAll a keepAll v ArrayList?

Odpoveď: Metódy ArrayList „removeAll“ a „keepAll“ vykazujú opačné správanie.

Zatiaľ čo metóda removeAll odstráni všetky prvky zo zoznamu, ktoré sa zhodujú s kolekciou odovzdanou ako argument tejto metóde, keepAll si na druhej strane ponechá všetky prvky v zozname, ktoré sa zhodujú s prvkami kolekcie.

Záver

V tomto tutoriáli sme podrobne diskutovali metódy ArrayList s príkladom.

Zvážili sme tiež niektoré špeciálne prípady, ako je pridanie prvkov na začiatok zoznamu. Diskutovali sme tiež o ďalších operáciách na ArrayList, ako je triedenie, obrátenie a premiešanie ArrayList.

V našom pripravovanom výučbe sa budeme venovať niektorým z konverzií ArrayList.

=> Dajte si pozor na jednoduchú sériu školení Java tu.

Metódy ArrayList v Jave - návod s ukážkovými programami