Java-Liste – Liste in Java

Tutorials

Die Java-Liste ist eine geordnete Sammlung. Die Java-Liste ist eine Schnittstelle, die die Schnittstelle Collection erweitert. Die Java-Liste bietet Kontrolle über die Position, an der ein Element eingefügt werden kann. Sie können auf Elemente über ihren Index zugreifen und auch Elemente in der Liste suchen.

Java-Liste

Einige wichtige Punkte zur Java-Liste sind;

  • Die Java-Listenschnittstelle ist ein Mitglied des Java Collections Frameworks.
  • Die Liste erlaubt das Hinzufügen von Duplikatelementen.
  • Die Liste erlaubt das Vorhandensein von ’null‘-Elementen.
  • Die Listen-Schnittstelle hat viele Standardmethoden in Java 8, wie z.B. replaceAll, sort und spliterator.
  • Die Listenindizes beginnen bei 0, genau wie bei Arrays.
  • Die Liste unterstützt Generics und wir sollten sie immer verwenden. Die Verwendung von Generics mit Liste vermeidet ClassCastException zur Laufzeit.

Klassendiagramm der Java-Liste

Die Java List-Schnittstelle erweitert die Collection-Schnittstelle. Die Collection-Schnittstelle erweitert die Iterable-Schnittstelle. Einige der am häufigsten verwendeten Implementierungsklassen von List sind ArrayList, LinkedList, Vector, Stack und CopyOnWriteArrayList. AbstractList bietet eine skelettartige Implementierung der List-Schnittstelle, um den Aufwand bei der Implementierung von List zu reduzieren.

Java-Listenmethoden

Einige der nützlichen Java-Listenmethoden sind:

  1. int size(): um die Anzahl der Elemente in der Liste zu erhalten.
  2. boolean isEmpty(): um zu überprüfen, ob die Liste leer ist oder nicht.
  3. boolean contains(Object o): Gibt true zurück, wenn diese Liste das angegebene Element enthält.
  4. Iterator<E> iterator(): Gibt einen Iterator über die Elemente in dieser Liste in der richtigen Reihenfolge zurück.
  5. Object[] toArray(): Gibt ein Array zurück, das alle Elemente in dieser Liste in der richtigen Reihenfolge enthält.
  6. boolean add(E e): Hängt das angegebene Element an das Ende dieser Liste an.
  7. boolean remove(Object o): Entfernt das erste Auftreten des angegebenen Elements aus dieser Liste.
  8. boolean retainAll(Collection): Behält nur die Elemente in dieser Liste bei, die in der angegebenen Sammlung enthalten sind.
  9. void clear(): Entfernt alle Elemente aus der Liste.
  10. E get(int index): Returns the element at the specified position in the list.
  11. E set(int index, E element): Replaces the element at the specified position in the list with the specified element.
  12. ListIterator listIterator(): Gibt einen Listen-Iterator über die Elemente in der Liste zurück.
  13. List subList(int fromIndex, int toIndex): Gibt eine Ansicht des Ausschnitts dieser Liste zwischen dem angegebenen fromIndex (inklusive) und toIndex (exklusive) zurück. Die zurückgegebene Liste wird von dieser Liste unterstützt, sodass nicht-strukturelle Änderungen in der zurückgegebenen Liste in dieser Liste reflektiert werden und umgekehrt.

Einige der Standardmethoden, die in Java 8 zu List hinzugefügt wurden, sind;

  1. default void replaceAll(UnaryOperator operator): Ersetzt jedes Element dieser Liste durch das Ergebnis der Anwendung des Operators auf dieses Element.
  2. default void sort(Comparator c): Sortiert diese Liste gemäß der Ordnung, die durch den angegebenen Comparator induziert wird.
  3. default Spliterator spliterator(): Erstellt einen Spliterator über die Elemente in dieser Liste.

Java Array to List

Wir können die Arrays-Klasse verwenden, um die Ansicht des Arrays als Liste zu erhalten. Wir werden jedoch keine strukturellen Änderungen an der Liste vornehmen können, es wird eine java.lang.UnsupportedOperationException ausgelöst. Daher ist der beste Weg, eine Schleife zu verwenden, um die Liste zu erstellen, indem man über das Array iteriert. Unten finden Sie ein einfaches Beispiel, das zeigt, wie man ein Java-Array ordnungsgemäß in eine Liste konvertiert.

package com.journaldev.examples;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class ArrayToList {

	public static void main(String[] args) {
		
		String[] vowels = {"a","e","i","o","u"};
		
		List vowelsList = Arrays.asList(vowels);
		System.out.println(vowelsList);
		
		/**
		 * List is backed by array, we can't do structural modification
		 * Both of the below statements will throw java.lang.UnsupportedOperationException
		 */
		//vowelsList.remove("e");
		//vowelsList.clear();
				
		// Verwendung einer Schleife zum Kopieren von Elementen aus dem Array in die Liste, sicher für Modifikationen der Liste
		List myList = new ArrayList<>();
		for(String s : vowels){
			myList.add(s);
		}
		System.out.println(myList);
		myList.clear();
	}

}

Wählen Sie eine der obigen Methoden basierend auf den Anforderungen Ihres Projekts aus.

Java-Liste in Array

A simple example showing the correct way to convert a list to array.

