ArrayList-Methoden in Java

arraylist methods java tutorial with example programs

Versuchen Sie Unser Instrument, Um Probleme Zu Beseitigen

Wählen Sie Das Betriebssystem Aus Wählen Sie Ein Projektionsprogramm (Optional)

Beschreiben Sie Ihr Problem

In diesem Tutorial werden Java ArrayList-Methoden wie add, addAll, remove, removeAll, Größe, enthält, behaltenAll, Sortieren, Umkehren usw. anhand von Beispielen erläutert:

Im vorherigen Lernprogramm haben wir die ArrayList-Datenstruktur und die ArrayList-Klasse untersucht, die für diese Datenstruktur / Sammlung in Java bereitgestellt wurden. Wir haben die Erstellung, Initialisierung usw. der ArrayList-Objekte gelernt.

Abgesehen von diesen Funktionen, die uns beim Definieren von ArrayList helfen, bietet die ArrayList-Klasse in Java auch eine vollwertige Funktions-API, die aus Methoden besteht, mit denen ArrayList-Objekte bearbeitet werden.

=> Überprüfen Sie ALLE Java-Tutorials hier.

Mit diesen Methoden können wir Elemente in der ArrayList hinzufügen, löschen, suchen sowie die Länge / Größe von ArrayList-Elementen usw. abrufen.

Java ArrayList_Methods

Wie öffne ich eine Torrent-Datei?

In diesem Tutorial werden wir diese Methoden anhand einfacher Programmierbeispiele ausführlich diskutieren.

Was du lernen wirst:

In der folgenden Tabelle sind alle Methoden aufgeführt, die von der ArrayList-Klasse bereitgestellt werden.

Methode	Methodenprototyp	Methodenbeschreibung
Enthält	Boolescher Wert enthält (Objekt o)	Überprüft, ob die Liste das angegebene Element 'o' enthält. Gibt true zurück, wenn das Element vorhanden ist.
Hinzufügen	Boolesches Addieren (E e)	Fügt das angegebene Element e am Ende der Liste hinzu.
Hinzufügen	void add (int index, E element)	Fügt das angegebene Element 'Element' an der angegebenen Position 'Index' hinzu.
Füge alle Hinzu	boolean addAll (Sammlung c)	Fügt alle Elemente in der angegebenen Sammlung c am Ende der Liste hinzu.
Füge alle Hinzu	boolean addAll (int index, Sammlung c)	Fügt alle Elemente in der angegebenen Sammlung c an der Position hinzu, die durch den Index in der Liste angegeben ist.
klar	void clear ()	Löscht die Liste, indem alle Elemente aus der Liste entfernt werden.
Klon	Objektklon ()	Erstellt eine flache Kopie der angegebenen ArrayList.
Stellen Sie sicher, dass die Kapazität	void sureCapacity (int minCapacity)	Erhöht die Kapazität der ArrayList, um sicherzustellen, dass sie über die minCapacity verfügt.
Erhalten	E get (int index)	Gibt das Element in der Liste zurück, das an der durch 'Index' angegebenen Position vorhanden ist.
Index von	int indexOf (Objekt o)	Gibt den Index des ersten Auftretens des Elements o in der Liste zurück. -1 wenn das Element o nicht in der Liste vorhanden ist.
ist leer	boolean isEmpty ()	Überprüft, ob die angegebene Liste leer ist.
Iterator	Iterator iterator ()	Gibt einen Iterator zurück, der die Listenelemente in der richtigen Reihenfolge durchläuft.
lastIndexOf	int lastIndexOf (Objekt o)	Gibt den Index des letzten Vorkommens des angegebenen Elements o in der Liste zurück. -1, wenn das Element nicht in der Liste vorhanden ist.
listIterator	ListIterator listIterator ()	Gibt den Listeniterator zurück, um die Elemente der angegebenen Liste zu durchlaufen.
listIterator	ListIterator listIterator (int index)	Gibt den Listeniterator ab der angegebenen Position 'Index' zurück, um die Elemente der angegebenen Liste zu durchlaufen.
entfernen	E entfernen (int index)	Löscht das Element am Index in der ArrayList.
entfernen	boolean remove (Objekt o)	Löscht das erste Vorkommen des Elements o aus der Liste.
alles entfernen	boolean removeAll (Sammlung c)	Entfernt alle Elemente aus der Liste, die mit den Elementen in der angegebenen Sammlung übereinstimmen. C.
removeRange	protected void removeRange (int fromIndex, int toIndex)	Entfernt die im angegebenen Bereich angegebenen Elemente von Index (einschließlich) bis Index (exklusiv) aus der Liste.
behaltenAlle	boolean keepAll (Sammlung c)	Behält die Elemente in der Liste bei, die mit den Elementen in der angegebenen Sammlung übereinstimmen. C.
einstellen	E set (int index, E element)	Setzt den Elementwert am angegebenen 'Index' auf den neuen Wert, der durch 'Element' angegeben wird.
Größe	int size ()	Gibt die Gesamtzahl der Elemente oder die Länge der Liste zurück.
Unterliste	List subList (int fromIndex, int toIndex)	Gibt eine Unterliste zwischen dem angegebenen Bereich von Index bis Index für die angegebene Liste zurück.
toArray	Objekt () toArray ()	Konvertiert die angegebene Liste in ein Array.
toArray	T () toArray (T () a)	Konvertiert die angegebene Liste in ein Array des Typs a.
trimToSize	void trimToSize ()	Reduziert die ArrayList-Kapazität auf die Größe oder Anzahl der in der Liste vorhandenen Elemente.

