Java List

Das Java Collection Framework enthält sehr nützliche Interfaces und Klassen, die sie für die Arbeit mit Datenstrukturen implementieren. Man kann sagen, dass dies eines der wichtigsten JDK Frameworks ist. Das List-Interface ist sehr beliebt, da es angesichts der zahlreichen Arten von Listen in der Programmierung unentbehrlich ist. In diesem Artikel werden wir dieses Interface, die Methoden und Implementierungen von Java List behandeln.

Java List – Interface

Das Wichtigste an einer Liste ist, dass es sich um eine geordnete Collection handelt. Du kannst es auch eine Folge nennen. In Java sind Listen homogen, d. h. die Elemente der Liste sind vom gleichen Datentyp. Da das List-Interface in Java von Collection erbt, erbt es auch alle ihre Operationen. Außerdem sind die folgenden Operationen in List möglich:

• Zugriff nach Position. Jedes Element hat einen Index und kann anhand seiner Position in der Liste manipuliert werden. Das heißt, du kannst Elemente hinzufügen, entfernen und ändern.
• Suche. Du kannst ein Element in einer Liste anhand seines Inhalts finden und seinen Index zurückgeben.
• Iteration. Die sequentielle Natur von List ermöglicht die Verwendung von Iterationsmethoden (listIterator).
• Bereichsansicht. Die Sublist-Methode führt beliebige Bereichsoperationen mit der Liste durch.

Java List – Methoden

Die oben genannten Operationen sind in den Methoden des List-Interfaces in Java enthalten. Hier sind einige davon:

List – Implementierung

Da List ein Interface ist, müssen Programme eine konkrete Implementierung davon erstellen. Du kannst zwischen den folgenden List-Implementierungen in der Java Collections API wählen:

• java.util.ArrayList
• java.util.LinkedList
• java.util.Vector
• java.util.Stack

Die beliebteste Implementierung des List-Interfaces heißt ArrayList. Wesentlich seltener, aber immer noch in realen Projekten zu sehen, ist die Verwendung von LinkedList, aber Vector und Stack sind schon lange technisch veraltet, so dass man sie wahrscheinlich nur in Projekten mit altem Legacy-Code findet.

List – Interface-Deklaration

Du kannst eine Liste in einem Java-Programm auf eine der folgenden Arten deklarieren:

List<String> myList = new ArrayList();
List myList1 = new ArrayList();
List myList3 = new ArrayList<String>();
ArrayList arrayList = new ArrayList();

Am besten ist es, eine neue Liste über ein Interface zu deklarieren. Genauso kannst du andere Implementierungen von List deklarieren. Der kürzeste Weg:

Vector myVector = new Vector;
LinkedList linkedList = new LinkedList();
Stack stack = new Stack();

Bei einer solchen Deklaration wird der Datentyp der Elemente solcher Listen bei der Initialisierung der Liste festgelegt, d. h. wenn Elemente hinzugefügt werden.

List myList = new ArrayList<String>();
Vector myVector = new Vector();
LinkedList linkedList = new LinkedList();
Stack stack = new Stack();
stack.add("Paul");
linkedList.add(1);
myVector.add(1.2f);
myList.add('a');

Jetzt können nur noch Strings zu unserem Stack hinzugefügt werden, Integer zu linkedList, Floats zu myVector und myList ist eine Liste von Zeichen.

Wie ArrayList funktioniert

Wenn du bereits mit normalen Arrays vertraut bist, bist du automatisch auch mit ArrayList einigermaßen vertraut. In Wirklichkeit ist ArrayList ein dynamisches Array und darin ein gewöhnliches Array. Dieses Array dient als Datenspeicher. ArrayList speichert nur Referenztypen, also beliebige Objekte, einschließlich Klassen von Dritten, Strings, Ausgabeströme und andere Collections. Wrapper-Klassen werden verwendet, um primitive Datentypen in einer ArrayList zu speichern. Wenn wir eine Liste erstellen, können wir sofort ihre Größe festlegen, aber in den meisten Fällen tun wir das nicht. Standardmäßig ist die Größe von ArrayList = 10. Wie sieht das Hinzufügen eines neuen Elements zu einer ArrayList aus? Zuerst wird geprüft, ob im internen Array genug Platz ist und ob ein weiteres Element hineinpasst. Wenn ein Leerzeichen vorhanden ist, wird das neue Element am Ende der Liste hinzugefügt, also in der Zelle, die auf das letzte Element folgt. Sein Index ist arraylist.size(). Wenn wir unsere Liste gerade erstellt haben und sie leer ist, bedeutet das, dass arrayList.size() = 0 ist. Entsprechend wird der Zelle mit dem Index 0 ein neues Element hinzugefügt. Wenn sich herausstellt, dass der Platz nicht ausreicht, wird innerhalb der ArrayList ein neues Array mit der Größe (Größe von altesArray * 1,5) + 1 erstellt. Nach dem gleichen Prinzip erfolgt ein Einfügen in der Mitte der Liste, aber gleichzeitig werden alle Elemente, die auf das eingefügte Element folgen, nach rechts verschoben. Wenn wir also 5 Elemente im Array haben und ein Element in die Zelle Nummer 2 (also die dritte) einfügen müssen, dann bleiben die Arrayelemente 0 und 1 an ihrem Platz, ein neues Element erscheint in Zelle 2 und sein Vorgänger geht in die dritte Zelle und so weiter.