package com.journaldev.examples;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class ListToArray {

	public static void main(String[] args) {

		List letters = new ArrayList();

		// Beispiel hinzufügen
		letters.add("A");
		letters.add("B");
		letters.add("C");
		
		// Liste in Array konvertieren
		String[] strArray = new String[letters.size()];
		strArray = letters.toArray(strArray);
		System.out.println(Arrays.toString(strArray)); //will print "[A, B, C]"
	}

}

Java-Liste sortieren

Es gibt zwei Möglichkeiten, eine Liste zu sortieren. Wir können die Collections-Klasse für die natürliche Sortierung verwenden oder wir können die sort()-Methode der Liste verwenden und unseren eigenen Comparator für die Sortierung verwenden. Unten finden Sie ein einfaches Beispiel für die Sortierung einer Java-Liste.

package com.journaldev.examples;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;

public class ListSortExample {

	public static void main(String[] args) {
		
		List ints = new ArrayList<>();
		Random random = new Random();
		for (int i = 0; i < 10; i++) ints.add(random.nextInt(1000));
		
		// Natürliche Sortierung unter Verwendung der Collections-Klasse
		Collections.sort(ints);
		System.out.println("Natural Sorting: "+ints);
		
		// Meine benutzerdefinierte Sortierung, umgekehrte Reihenfolge
		ints.sort((o1,o2) -> {return (o2-o1);});
		System.out.println("Reverse Sorting: "+ints);
	}
}

A sample output is given below. Since I am using Random for generating list elements, it will be different every time.

Natural Sorting: [119, 273, 388, 450, 519, 672, 687, 801, 812, 939]
Reverse Sorting: [939, 812, 801, 687, 672, 519, 450, 388, 273, 119]

Java-Liste – Übliche Operationen

Die häufigsten Operationen, die auf einer Java-Liste ausgeführt werden, sind Hinzufügen, Entfernen, Festlegen, Leeren, Größe usw. Im Folgenden finden Sie ein einfaches Java-Liste Beispiel, das die Verwendung gängiger Methoden zeigt.

package com.journaldev.examples;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class ListExample {

	public static void main(String args[]) {
		List vowels= new ArrayList();
		
		//Hinzufügen Beispiel
		vowels.add("A");
		vowels.add("I");
		
		//Wir fügen E zwischen A und I ein
		vowels.add(1,"E");
		System.out.println(vowels);
		
		List list = new ArrayList();
		list.add("O");list.add("U");
		
		//Anhängen von Listenelementen an Buchstaben
		vowels.addAll(list);
		System.out.println(vowels);
		
		//Leeren Beispiel, um die Liste zu leeren
		list.clear();
		
		//Größe Beispiel
		System.out.println("letters list size = "+vowels.size());
		
		//Setzen Beispiel
		vowels.set(2, "E");
		System.out.println(vowels);
		
		//subList Beispiel
		vowels.clear();vowels.add("E"); vowels.add("E");vowels.add("I"); vowels.add("O");
		list = vowels.subList(0, 2);
		System.out.println("letters = "+vowels+", list = "+list);
		vowels.set(0, "A");
		System.out.println("letters = "+vowels+", list = "+list);
		list.add("U");
		System.out.println("letters = "+vowels+", list = "+list);
		
		
	}

}

Die Ausgabe des obigen Java-Listenbeispiels ist;

[A, E, I]
[A, E, I, O, U]
letters list size = 5
[A, E, E, O, U]
letters = [E, E, I, O], list = [E, E]
letters = [A, E, I, O], list = [A, E]
letters = [A, E, U, I, O], list = [A, E, U]

Java-Listeniterator

Hier ist ein einfaches Beispiel, das zeigt, wie man in Java über eine Liste iteriert.

package com.journaldev.examples;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class ListIteratorExample {

	public static void main(String[] args) {

		List list = new ArrayList<>();
		for(int i=0; i<5; i++) list.add(i);
		
		Iterator iterator = list.iterator();
		
		//Einfache Iteration
		while(iterator.hasNext()){
			int i = (int) iterator.next();
			System.out.print(i + ", ");
		}
		System.out.println("\n"+list);
		
		//Änderung der Liste unter Verwendung des Iterators
		iterator = list.iterator();
		while(iterator.hasNext()){
			int x = (int) iterator.next();
			if(x%2 ==0) iterator.remove();
		}
		System.out.println(list);
		
		//Ändern der Listenstruktur während der Iteration
		iterator = list.iterator();
		while(iterator.hasNext()){
			int x = (int) iterator.next(); //ConcurrentModificationException here
			if(x==1) list.add(10);
		}
	}

}

Die Ausgabe des obigen Java-Listeniteratorprogramms ist;

0, 1, 2, 3, 4, 
[0, 1, 2, 3, 4]
[1, 3]
Exception in thread "main" java.util.ConcurrentModificationException
	at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:901)
	at java.util.ArrayList$Itr.next(ArrayList.java:851)
	at com.journaldev.examples.ListIteratorExample.main(ListIteratorExample.java:34)

Das ist alles für einen schnellen Überblick über Listen in Java. Ich hoffe, diese Java-Listenbeispiele helfen Ihnen beim Einstieg in die Programmierung von Listenkollektionen.

Source:
https://www.digitalocean.com/community/tutorials/java-list