Als Nächstes werden wir jede dieser Methoden aus der ArrayList-Funktions-API ausführlich diskutieren und Programmierbeispiele präsentieren. Nachdem wir alle oben aufgeführten Methoden besprochen haben, werden wir auch einige spezifische Operationen aufnehmen, die mit ArrayLists ausgeführt werden, die nicht Teil der ArrayList-Funktions-API sind.

ArrayList hinzufügen

ich

Prototyp: Boolesches Addieren (E e)
Parameter: e => Element, das der ArrayList hinzugefügt werden soll.
Rückgabewert: true => Element erfolgreich hinzugefügt.
Beschreibung: Fügt das angegebene Element e am Ende der Liste hinzu.

II.

Prototyp: void add (int index, E element)

Parameter:

index => Position, an der das Element hinzugefügt werden soll.
Element => Element, das der ArrayList hinzugefügt werden soll.

Rückgabewert: Leere

Beschreibung: Fügt das angegebene Element 'Element' an der angegebenen Position 'Index' hinzu, indem das Element an dieser Position und die nachfolgenden Elemente nach rechts verschoben werden.

Ausnahmen: IndexOutOfBoundsException => Wenn der angegebene Index außerhalb des Bereichs liegt.

ArrayList addAll

ich

Prototyp: boolean addAll (Sammlung c)
Parameter: c => Sammlung, deren Elemente zur ArrayList hinzugefügt werden sollen.
Rückgabewert: true => Wenn die Operation die ArrayList geändert hat.

Beschreibung: Fügt alle Elemente in der angegebenen Sammlung c am Ende der Liste hinzu. Das Ergebnis der Operation ist undefiniert, wenn die Sammlung während der Operation geändert wird.

Ausnahmen: NullPointerException => Wenn die angegebene Sammlung c null ist.

Prototyp: boolean addAll (int index, Sammlung c)
Parameter: index => Position, an der die Elemente in der angegebenen Sammlung hinzugefügt werden sollen.
Rückgabewert: true => Wenn sich die Liste infolge der Operation geändert hat.

Beschreibung: Fügt alle Elemente in der angegebenen Sammlung c an der Position hinzu, die durch den Index in der Liste angegeben ist. Das Element am angegebenen Index und die nachfolgenden Elemente werden nach rechts verschoben. Das Ergebnis der Operation ist undefiniert, wenn die hinzugefügte Sammlung während der Operation geändert wird.

Ausnahmen: IndexOutOfBoundsException: Wenn der Index, zu dem die Sammlung hinzugefügt werden soll, außerhalb der Grenzen liegt
NullPointerException: Wenn die angegebene Auflistung c null ist.

Das folgende Java-Programm demonstriert die Verwendung der Methoden add und 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); } }

Ausgabe:

Erste ArrayList: (Delhi, Mumbai, Chennai, Kolkata)
rrayList nach dem Hinzufügen eines Elements bei Index 1: (Delhi, NYC, Mumbai, Chennai, Kolkata)
ArrayList nach Hinzufügen einer Liste bei Index 4: (Delhi, NYC, Mumbai, Chennai, Pune, Hyderabad, Kolkata)

Ausgabe von Java ArrayList addAll

Das obige Programm verwendet beide Versionen der Methode add, um der Liste Elemente hinzuzufügen. Außerdem wird der Liste am angegebenen Index eine Sammlung hinzugefügt. Beachten Sie die Verschiebung der Elemente rechts von der ArrayList, wie aus der Ausgabe des Programms hervorgeht.

ArrayList Nach vorne hinzufügen

Wie bereits erwähnt, fügt die erste Version der Methode add die Elemente am Ende der Liste hinzu. Wenn Sie die Elemente am Anfang der ArrayList hinzufügen möchten, müssen Sie die zweite Version der Methode add verwenden. Diese Add-Methode verwendet einen Index als Parameter. Dieser Index ist die Position, an der das Element hinzugefügt werden soll.

Um das Element am Anfang der Liste hinzuzufügen, müssen Sie den Index als 0 angeben, der der Anfang der Liste ist.

Das folgende Programm fügt der Vorderseite der ArrayList ein Element hinzu.

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

Ausgabe:

Anfängliche ArrayList:
(5, 7, 9)
ArrayList nach dem Hinzufügen von Elementen am Anfang:
(1, 3, 5, 7, 9)

Ausgabe - ArrayList wird an der Vorderseite hinzugefügt

ArrayList entfernen

ICH.

Prototyp: E entfernen (int index)
Parameter: index => Position, an der das Element aus der ArrayList entfernt werden soll.
Rückgabewert: E => Element, das gelöscht wird
Beschreibung: Löscht das Element am Index in der ArrayList und verschiebt nachfolgende Elemente nach links.
Ausnahmen: IndexOutOfBoundsException => Der angegebene Index liegt außerhalb des Bereichs.

II.

Prototyp: boolean remove (Objekt o)
Parameter: o => Element, das aus der ArrayList entfernt werden soll.
Rückgabewert: true => Wenn das Element in der Liste vorhanden ist.

Beschreibung: Löscht das erste Vorkommen des Elements o aus der Liste. Wenn das Element nicht in der Liste vorhanden ist, hat dieser Vorgang keine Auswirkung. Sobald das Element gelöscht ist, werden die nachfolgenden Elemente nach links verschoben.

ArrayList removeAll

Prototyp: boolean removeAll (Sammlung c)
Parameter: c => Sammlung, deren Elemente mit denen von ArrayList übereinstimmen und entfernt werden sollen.
Rückgabewert: true => Wenn die ArrayList durch die Operation geändert wird.

Beschreibung: Entfernt alle Elemente aus der Liste, die mit den Elementen in der angegebenen Sammlung übereinstimmen. C. Infolgedessen werden die verbleibenden Elemente nach links von der Liste verschoben.

Ausnahmen: ClassCastException => Die Klasse ist nicht mit der angegebenen Sammlung identisch, was bedeutet, dass die Klasse nicht kompatibel ist.
NullPointerException => Wenn die angegebene Auflistung c null ist; oder wenn c ein Nullelement hat und es von der Sammlung nicht zugelassen wird.

ArrayList removeRange

Prototyp: protected void removeRange (int fromIndex, int toIndex)
Parameter: fromIndex => Index des Startelements des zu entfernenden Bereichs.
toIndex => Index des Elements nach dem letzten zu entfernenden Element im Bereich.
Rückgabewert: Leere
Beschreibung: Entfernt die im angegebenen Bereich angegebenen Elemente von Index (einschließlich) bis Index (exklusiv) aus der Liste. Diese Operation verkürzt die Länge der Liste um (toIndex-fromIndex). Diese Operation hat keine Auswirkung, falls fromIndex = toIndex.
Ausnahmen: IndexOutOfBoundsException => Wenn einer der Indizes (fromIndex oder toIndex) außerhalb der Grenzen liegt.

Lassen Sie uns ein Java-Programm implementieren, um einige dieser oben beschriebenen Entfernungsmethoden zu demonstrieren.

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

Ausgabe:

Erste ArrayList: (Delhi, Mumbai, Chennai, Kolkata, Pune, Hyderabad
ArrayList nach Entfernen des Elements bei Index 2: (Delhi, Mumbai, Kolkata, Pune, Hyderabad)
ArrayList nach dem Entfernen des Elements -> Kolkata: (Delhi, Mumbai, Pune, Hyderabad)
ArrayList nach Aufruf von removeAll: (Mumbai, Pune)

Output-ArrayList removeAll-Bereich

ArrayList-Größe (Länge)

Prototyp: int size ()
Parameter: NULL
Rückgabewert: int => Anzahl der Elemente in der ArrayList.
Beschreibung: Gibt die Gesamtzahl der Elemente oder die Länge der ArrayList zurück.

Stellen Sie die Kapazität sicher

Prototyp: void sureCapacity (int minCapacity)
Parameter: minCapacity => Die für die ArrayList gewünschte Mindestkapazität.
Rückgabewert: Leere
Beschreibung: Erhöht die Kapazität der ArrayList, um sicherzustellen, dass sie über die minCapacity verfügt.

trimToSize

Prototyp: void trimToSize ()
Parameter: NULL
Rückgabewert: Leere
Beschreibung: Reduziert die ArrayList-Kapazität auf die Größe oder Anzahl der in der Liste vorhandenen Elemente.

Das folgende Programmierbeispiel zeigt die Methoden size (), sureCapacity () und 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 + ' '); } } }

Ausgabe:

Anfangsgröße: 0
Originalliste: (2, 4, 6, 8, 10)
ArrayList Größe nach dem Hinzufügen: 5
ArrayList Größe nach dem Aufruf von sureCapacity () und Hinzufügen einer Operation: 7
ArrayList-Größe nach der Operation trimToSize (): 7
ArrayList final:
2 4 6 8 10 12 14

Größe der AusgabearrayList (Länge)

ArrayList enthält

Prototyp: Boolescher Wert enthält (Objekt o)
Parameter: o => Element, das überprüft werden soll, wenn es in der ArrayList vorhanden ist.
Rückgabewert: true => Wenn die ArrayList das Element o enthält.
Beschreibung: Überprüft, ob die Liste das angegebene Element 'o' enthält. Gibt true zurück, wenn das Element vorhanden ist.

Wir verwenden im folgenden Programm die Methode 'enthält'.

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

Ausgabe:

ArrayList enthält ('Rot Grün'): false
ArrayList enthält ('Blau'): true
ArrayList enthält ('Gelb'): false
ArrayList enthält ('Weiß'): true

Ausgabe - ArrayList enthält

Wie in der obigen Ausgabe gezeigt, prüft die Methode 'enthält', ob das angegebene Argument in der ArrayList vorhanden ist, und gibt true oder false zurück.

ArrayList get

Prototyp: E get (int index)
Parameter: index => Index, bei dem das Element aus der ArrayList abgerufen werden soll.
Rückgabewert: E => Elementwert am angegebenen Index in der ArrayList.
Beschreibung: Gibt das Element in der Liste zurück, das an der durch 'Index' angegebenen Position vorhanden ist.
Ausnahmen: IndexOutOfBoundsException => Wenn der Index außerhalb der Grenzen liegt.