Java List – Beispiel (ArrayList-Realisierung)

import java.util.*;

public class ArrayListExample2 {
   public static void main(String[] args) {
       List<String> myFriendsList = new ArrayList();
       //we created list of some objects 
       System.out.println( "the size of myList before init = " + myFriendsList.size());
       myFriendsList.add("Alex");
       myFriendsList.add("Tanya");
       myFriendsList.add("Veloxy");
       myFriendsList.add("Alex");
       myFriendsList.add("Andrew");
       System.out.println(myFriendsList);
       System.out.println( "the size of myList after init = " + myFriendsList.size());

       myFriendsList.add("Ihor");
       System.out.println(myFriendsList);
       System.out.println("the size of my list = " +  myFriendsList.size());


       //here the program will print out the first appearance of "Alex" element
       System.out.println(myFriendsList.indexOf("Alex"));
       //program will print out the first appearance of "Alex" element starting from the element 0

       myFriendsList.remove(3);
       System.out.println(myFriendsList.get(3));
       System.out.println("after removing one of Alex's there is only one Alex: " + myFriendsList);
       System.out.println(myFriendsList.get(1));



       myFriendsList.clear();
       System.out.println("the size of the vector after clear method = " +  myFriendsList.size());

   }
}

Hier ist die Ausgabe dieses Programms:

Wie LinkedList funktioniert

In einer LinkedList sind die Elemente tatsächlich Glieder einer Kette. Jedes Element hat zusätzlich zu den Daten, die es speichert, einen Link zum vorherigen und zum nächsten Element. Diese Links ermöglichen es dir, von einem Element zum anderen zu navigieren. Der Iterator unterstützt den Durchlauf in beide Richtungen. Implementiert Methoden zum Abrufen, Entfernen und Einfügen am Anfang, in der Mitte und am Ende einer Liste. Ermöglicht es dir, beliebige Elemente hinzuzufügen, einschließlich Null. LinkedList implementiert zwei Interfaces – nicht nur List, sondern auch Deque. Damit kannst du eine bidirektionale Warteschlange aus beliebigen Elementen erstellen, sogar aus Null. Jedes Objekt, das in der verknüpften Liste steht, ist ein Knoten. Jeder Knoten enthält ein Element, einen Link zum vorherigen und nächsten Knoten. Tatsächlich besteht die verkettete Liste aus einer Folge von Knoten, von denen jeder ein Objekt des Typs speichern soll, der bei seiner Erstellung definiert wurde.

Codebeispiel

import java.util.*;
public class LinkedListTest {

       public static void main(String args[]){

           List myLinkedList= new LinkedList<Integer>();
           myLinkedList.add(1);
           myLinkedList.add(2);
           myLinkedList.add(4);
           System.out.println("three added elements: " + myLinkedList);
           myLinkedList.add(5);
           myLinkedList.remove(1);
           System.out.println(myLinkedList);
           myLinkedList.size(); //3
           
           //add new element at the specified position:
           myLinkedList.add(2,7);
           System.out.println(myLinkedList);
                }
       }

Die Ausgabe ist hier:

Vector – Codebeispiel

Vector ist ebenfalls eine dynamische Array-Realisierung und ähnelt ArrayList, ist aber synchronisiert und hat einige Legacy-Methoden, die das Collection Framework nicht enthält. Hier ist ein einfaches Beispiel für die Verwendung dieser Klasse.

import java.util.Vector;

public class VectorExample1 {

   public static void main(String[] args) {
       Vector vector = new Vector();
       System.out.println("the size of the empty vector = " +  vector.size());
       vector.add("Alex");
       vector.add("Tanya");
       vector.add("Andrew");
       System.out.println(vector);
       vector.add("Alex");
       vector.add("Ihor");
       System.out.println(vector);
       System.out.println("the size of the vector = " +  vector.size());
       System.out.println("the first element of the vector = " + vector.firstElement());

       //here the program will print out the first appearance of "Johnny" element
       System.out.println(vector.indexOf("Andrew"));
       //program will print out the first appearance of "Johnny" element starting from the element 1
       System.out.println(vector.indexOf("Alex", 1));
       System.out.println(vector);
       vector.clear();
       System.out.println("the size of the vector after clear method = " +  vector.size());

   }
}

Die Ausgabe ist:

Java Stack-Klasse – Codebeispiel

import java.util.Stack;

public class StackTest {
   public static void main(String[] args) {
       Stack stack = new Stack();
       System.out.println(stack.isEmpty());
       stack.add("Paul");
       stack.add("Johnny");
       stack.add("Alex");
       System.out.println(stack.isEmpty());
       stack.push("Andrew");
       System.out.println(stack);
       stack.pop();
       System.out.println(stack);
   }
}

Stack hat nicht nur die Methoden add() und remove(), sondern auch push und pop, die für solche Datenstrukturen klassisch sind. Der Stack gehorcht der Regel „first in, last out“ – das ist eine Art Anti-Warteschlange. Deshalb wird bei der Pop-Operation das Element, das zuletzt auf dem Stack platziert wurde, herausgenommen. Hier ist die Ausgabe unseres Beispiels: