java list methods sort list
In diesem Tutorial werden verschiedene Java-Listenmethoden wie Sortierliste, Liste enthält, Liste hinzufügen, Liste entfernen, Listengröße, AddAll, RemoveAll, Reverse List und mehr erläutert:
Wir haben die Listenoberfläche im Allgemeinen bereits in unserem vorherigen Tutorial besprochen. Die Listenschnittstelle verfügt über verschiedene Methoden, mit denen der Inhalt der Liste bearbeitet werden kann. Mit diesen Methoden können Sie Elemente in die Liste einfügen / löschen, sortieren und suchen.
In diesem Tutorial werden alle Methoden erläutert, die von der Listenschnittstelle bereitgestellt werden.
=> Hier finden Sie A-Z der Java-Schulungsanleitungen.
Um die Liste zu durchlaufen, verwendet die Listenschnittstelle den Listeniterator. Dieser Listeniterator erstreckt sich über die Iteratorschnittstelle. In unserem nächsten Tutorial werden wir mehr über den Listeniterator erfahren.
Was du lernen wirst:
- Listenmethoden in Java
- Entfernen von Duplikaten aus einer Liste in Java
- Häufig gestellte Fragen
- Fazit
- Literatur-Empfehlungen
Listenmethoden in Java
Die folgende Tabelle zeigt verschiedene Funktionen, die von der Listenschnittstelle in Java bereitgestellt werden.
| Listenmethode | Methodenprototyp | Beschreibung |
|---|---|---|
| enthält | Boolescher Wert enthält (Objekt o) | Überprüft, ob das angegebene Element in der Liste vorhanden ist, und gibt true zurück, falls vorhanden |
| Größe | int size () | Gibt die Größe der Liste zurück, d. H. Die Anzahl der Elemente in der Liste oder die Länge der Liste. |
| klar | void clear () | Löscht die Liste, indem alle Elemente in der Liste entfernt werden |
| hinzufügen | void add (int index, Objektelement) | Fügt das angegebene Element der Liste am angegebenen Index hinzu |
| boolean add (Objekt o) | Fügt das angegebene Element am Ende der Liste hinzu | |
| füge alle Hinzu | boolean addAll (Sammlung c) | Hängt die gesamte angegebene Sammlung an das Ende der Liste an |
| boolean addAll (int index, Sammlung c) | Fügt die angegebene Sammlung (alle Elemente) am angegebenen Index in die Liste ein | |
| enthältAll | Boolescher Wert enthältAll (Sammlung c) | Überprüft, ob die angegebene Sammlung (alle Elemente) Teil der Liste ist. Gibt true von yes zurück. |
| gleich | Boolescher Wert gleich (Objekt o) | Vergleicht das angegebene Objekt auf Gleichheit mit Elementen der Liste |
| Erhalten | Objekt get (int index) | Gibt das Element in der durch den Index angegebenen Liste zurück |
| Hash-Code | int hashCode () | Gibt den Hashcode-Wert der Liste zurück. |
| indexOf` | int indexOf (Objekt o) | Findet das erste Vorkommen des Eingabeelements und gibt seinen Index zurück |
| ist leer | boolean isEmpty () | Überprüft, ob die Liste leer ist |
| lastIndexOf | int lastIndexOf (Objekt o) | Findet das letzte Vorkommen des Eingabeelements in der Liste und gibt seinen Index zurück |
| entfernen | Objekt entfernen (int index) | Entfernt das Element am angegebenen Index |
| boolean remove (Objekt o) | Entfernt das Element beim ersten Auftreten in der Liste | |
| alles entfernen | boolean removeAll (Sammlung c) | Entfernt alle in der angegebenen Sammlung enthaltenen Elemente aus der Liste |
| behaltenAlle | boolean keepAll (Sammlung c) | Gegenüber von removeAll. Behält das in der Eingabesammlung in der Liste angegebene Element bei. |
| einstellen | Objektmenge (int index, Objektelement) | Ändert das Element am angegebenen Index, indem es auf den angegebenen Wert gesetzt wird |
| Unterliste | List subList (int fromIndex, int toIndex) | Gibt die Unterliste der Elemente zwischen fromIndex (einschließlich) und toIndex (exklusiv) zurück. |
| Sortieren | Leersortierung (Komparator c) | Sortiert das Listenelement gemäß dem angegebenen Komparator, um eine geordnete Liste zu erhalten |
| toArray | Objekt () toArray () | Gibt die Array-Darstellung der Liste zurück |
| Object () toArray (Objekt () a) | Gibt die Array-Darstellung zurück, deren Laufzeittyp mit einem angegebenen Array-Argument identisch ist | |
| Iterator | Iterator iterator () | Gibt einen Iterator für die Liste zurück |
| listIterator | ListIterator listIterator () | Gibt einen ListIterator für die Liste zurück |
| ListIterator listIterator (int index) | Gibt einen ListIterator zurück, der am angegebenen Index in der Liste beginnt |
Als nächstes werden wir diese Funktionen zusammen mit ihren Beispielen diskutieren.
Größe
Prototyp: int size ()
Parameter: NULL
Rückgabewert: int => Anzahl der Elemente in der Liste oder mit anderen Worten die Länge der Liste.
Beschreibung: Die Größe () gibt die Anzahl der Elemente oder die Größe der Liste zurück. Es kann auch in einfachen Worten als Länge bezeichnet werden.
klar
Prototyp: void clear ()
Parameter: NULL
Rückgabewert: Kein Rückgabewert
Beschreibung: Löscht die Liste, indem alle Elemente der Liste entfernt werden. Löst 'UnSupportedException' aus, wenn der Vorgang von der Liste nicht unterstützt wird.
Das folgende Beispiel zeigt die Methode size () und clear ().
import java.util.*; public class Main { public static void main(String() args) { List strList = new ArrayList(); // Creating a list //add items to list strList.add('Java'); strList.add('C++'); //print the size of list System.out.println('Size of list:' + strList.size()); //add more items to list strList.add('Ruby'); strList.add('Python'); strList.add('C#'); //print the size of list again System.out.println('Size of list after adding more elements:' + strList.size()); //clear method strList.clear(); System.out.println('List after calling clear() method:' + strList); } } Ausgabe:
hinzufügen
Prototyp: void add (int index, Objektelement)
Parameter: Index - eine Position, an der das Element hinzugefügt werden soll.
Element - das hinzuzufügende Element
Rückgabewert: Leere
Beschreibung: Fügt das angegebene Element der Liste am angegebenen Index hinzu. Die nachfolgenden Elemente werden nach rechts verschoben.
Folgende Ausnahmen werden ausgelöst:
IndexOutOfBoundsException: Der Listenindex liegt außerhalb des Bereichs
UnsupportedOperationException: Das Hinzufügen wird von der Liste nicht unterstützt.
ClassCastException: Das Element kann aufgrund der Klasse der angegebenen Elemente nicht zur Liste hinzugefügt werden.
IllegalArgumentException: Das angegebene Element oder ein Aspekt ist nicht korrekt.
Hinzufügen
Prototyp: boolean add (Objekt o)
Parameter: o => Element, das der Liste hinzugefügt werden soll
Rückgabewert: true => Element erfolgreich hinzugefügt
False => Hinzufügen nicht erfolgreich
Beschreibung: Diese Methode fügt das angegebene Element am Ende der Liste hinzu.
Diese Operation kann die folgenden Ausnahmen auslösen.
UnsupportedOperationException: Hinzufügen einer Operation, die von dieser Liste nicht unterstützt wird.
ClassCastException: Das angegebene Element kann aufgrund seiner Klasse nicht hinzugefügt werden
IllegalArgumentException: Das angegebene Element oder ein Aspekt ist nicht korrekt.
füge alle Hinzu
Prototyp: boolean addAll (Sammlung c)
Parameter: c => Sammlung, deren Elemente zur Liste hinzugefügt werden sollen
Rückgabewert: true => Methodenausführung erfolgreich
Beschreibung: Die addAll-Methode übernimmt alle Elemente aus Sammlung c und hängt sie an das Ende der Liste an, indem die festgelegte Reihenfolge beibehalten wird.
Diese Methode zeigt ein nicht angegebenes Verhalten, wenn die Sammlung während des Vorgangs geändert wird.
Die Methode löst die folgenden Ausnahmen aus:
UnsupportedOperationException: Hinzufügen einer Operation, die von dieser Liste nicht unterstützt wird.
ClassCastException: Das angegebene Element kann aufgrund seiner Klasse nicht hinzugefügt werden.
IllegalArgumentException: Das angegebene Element oder ein Aspekt ist nicht korrekt.
füge alle Hinzu
Prototyp: boolean addAll (int index, Sammlung c)
Parameter: index => Position, an der die Sammlung eingefügt werden soll.
C => Sammlung, die in die Liste eingefügt werden soll.
Rückgabewert: true => Wenn Sammlungselemente erfolgreich zur Liste hinzugefügt wurden.
Beschreibung: Die addAll-Methode fügt alle Elemente in der angegebenen Auflistung in die Liste am angegebenen Index ein. Die nachfolgenden Elemente werden dann nach rechts verschoben. Wie bei der vorherigen Überladung von addAll ist das Verhalten nicht angegeben, wenn die Sammlung während des Vorgangs geändert wird.
Die von dieser Methode ausgelösten Ausnahmen sind:
UnsupportedOperationException: Hinzufügen einer Operation, die von dieser Liste nicht unterstützt wird.
ClassCastException: Das angegebene Element kann aufgrund seiner Klasse nicht hinzugefügt werden.
IllegalArgumentException: Das angegebene Element oder ein Aspekt ist nicht korrekt.
IndexOutOfBoundsException: Index außerhalb des Bereichs.
Das folgende Programm zeigt die Demonstration der Methoden add und addAll der Liste.
import java.util.*; public class Main { public static void main(String() args) { List strList = new ArrayList(); // Creating a list strList.add('Java'); strList.add('C++'); //print the list System.out.println('List after adding two elements:' + strList); List llist = new ArrayList(); // Create another list llist.add('Ruby'); llist.add('Python'); llist.add('C#'); // addAll method - add llist to strList strList.addAll(llist); System.out.println('List after addAll:'+ strList); } } Ausgabe:
enthält
Prototyp: Boolescher Wert enthält (Objekt o)
Parameter: o => Element, das in der Liste gesucht werden soll.
Rückgabewert: true => Wenn die Liste das angegebene Element enthält.
Beschreibung: Die Methode 'enthält' prüft, ob das angegebene Element in der Liste vorhanden ist, und gibt einen Booleschen Wert true zurück, wenn das Element vorhanden ist. Andernfalls wird false zurückgegeben.
enthältAll
Prototyp: Boolescher Wert enthältAll (Sammlung c)
Parameter: c => Sammlung, die in der Liste durchsucht werden soll.
Rückgabewert: true => Wenn alle Elemente in der angegebenen Sammlung in der Liste vorhanden sind.
Beschreibung: Die Methode 'includesAll' prüft, ob alle in der angegebenen Auflistung vorhandenen Elemente in der Liste vorhanden sind. Wenn vorhanden, wird ein wahrer Wert und andernfalls ein falscher Wert zurückgegeben.
Das folgende Java-Programm demonstriert die Verwendung der Methoden 'enthält' und 'enthält alle' der Liste.
import java.util.*; public class Main { public static void main(String() args) { //define list of strings List list = new ArrayList(); //initialize list to strings list.add('Java'); list.add('Xml'); list.add('Python'); list.add('Ruby'); list.add('JavaScript'); //contains method demo if(list.contains('C')==true) System.out.println('Given list contains string 'C''); else if(list.contains('Java')==true) System.out.println('Given list contains string 'Java' but not string 'C''); //containsAll method demo List myList = new ArrayList(); myList.add('Ruby'); myList.add('Python'); if(list.containsAll(myList)==true) System.out.println('List contains strings 'Ruby' and 'Python''); } }Ausgabe:
Die angegebene Liste enthält die Zeichenfolge 'Java', jedoch nicht die Zeichenfolge 'C'.
Die Liste enthält die Zeichenfolgen 'Ruby' und 'Python'.
gleich
Prototyp: Boolescher Wert gleich (Objekt o)
Parameter: o => Das Objekt, das auf Gleichheit geprüft werden soll.
Rückgabewert: true => Wenn das angegebene Objekt der Liste entspricht.
Beschreibung: Diese Methode wird verwendet, um das angegebene Objekt mit der Liste der Gleichheit zu vergleichen. Wenn das angegebene Objekt eine Liste ist, gibt die Methode true zurück. Beide Listen gelten genau dann als gleich, wenn sie gleich groß sind und die entsprechenden Elemente in den beiden Listen gleich und in derselben Reihenfolge sind.
Eine Demonstration der Gleichheitsmethode ist unten angegeben:
import java.util.LinkedList; import java.util.List; public class Main { public static void main(String() args) { //define lists List first_list= new LinkedList(); List second_list = new LinkedList(); List third_list = new LinkedList(); //initialize lists with values for (int i=0;i<11;i++){ first_list.add(i); second_list.add(i); third_list.add(i*i); } //print each list System.out.println('First list: ' + first_list); System.out.println('Second list: ' + second_list); System.out.println('Third list: ' + third_list); //use equals method to check equality with each list to other if (first_list.equals(second_list) == true) System.out.println('
first_list and second_list are equal.
'); else System.out.println('first_list and second_list are not equal.
'); if(first_list.equals(third_list)) System.out.println('first_list and third_list are equal.
'); else System.out.println('first_list and third_list are not equal.
'); if(second_list.equals(third_list)) System.out.println('second_list and third_list are equal.
'); else System.out.println('second_list and third_list are not equal.
'); } } Ausgabe:
Erhalten
Prototyp: Objekt get (int index)
Parameter: index => Position, an der das Element zurückgegeben werden soll.
Rückgabewert: Objekt => Element an der angegebenen Position.
Beschreibung: Die Methode get () gibt das Element an der angegebenen Position zurück.
Diese Methode löst 'indexOutOfBoundsException' aus, wenn der angegebene Index außerhalb des Bereichs der Liste liegt.
einstellen
Prototyp: Objektmenge (int index, Objektelement)
Parameter: index => Position, an der das neue Element gesetzt werden soll.
element => Neues Element, das an der durch den Index angegebenen Position platziert werden soll.
Rückgabewert: Objekt => Element, das ersetzt wurde
Beschreibung: Die Methode set () ersetzt das Element am angegebenen Index durch einen anderen vom Element angegebenen Wert.
Die Methode kann die folgenden Ausnahmen auslösen:
UnsupportedOperationException: Die Set-Operation wird von der Liste nicht unterstützt.
ClassCastException: Die Operation kann aufgrund der Klasse des Elements nicht ausgeführt werden
IllegalArgumentException: Argument oder ein Aspekt davon ist illegal
IndexOutOfBoundsException: Index außerhalb des Bereichs.
Das folgende Programm zeigt ein Beispiel für die Methoden get () und set ().
import java.util.*; public class Main { public static void main(String() args) { //define list List listA = new ArrayList(); listA.add('Java'); listA.add('C++'); listA.add('Python'); //access list elements using index with get () method System.out.println('Element at index 0:' + listA.get(0)); System.out.println('Element at index 1:' + listA.get(1)); System.out.println('Element at index 2:' + listA.get(2)); //set element at index 1 to Ruby listA.set(1,'Ruby'); System.out.println('Element at index 1 changed to :' + listA.get(1) ); } } Ausgabe:
Hash-Code
Prototyp: int hashCode ()
Parameter: NULL
Rückgabewert: int => hashCode der Liste
Beschreibung: Die Methode 'hashCode ()' gibt den HashCode der Liste zurück, der ein ganzzahliger Wert ist.
Beispiel:
import java.util.*; public class Main { public static void main(String() args) { // Initializing a list of type Linkedlist List mylist = new LinkedList(); mylist.add(1); mylist.add(3); mylist.add(5); mylist.add(7); //print the list System.out.println('The list:' + mylist); //use hashCode() method to find hashcode of list int hash = mylist.hashCode(); System.out.println('Hashcode for list:' + hash); } } Ausgabe:
ist leer
Prototyp: boolean isEmpty ()
Parameter: NULL
Rückgabewert: true => Liste ist leer
Beschreibung: Die Methode 'isEmpty ()' prüft, ob die Liste leer ist. Mit der IsEmpty-Methode wird überprüft, ob die Liste Elemente enthält, bevor Sie mit der Verarbeitung dieser Elemente beginnen.
Index von
Prototyp: int indexOf (Objekt o)
Parameter: o => Element, nach dem in der Liste gesucht werden soll
Rückgabewert: int => der Index oder die Position des ersten Auftretens des angegebenen Elements in der Liste. Gibt -1 zurück, wenn das Element nicht vorhanden ist.
Beschreibung: Die Methode 'indexOf ()' gibt den Index des ersten Auftretens des angegebenen Elements o in der Liste zurück. Wenn das Element nicht gefunden wird, gibt es -1 zurück.
lastIndexOf
Prototyp: int lastIndexOf (Objekt o)
Parameter: o => Objekt, dessen Index durchsucht werden soll
Rückgabewert: int => Index des letzten Vorkommens des angegebenen Elements in der Liste, andernfalls -1.
Beschreibung: Die Methode 'lastIndexOf ()' gibt den Index des letzten Vorkommens des Elements o in der Liste zurück. Wird das Element nicht gefunden, gibt die Methode -1 zurück.
Das folgende Java-Programm demonstriert die Verwendung der Methoden indexOf und lastIndexOf der Liste.
import java.util.*; public class Main { public static void main(String() args) { // define an integer array List intList = new ArrayList(5); //add elements to the list intList.add(10); intList.add(20); intList.add(30); intList.add(10); intList.add(20); //print the list System.out.println('The list of integers:' + intList); // Use indexOf() and lastIndexOf() methods of list to find first and last index System.out.println('first index of 20:' + intList.indexOf(20)); System.out.println('last index of 10:' + intList.lastIndexOf(10)); } } Ausgabe:
entfernen
Prototyp: Objekt entfernen (int index)
Parameter: index => Index oder Position in der Liste, an der das Element entfernt werden soll
Rückgabewert: Objekt => Element entfernt
Beschreibung: Die Methode 'remove ()' entfernt das Element an der angegebenen Position aus der Liste. Nach dem Löschen werden die Elemente neben dem gelöschten Element nach links verschoben.
Diese Methode kann die folgenden Ausnahmen auslösen:
UnsupportedOperationException: Entfernen wird von der Liste nicht unterstützt.
IndexOutOfBoundsException: Der angegebene Index liegt außerhalb des Bereichs
entfernen
Prototyp: boolean remove (Objekt o)
Parameter: o => Element, das aus der Liste entfernt werden soll
Rückgabewert: true => Element wurde erfolgreich entfernt.
Beschreibung: Diese überladene Version der remove () -Methode entfernt das erste Auftreten eines bestimmten Elements o aus der Liste. Wenn das angegebene Element nicht in der Liste vorhanden ist, bleibt es unverändert.
Diese Methode kann die folgende Ausnahme auslösen:
UnsupportedOperationException: Entfernen wird von der Liste nicht unterstützt.
alles entfernen
Prototyp: boolean removeAll (Sammlung c)
Parameter: c => Eine Sammlung, die Elemente enthält, die aus der Liste entfernt werden.
Rückgabewert: true => Wenn der Methodenaufruf erfolgreich ist und alle in der Auflistung c angegebenen Elemente aus der Liste entfernt werden.
Beschreibung: Mit der Methode 'removeAll ()' werden alle Elemente aus der Liste entfernt, die in der als Argument übergebenen Sammlung c angegeben sind.
Diese Methode kann die folgende Ausnahme auslösen:
UnsupportedOperationException: removeAll wird von der Liste nicht unterstützt.
Lassen Sie uns ein Beispiel für die Methoden remove und removeAll sehen.
import java.util.*; public class Main { public static void main(String() args) { // Creating a list List oddList = new ArrayList(); //add elements to the list oddList.add(1); oddList.add(3); oddList.add(5); oddList.add(7); oddList.add(9); oddList.add(11); //print the original list System.out.println('Original List:' + oddList); // Removes element from index 1 oddList.remove(1); System.out.println('Oddlist after removing element at index 1:' + oddList); //removeAll method List c1 = new ArrayList(); c1.add(1); c1.add(5); c1.add(11); oddList.removeAll(c1); System.out.println('Oddlist after removing elements {1,5,11}}:' + oddList); } } Ausgabe:
behaltenAlle
Prototyp: boolean keepAll (Sammlung c)
Parameter: c => Sammlung, die Elemente enthält, die in der Liste beibehalten werden sollen.
Rückgabewert: true => Wenn der Methodenaufruf die Liste geändert hat.
Beschreibung: Diese Methode entfernt alle Elemente aus der Liste mit Ausnahme derjenigen, die in der Sammlung vorhanden sind. C. Mit anderen Worten, diese Methode behält alle Elemente in der Liste bei, die in Sammlung c vorhanden sind, und entfernt die anderen Elemente.
Diese Methode kann die folgende Ausnahme auslösen:
UnsupportedOperationException: keepAll wird von der Liste nicht unterstützt.
import java.util.*; public class Main { public static void main(String() args) { // Creating a list List oddList = new ArrayList(); //add elements to the list oddList.add(1); oddList.add(3); oddList.add(5); oddList.add(7); oddList.add(9); oddList.add(11); //print the original list System.out.println('Original List:' + oddList); //retainAll method List c1 = new ArrayList(); c1.add(1); c1.add(5); c1.add(11); oddList.retainAll(c1); System.out.println('Oddlist after call to retainAll (1,5,11):' + oddList); } } Ausgabe:
Unterliste
Prototyp: List subList (int fromIndex, int toIndex)
Parameter: fromIndex => Unterer Index der Liste (einschließlich)
toIndex => Höherer Index der Liste (exklusiv)
Rückgabewert: Liste => Eine Unterliste der angegebenen Liste
Beschreibung: Die Methode sublist () gibt die Teilansicht der Liste zurück, die auch als Unterliste von 'fromIndex' bis 'toIndex' bezeichnet wird. Die zurückgegebene Unterliste ist nur eine Ansicht der übergeordneten Liste, und daher werden alle an beiden Listen vorgenommenen Änderungen überall angezeigt.
In ähnlicher Weise funktionieren alle Operationen der Liste auch in einer Unterliste.
Die Methode kann die folgende Ausnahme auslösen:
IndexOutOfBoundsException: Unzulässiger toIndex-Wert.
Ein Beispielprogramm für die Unterlistenmethode ist unten angegeben.
import java.util.*; public class Main { public static void main(String() args) { // define a string list List strList = new ArrayList(5); //add elements to the list strList.add('Java'); strList.add('Tutorials'); strList.add('Collection'); strList.add('Framework'); strList.add('Series'); //print the original list System.out.println('The original list=>strList: ' + strList); //define another list List subList = new ArrayList(); // take a sublist of elements from 2 to 4 from strList subList = strList.subList(2, 4); //print the sublist System.out.println('The sublist of strList:' + subList); } } Ausgabe:
Sortierliste
Prototyp: Leersortierung (Komparator c)
kostenlose PC-Optimierungstools Windows 10
Parameter: c => Komparator, nach dem die Liste sortiert ist.
Rückgabewert: NULL
Beschreibung: Mit der Methode 'sort ()' wird die Liste sortiert. Die Methode verwendet den angegebenen Komparator, um die Liste zu sortieren.
Sehen wir uns ein Beispiel für die Sortiermethode an . Wir haben es mit der Collections.sort-Methode verglichen, mit der die Elemente in einer natürlichen Reihenfolge sortiert werden. Die Ausgabe des Programms ist eine geordnete Liste.
import java.util.Collections; import java.util.ArrayList; import java.util.List; import java.util.Random; public class Main { public static void main(String() args) { //define list List intArray = new ArrayList(); Random random = new Random(); //populate the list with random numbers <20 for (int i = 0; i {return (o2-o1);}); //comparator to sort in reverse System.out.println('Reverse List sorted using comparator:
'+intArray); } }Ausgabe:
toArray
Prototyp: Objekt () toArray ()
Parameter: NULL
Rückgabewert: Objekt () => Array-Darstellung der Liste
Beschreibung: Die Methode toArray () gibt die Array-Darstellung der Liste in der richtigen Reihenfolge zurück.
toArray
Prototyp: Object () toArray (Objekt () a)
Parameter: a => Array-Typ, der beim Konvertieren der Liste in ein Array mit Listenelementtypen abgeglichen werden soll.
Rückgabewert: Objekt () => Array-Darstellung der Liste.
Beschreibung: Diese Überladung der Methode toArray () gibt das Array zurück, das Elemente in der Liste enthält, die denselben Laufzeittyp wie das Array a haben.
Diese Methode kann die folgende Ausnahme auslösen:
ArrayStoreException: Der Laufzeittyp jedes Elements in der Liste ist kein Untertyp des Laufzeittyps jedes Elements in dieser Liste.
Das Folgende ist ein Beispiel für die Implementierung der toArray-Methode.
import java.util.*; public class Main { public static void main(String() args) { // create list ArrayList colorsList = new ArrayList(7); // add colors to colorsList colorsList.add('Violet'); colorsList.add('Indigo'); colorsList.add('Blue'); colorsList.add('Green'); colorsList.add('Yellow'); colorsList.add('Orange'); colorsList.add('Red'); System.out.println('Size of the colorsList: ' + colorsList.size()); // Print the colors in the list System.out.println('Contents of colorsList:'); for (String value : colorsList){ System.out.print(value + ' '); } // Create an array from the list using toArray method String colorsArray() = new String(colorsList.size()); colorsArray = colorsList.toArray(colorsArray); // Display the contents of the array System.out.println('
Printing elements of colorsArray:' + Arrays.toString(colorsArray)); } }Ausgabe:
Iterator
Prototyp: Iterator iterator ()
Parameter: NULL
Rückgabewert: Iterator => Iterator zum Durchlaufen der Elemente der Liste
Beschreibung: Diese Methode gibt den Iterator zurück, der über die Elemente in der Liste iteriert.
Java-Programm zur Demonstration mit Iterator.
import java.util.*; public class Main { public static void main(String() args) { // create list ArrayList colorsList = new ArrayList(7); // add colors to colorsList colorsList.add('Violet'); colorsList.add('Indigo'); colorsList.add('Blue'); colorsList.add('Green'); colorsList.add('Yellow'); colorsList.add('Orange'); colorsList.add('Red'); System.out.println('ColorList using iterator:'); //define iterator for colorsList Iterator iterator = colorsList.iterator(); //iterate through colorsList using iterator and print each item while(iterator.hasNext()){ System.out.print(iterator.next() + ' '); } } } Ausgabe:
listIterator
Prototyp: ListIterator listIterator ()
Parameter: NULL
Rückgabewert: ListIterator => Listiterator der Elemente in der Liste.
Beschreibung: Die Methode listIterator () gibt das ListIterator-Objekt der Elemente in der Liste zurück. Dieser Iterator beginnt am Anfang der Liste, d. H. Index 0.
listIterator
Prototyp: ListIterator listIterator (int index)
Parameter: index => Position, an der listIterator startet.
Rückgabewert: ListIterator => ListIterator-Objekt am angegebenen Index in der Liste.
Beschreibung: Die Überladung der Methode listIterator () gibt einen listIterator zurück, der an der angegebenen Position in der Liste beginnt. Der angegebene Index gibt an, dass dies das erste Element ist, das beim ersten Aufruf der nextElement () -Methode von ListIterator zurückgegeben wird.
Die Methode kann IndexOutOfBoundsException für den ungültigen Wert des Index auslösen.
Das folgende Beispiel zeigt die Verwendung von listIterator.
import java.util.*; public class Main { public static void main(String() args) { //define list & add items to list List nameList = new LinkedList(); nameList.add('Java'); nameList.add('C++'); nameList.add('Python'); // get listIterator for the list ListIterator namesIterator = nameList.listIterator(); // Traverse list using listiterator and print each item System.out.println('Contents of list using listIterator:'); while(namesIterator.hasNext()){ System.out.print(namesIterator.next() + ' '); } } } Ausgabe:
Wir werden ListIterator später ausführlich besprechen.
Lassen Sie uns nun einige der verschiedenen Vorgänge diskutieren, die für Listen ausgeführt werden können, deren Methoden jedoch nicht in der Listenoberfläche bereitgestellt werden.
Liste in Java kopieren
Zum Kopieren von Elementen einer Liste in eine andere Liste müssen Sie die vom Collections-Framework bereitgestellte copy () -Methode verwenden.
Die Methode Collections.copy () kopiert alle Elemente der als zweites Argument bereitgestellten Liste in die als erstes Argument bereitgestellte Liste. Beachten Sie, dass die Liste, in die der Inhalt einer anderen Liste kopiert wird, groß genug sein sollte, um die kopierten Elemente aufzunehmen.
Wenn die Liste nicht groß genug ist, löst die Kopiermethode 'indexOutOfBoundsEexception' aus.
Das folgende Programm kopiert den Inhalt einer Liste in eine andere.
import java.util.*; public class Main { public static void main(String() args) { //create first ArrayList object List aList_1 = new ArrayList(); //Add elements to first ArrayList aList_1.add('R'); aList_1.add('G'); aList_1.add('B'); //print the List System.out.println('The first list:' + aList_1); //create second ArrayList object List aList_2 = new ArrayList(); //Add elements to second Arraylist aList_2.add('Red'); aList_2.add('Green'); aList_2.add('Blue'); aList_2.add('Yellow'); aList_2.add('Brown'); System.out.println('The second list: ' + aList_2); //use Collections.copy() method to copy elements of first list to second list. Collections.copy(aList_2,aList_1); //print the resultant second Arraylist System.out.println('
The second list after copying first list to second list: ' + aList_2); } } Ausgabe:
Entfernen von Duplikaten aus einer Liste in Java
Eine gegebene Liste kann sich wiederholende Elemente oder Duplikate enthalten oder nicht. Wenn die Liste, mit der Sie arbeiten, doppelte Elemente enthält und Sie alle unterschiedlichen Elemente in der Liste haben möchten, gibt es zwei Methoden, um doppelte Elemente aus der in Java unterstützten Liste zu entfernen.
Verwenden von Java 8 Stream
Die erste Methode zum Entfernen von Duplikaten aus der Liste ist die Verwendung der vom Java 8-Stream bereitgestellten Methode different (). Hier ruft die Liste mit Duplikaten die Methode stream () .distinct auf, und der Rückgabewert wird in eine neue Liste konvertiert, die nur die verschiedenen Elemente enthält.
Das folgende Programm demonstriert die Verwendung der Methode different ().
import java.util.*; import java.util.stream.Collectors; class Main { public static void main(String() args) { // original list List intlist = new ArrayList( Arrays.asList(1, 1, 1, 2, 2, 3, 3, 3, 4, 5, 5,6,5,3,4)); // Print the list System.out.println('Original ArrayList: ' + intlist); // using distinct() method of Java 8 stream remove duplicates from original List //and generate a new list without duplicates List distinct_list = intlist.stream().distinct() .collect(Collectors.toList()); // Print the new list System.out.println('ArrayList after removing duplicates: ' + distinct_list); } } Ausgabe:
Verwenden des Iterator-Ansatzes
Das Entfernen von Duplikaten aus der Liste mithilfe des Iterators ist ein langwieriger und primitiver Ansatz. Bei diesem Ansatz müssen Sie die Liste durchlaufen und das erste Vorkommen jedes Elements in eine neue Liste einfügen. Jedes nachfolgende Element wird überprüft, ob es sich um ein Duplikat handelt.
Das folgende Programm erreicht dies.
import java.util.*; public class Main { public static void main(String args()) { // create original list ArrayList aList = new ArrayList( Arrays.asList(1, 1, 1, 2, 2, 3, 3, 3, 4, 5, 5, 6, 5, 3, 4)); // Print the original list System.out.println('Original List: '+ aList); // Create a new list ArrayList new_List = new ArrayList(); // Traverse through the original list to remove duplicates for (Integer element : aList) { // check if element is present in new_List, else add it if (!new_List.contains(element)) { new_List.add(element); } } // Print the new list without duplicates System.out.println('List after removing duplicates: '+ new_List); } } Ausgabe:
Häufig gestellte Fragen
F # 1) Was ist die get-Methode in der Liste in Java?
Antworten: Die Get-Methode der Liste wird verwendet, um ein bestimmtes Element in der Liste basierend auf dem Index abzurufen. Sie übergeben den erforderlichen Index an die get-Methode, und die get-Methode gibt den Elementwert an diesem Index zurück.
F # 2) Was ist die toArray-Methode in Java?
Antworten: Die Methode toArray () wird verwendet, um die Array-Darstellung der Liste abzurufen.
F # 3) Wie sortieren Sie eine Liste in Java?
Antworten: In Java kann eine Liste mit der Sortiermethode der Liste sortiert werden. Sie können Ihre eigenen Sortierkriterien über die Komparatorschnittstelle übergeben, die als Parameter an die Sortiermethode übergeben wird.
Sie können auch Sammlungen verwenden. Sortiermethode zum Sortieren der Liste. Diese Methode sortiert die Liste nach natürlicher Reihenfolge.
Q # 4) Was ist Arrays.asList () in Java?
Antworten: Die Methode 'asList' des Arrays gibt die Liste der Elemente zurück, die von einem Array unterstützt werden.
Fazit
In diesem Tutorial haben wir alle Methoden kennengelernt, die eine Liste bietet. Die Java-Liste enthält verschiedene Methoden, mit denen Sie Listen bearbeiten und verarbeiten können, einschließlich Suchen, Sortieren usw. Wir haben jede Methode hier mit geeigneten Programmierbeispielen erläutert.
In unserem nächsten Tutorial werden wir den ListIterator ausführlich besprechen.
=> Entdecken Sie hier die Simple Java Training Series.
Literatur-Empfehlungen
- Java-Liste - Erstellen, Initialisieren und Verwenden einer Liste in Java
- Verdeckte Liste in Array und andere Sammlungen in Java
- Python Advanced List Tutorial (Listensortierung, Umkehren, Indexieren, Kopieren, Verbinden, Summen)
- Python-Liste - Elemente erstellen, darauf zugreifen, in Scheiben schneiden, hinzufügen oder löschen
- Java-Threads mit Methoden und Lebenszyklus
- Entfernen / Löschen eines Elements aus einem Array in Java
- Java String Tutorial | Java-String-Methoden mit Beispielen
- Standard-Router-IP-Adressliste für gängige WLAN-Router-Marken