ArrayList set (Element ersetzen)

Prototyp: E set (int index, E element)
Parameter: index => Index, bei dem das Element ersetzt werden soll.
Element => Neues Element, das auf den angegebenen Index gesetzt werden soll.
Rückgabewert: E => Element, das durch die eingestellte Operation ersetzt wird.
Beschreibung: Setzt den Elementwert am angegebenen 'Index' auf den neuen Wert, der durch 'Element' angegeben wird.
Ausnahmen: IndexOutOfBoundsException => Wenn der Index außerhalb der Grenzen liegt

Das folgende Java-Programm verwendet die Methoden get () und set (), um Werte in der ArrayList abzurufen und zu ersetzen.

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

Ausgabe:

Eintrag bei Index 2 vor Aufruf zum Einstellen: Blau
Eintrag bei Index 2 nach Aufruf zum Einstellen: Gelb

Ausgabe

ArrayList löschen

Prototyp: void clear ()
Parameter: NULL
Rückgabewert: Leere
Beschreibung: Löscht die Liste, indem alle Elemente aus der Liste entfernt werden.

ArrayList isEmpty

Prototyp: boolean isEmpty ()
Parameter: NULL
Rückgabewert: true => wenn die Liste leer ist
Beschreibung: Überprüft, ob die angegebene Liste leer ist.

Die Funktionen Clear () und isEmpty () werden unten gezeigt.

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

Ausgabe:

Die ArrayList: (Rot, Grün, Blau, Weiß)
Ist ArrayList nach clear () leer? :wahr

Ausgabe - isEmpty ArrayList

ArrayList indexOf

Prototyp: int indexOf (Objekt o)
Parameter: o => Element, dessen Index in der ArrayList zu finden ist.
Rückgabewert: int => Index des ersten Auftretens des Elements in der Liste.
Beschreibung: Gibt den Index des ersten Vorkommens des Elements o in der Liste zurück. -1, wenn das Element o nicht in der Liste vorhanden ist.

ArrayList lastIndexOf

Prototyp: int lastIndexOf (Objekt o)
Parameter: o => Das zu suchende Element.
Rückgabewert: int => Index des letzten Vorkommens des Elements in der Liste.
Beschreibung: Gibt den Index des letzten Vorkommens des angegebenen Elements o in der Liste zurück. -1, wenn das Element nicht in der Liste vorhanden ist.

Das folgende Java-Programm demonstriert die Methoden indexOf und lastIndexOf von 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)); } }

Ausgabe:

Die ArrayList: (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

Ausgabe

ArrayList toArray

Prototyp: Objekt () toArray ()
Parameter: NULL
Rückgabewert: Objekt () => ein Array. Dieses zurückgegebene Array enthält alle Elemente der Liste in einer geeigneten Reihenfolge.
Beschreibung: Konvertiert die angegebene Liste in ein Array.

Prototyp: T () toArray (T () a)

Parameter: a => Array zum Speichern von Elementen der Liste. Wenn die Größe des Arrays für Listenelemente nicht ausreicht, wird ein anderes Array mit demselben Typ wie a zum Speichern von Elementen erstellt.

Rückgabewert: T () => Array, das alle Listenelemente enthält.
Beschreibung: Konvertiert die angegebene Liste in ein Array des Typs a.

Ausnahmen: ArrayStoreException => Wenn der Laufzeittyp des Arrays und der Laufzeittyp oder der Supertyp seiner Elemente nicht übereinstimmen.
NullPointerException => Das angegebene Array ist null

Das folgende Java-Programm demonstriert die toArray-Methode von 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)); } }

Ausgabe:

ArrayList: (10, 20, 30, 40, 50)
Array aus ArrayList: (10, 20, 30, 40, 50)

Ausgabe - toArray ArrayList

ArrayList-Klon

Prototyp: Objektklon ()
Parameter: NULL
Rückgabewert: Object => Klon der ArrayList-Instanz.
Beschreibung: Erstellt eine flache Kopie der angegebenen 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); } }

Ausgabe:

Original ArrayList: (Apfel, Orange, Melone, Trauben)
Geklonte ArrayList: (Apfel, Orange, Melone, Trauben)
Original ArrayList nach dem Hinzufügen und Entfernen: (Apfel, Melone, Trauben, Mango)
Geklonte ArrayList nach Änderung des Originals: (Apfel, Orange, Melone, Trauben)

Ausgabe - Arraylist-Klon

An der obigen Programmausgabe können Sie erkennen, dass die geklonte ArrayList eine flache Kopie der ursprünglichen ArrayList ist. Dies bedeutet, dass diese Änderungen beim Ändern der ursprünglichen ArrayList nicht in der geklonten ArrayList berücksichtigt werden, da sie nicht die Speicherorte der einzelnen Elemente gemeinsam nutzen.

Um eine tiefe Kopie von Array zu erstellen, muss die ursprüngliche ArrayList durchlaufen und jedes seiner Elemente in die Ziel-ArrayList kopiert werden.

ArrayList-Unterliste

Prototyp: List subList (int fromIndex, int toIndex)
Parameter: fromIndex => Startindex des Bereichs (einschließlich)
toIndex => Endindex des Bereichs (exklusiv)
Rückgabewert: Liste => Unterliste der Liste im angegebenen Bereich.

Beschreibung: Gibt eine Unterliste zwischen einem bestimmten Bereich von Index bis Index für die angegebene Liste zurück. Beachten Sie, dass diese Unterliste oder die Ansicht der Liste im angegebenen Bereich alle von der Liste unterstützten Vorgänge unterstützt. Es wird keine Ansicht zurückgegeben, wenn fromIndex = toIndex.

Ausnahmen: IndexOutOfBoundsException => Wird ausgelöst, wenn toIndex außerhalb des Bereichs liegt.
IllegalArgumentException => Wenn fromIndex> toIndex, d. H. Indizes sind nicht in Ordnung.

Sehen wir uns ein Beispiel für die subList-Methode an.

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

Ausgabe:

Ursprüngliche ArrayList: (5, 10, 15, 20, 25, 30, 35, 40, 45, 50)
Unterliste der angegebenen ArrayList: (15, 20, 25, 30)

Ausgabe

ArrayList keepAll

Prototyp: boolean keepAll (Sammlung c)
Parameter: c => Sammlung mit Elementen, die in der Liste beibehalten werden sollen.
Rückgabewert: true => Wenn sich die ArrayList infolge der Operation geändert hat.
Beschreibung: Behält die Elemente in der Liste bei, die mit den Elementen in der angegebenen Sammlung übereinstimmen. C.

Ausnahmen: ClassCastException => Der Auflistungstyp und der Listentyp stimmen nicht überein
NullPointerException => Die angegebene Sammlung ist null oder die Liste enthält null Elemente und die Sammlung erlaubt keine Nullen.

Das folgende Programm demonstriert die RetainAll-Methode.

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

Ausgabe:

Original ArrayList: (Rot, Grün, Blau, Gelb)
Sammlungselemente, die in der Liste beibehalten werden sollen: (Rot, Blau)
ArrayList nach dem Aufruf von keepAll: (Rot, Blau)

Ausgabe - RetailAll-Methode

ArrayList Iterator

Prototyp: Iterator iterator ()
Parameter: NULL
Rückgabewert: Iterator => Iterator über die Listenelemente.
Beschreibung: Gibt einen Iterator zurück, der die Listenelemente in der richtigen Reihenfolge durchläuft.

ArrayList listIterator

ICH.

Prototyp: ListIterator listIterator ()
Parameter: NULL
Rückgabewert: ListIterator => listIterator über den Listenelementen.
Beschreibung: Gibt den Listeniterator zurück, um die Elemente der angegebenen Liste zu durchlaufen.

II.

Prototyp: ListIterator listIterator (int index)
Parameter: index => Position des ersten Elements im listIterator.
Rückgabewert: ListIterator => ListIterator für die Liste aus dem angegebenen Index.
Beschreibung: Gibt den Listeniterator ab der angegebenen Position 'Index' zurück, um die Elemente der angegebenen Liste zu durchlaufen.
Ausnahmen: IndexOutOfBoundsException => Der angegebene Index liegt außerhalb des Bereichs.

Beispiel für die Methoden iterator () und 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() + ' '); } } }

Ausgabe:

Listen Sie den Inhalt mit der Iterator () -Methode auf:
Mumbai Pune Hyderabad Delhi
Listen Sie den Inhalt mit der Methode listIterator () auf:
Mumbai Pune Hyderabad Delhi

Ausgabe - Iterator- und listIterator-Methoden

Hinzufügen eines Arrays zur ArrayList in Java

ArrayList unterstützt die addAll-Methode zum Hinzufügen von Elementen der Auflistung zur ArrayList. In ähnlicher Weise können Sie der ArrayList auch ein Array hinzufügen. Dies erfolgt mit der Methode 'Collections.addAll'.

Beispiel für das Hinzufügen eines Arrays zur 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); } }

Ausgabe:

Erste ArrayList: (Delhi, Mumbai, Chennai, Kolkata)
ArrayList nach dem Hinzufügen eines Arrays: (Delhi, Mumbai, Chennai, Kolkata, Cochin, Goa)

Ausgabe - Array zur Arrayliste in Java hinzufügen

ArrayList in Java sortieren

ArrayList verwendet die Collections.sort-Methode, um seine Elemente zu sortieren. Standardmäßig wird die Liste nach der Collections.sort-Methode in aufsteigender Reihenfolge sortiert. Wenn die ArrayList in absteigender Reihenfolge sortiert werden soll, müssen Sie der Sortiermethode einen Parameter 'Collections.reverseOrder ()' geben.

Im Folgenden finden Sie ein Programm zum Sortieren einer ArrayList in aufsteigender und absteigender Reihenfolge:

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

Ausgabe:

Anfängliche ArrayList: (Rot, Grün, Blau, Gelb)
ArrayList in aufsteigender Reihenfolge sortiert:
(Blau, Grün, Rot, Gelb)
ArrayList in absteigender Reihenfolge sortiert:
(Gelb, Rot, Grün, Blau)

Ausgabe - Sortieren Sie die Arrayliste in Java

Wenn die ArrayList andere Klassenobjekte als Elemente enthält, können Sie die Schnittstellen Comparable und Comparator verwenden. Weitere Details zu Schnittstellen finden Sie in unseren späteren Tutorials.

ArrayList in Java umkehren

Sie können eine ArrayList auch in Java umkehren. Eine Methode, um dies zu tun, besteht darin, die herkömmliche Methode zum Durchlaufen der ArrayList in umgekehrter Reihenfolge zu verwenden und jedes Element in eine neue ArrayList zu kopieren.

Eine andere Methode ist die Verwendung der Collections-Klasse, die die 'Reverse' -Methode bereitstellt, mit der eine Sammlung umgekehrt wird.

Das Programm zum Umkehren einer ArrayList mithilfe der Collections-Klasse ist unten angegeben.

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

Ausgabe:

Anfängliche ArrayList: (1, 3, 5, 7, 9)
Umgekehrte ArrayList: (9, 7, 5, 3, 1)

Ausgabe - Reverse und ArrayList

Entfernen von Duplikaten aus einer ArrayList in Java

Um Duplikate aus der ArrayList zu entfernen, können Sie erneut auf die herkömmliche Methode zurückgreifen, einen Iterator zu verwenden, um die ArrayList zu durchlaufen und nur das erste Vorkommen des Elements in einer anderen ArrayList zu speichern.

Eine weitere Methode ist die Verwendung der Methode 'unique ()' der Klasse stream (). Diese Methode gibt einen Strom unterschiedlicher Elemente zurück. Die Funktion stream () ist in Java ab Java 8 verfügbar.

Die Implementierung der Methode stream () .distinct () ist unten angegeben:

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

Ausgabe:

Ursprüngliche ArrayList: (1, 2, 3, 1, 3, 5, 5, 6, 6, 7, 7, 8, 8)
ArrayList ohne Duplikate: (1, 2, 3, 5, 6, 7, 8)

Ausgabe - Entfernen Sie Duplikate aus ArrayList

Eine ArrayList in Java mischen (randomisieren)

Sie können die ArrayList-Elemente auch mischen oder zufällig sortieren. Dies erfolgt mit der Methode Collections.shuffle (). Mit dieser Methode können Sie entweder die ArrayList mit Standardeinstellungen mischen oder eine random () - Funktion bereitstellen, die die Elemente gemäß dem angegebenen Zufallswert randomisiert.

Ein Java-Programm, um dies zu erreichen, ist unten angegeben.

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

Ausgabe:

Ursprüngliche ArrayList: (Ost, West, Nord, Süd, Südwest, Nordost) Gemischte ArrayList ohne Zufall (): (Nord, Nordost, Ost, Südwest, Süd, West)
Gemischte ArrayList mit Random (): (Süd, Ost, Nord, Nordost, West, Südwest)
Gemischte ArrayList mit Random (2): (Südwesten, Süden, Osten, Nordosten, Norden, Westen)

Ausgabe - Mischen (Randomisieren) einer ArrayList

Häufig gestellte Fragen

F # 1) Was ist der Unterschied zwischen homogenen und heterogenen Containern in Java?

Antworten: Homogene Container enthalten Objekte / Elemente des gleichen Typs. Andererseits haben heterogene Behälter Objekte gemischten Typs.

Q # 2) Ist ArrayList in Java heterogen?

Antworten: Ja. Da ArrayLists Generika unterstützen und daher das Löschen eingeben, kann es gemischte Objekte enthalten, wenn es als generische ArrayList implementiert wird.

Q # 3) Kann ArrayList int speichern?

Antworten: Nein. ArrayLists können keine Werte wie int speichern, aber Integer-Objekte, da ArrayLists nur Objekte enthalten können. Um primitive Typen zu speichern, sollten Sie daher Wrapper-Klassen wie Integer für Ints verwenden.

Q # 4) Was passiert, wenn ArrayList voll ist?

Antworten: Jedes ArrayList-Objekt verfügt über eine Funktion namens 'Kapazität'. Wenn die ArrayList voll ist, erhöht sich die Kapazität der ArrayList automatisch, um Platz für mehr Elemente zu schaffen.

Testdatengenerierung beim Testen von Software

Q # 5) Was ist der Unterschied zwischen der removeAll- und der RetainAll-Methode in ArrayList?

Antworten: Die ArrayList-Methoden 'removeAll' und 'RetainAll' zeigen ein entgegengesetztes Verhalten.

Während die removeAll-Methode alle Elemente aus der Liste entfernt, die mit der als Argument an diese Methode übergebenen Auflistung übereinstimmen, behält keepAll andererseits alle Elemente in der Liste bei, die mit denen der Auflistung übereinstimmen.

Fazit

In diesem Tutorial haben wir ArrayList-Methoden anhand eines Beispiels ausführlich erläutert.

Wir haben auch einige Sonderfälle in Betracht gezogen, z. B. das Hinzufügen von Elementen am Anfang der Liste. Wir haben auch andere Operationen in ArrayList wie das Sortieren, Umkehren und Mischen von ArrayList besprochen.

In unserem nächsten Tutorial werden wir einige der ArrayList-Konvertierungen diskutieren.

=> Sehen Sie sich hier die einfache Java-Schulungsreihe an.

ArrayList-Methoden in Java - Tutorial mit Beispielprogrammen