Listen

In der Programmierung stoßen wir oft auf Situationen, in denen wir viele Werte verarbeiten müssen. Die bisher einzige Methode, die wir verwendet haben, bestand darin, für jeden Wert eine eigene Variable zu definieren. Dies ist jedoch unpraktisch.

String wort1;
String wort2;
String wort3;
// ...
String wort10;

Die oben dargestellte Lösung ist in der Praxis nutzlos – stellen Sie sich eine Situation vor, in der tausende von Wörtern gespeichert werden müssen.

Programmiersprachen bieten Werkzeuge, um eine große Anzahl von Werten zu speichern. Wir werden uns als Nächstes ein möglicherweise am häufigsten verwendetes Werkzeug in Java ansehen, die ArrayList, die zum Speichern vieler Werte des gleichen Typs verwendet wird.

ArrayList ist ein vorgefertigtes Werkzeug in Java, das beim Umgang mit Listen hilft. Es bietet verschiedene Methoden, darunter solche zum Hinzufügen von Werten zur Liste, zum Entfernen von Werten aus ihr und auch zum Abrufen eines Wertes von einer bestimmten Position in der Liste. Die konkrete Implementierung – das heißt, wie die Liste tatsächlich programmiert ist – wurde hinter den Methoden abstrahiert, sodass sich der Programmierer, der eine Liste verwendet, nicht um deren innere Funktionsweise kümmern muss.

Verwendung und Erstellung von Listen

Um eine ArrayList verwenden zu können, muss sie zunächst in das Programm importiert werden. Dies wird erreicht, indem der Befehl import java.util.ArrayList; am Anfang des Programms eingefügt wird. Im Folgenden finden Sie ein Beispielprogramm, in dem eine ArrayList in das Programm importiert wird.

// Importieren der Liste, um sie im Programm verfügbar zu machen
import java.util.ArrayList;

public class Programm {

    public static void main(String[] args) {
        // noch keine Implementierung
    }
}

Das Erstellen einer neuen Liste erfolgt mit dem Befehl ArrayList<Type> liste = new ArrayList<>(), wobei Type der Typ der Werte ist, die in der Liste gespeichert werden sollen (z.B. String). Im folgenden Beispiel erstellen wir eine Liste zum Speichern von Strings.

// Importieren der Liste, damit das Programm sie verwenden kann
import java.util.ArrayList;

public class Programm {

    public static void main(String[] args) {
        // Erstellen einer Liste
        ArrayList<String> liste = new ArrayList<>();

        // Die Liste wird noch nicht verwendet
    }
}

Der Typ der ArrayList-Variablen ist ArrayList. Wenn eine Listenvariable initialisiert wird, wird zusätzlich zum Variablentyp auch der Typ der Werte definiert, die in der Liste gespeichert werden sollen – alle in einer gegebenen Liste gespeicherten Variablen sind vom gleichen Typ. Der Typ einer ArrayList, die Strings speichert, ist also ArrayList<String>. Eine neue Liste wird mit dem Befehl new ArrayList<>(); erstellt.

Definition des Typs der Werte, die eine Liste enthalten kann

Bei der Definition des Typs der Werte, die eine Liste enthalten soll, muss der erste Buchstabe des Elementtyps großgeschrieben werden. Eine Liste, die int-Variablen enthält, muss in der Form ArrayList<Integer> definiert werden; eine Liste, die double-Variablen enthält, wird in der Form ArrayList<Double> definiert.

Der Grund dafür hängt mit der Implementierung der ArrayList zusammen. Variablen in Java können in zwei Kategorien unterteilt werden: Werttypen (primitive) und Referenztypen (reference type). Werttypen wie int oder double enthalten ihre tatsächlichen Werte. Referenztypen wie ArrayList enthalten hingegen einen Verweis auf den Speicherort, der die mit dieser Variablen verbundenen Werte enthält.

Werttypen können nur eine begrenzte Menge an Informationen speichern, während Referenzen nahezu unbegrenzt viele Informationen speichern können.

Im Folgenden finden Sie Beispiele für das Erstellen von Listen, die verschiedene Arten von Werten enthalten.

ArrayList<Integer> liste = new ArrayList<>();
liste.add(1);

ArrayList<Double> liste = new ArrayList<>();
liste.add(4.2);

ArrayList<Boolean> liste = new ArrayList<>();
liste.add(true);

ArrayList<String> liste = new ArrayList<>();
liste.add("String ist eine referenzartige Variable");

Sobald eine Liste erstellt wurde, geht ArrayList davon aus, dass alle darin enthaltenen Variablen Referenztypen sind. Java konvertiert automatisch eine int-Variable in Integer, wenn sie zur Liste hinzugefügt wird, und dasselbe geschieht, wenn eine Variable aus einer Liste abgerufen wird. Dasselbe gilt für double-Variablen, die in Double konvertiert werden. Dies bedeutet, dass, obwohl eine Liste so definiert ist, dass sie Integer-Typ-Variablen enthält, auch Variablen vom Typ int hinzugefügt werden können.

ArrayList<Integer> ganzeZahlen = new ArrayList<>();
int ganzeZahl = 1;
ganzeZahlen.add(ganzeZahl);

ArrayList<Double> kommazahlen = new ArrayList<>();
double d = 4.2;
kommazahlen.add(d);

Wir werden zu diesem Thema zurückkehren, da die Kategorisierung von Variablen in Wert- und Referenztypen unsere Programme auch auf andere Weise beeinflusst.

Hinzufügen zu einer Liste und Abrufen eines Wertes von einem bestimmten Ort

Im nächsten Beispiel wird das Hinzufügen einiger Strings zu einer ArrayList, die Strings enthält, demonstriert. Das Hinzufügen erfolgt mit der Listenmethode add, die den hinzuzufügenden Wert als Parameter übernimmt. Anschließend drucken wir den Wert an Position Null aus. Um einen Wert von einer bestimmten Position abzurufen, verwenden Sie die Listenmethode get, der der Ort des Abrufs als Parameter übergeben wird.

Um eine Listenmethode aufzurufen, schreiben Sie zuerst den Namen der die Liste beschreibenden Variablen, gefolgt von einem Punkt und dem Namen der Methode.

// Liste importieren, damit das Programm sie verwenden kann
import java.util.ArrayList;

public class WortlistenBeispiel {

    public static void main(String[] args) {
        // Erstellen Sie die Wortliste zum Speichern von Strings
        ArrayList<String> wortListe = new ArrayList<>();

        // Fügen Sie der Wortliste zwei Werte hinzu
        wortListe.add("Erste");
        wortListe.add("Zweite");

        // Abrufen des Werts von Position 0 der Wortliste und Ausdrucken
        System.out.println(wortListe.get(0));
    }
}

Wie zu sehen ist, ruft die Methode get den ersten Wert aus der Liste ab, wenn ihr der Parameter 0 übergeben wird. Dies liegt daran, dass Listenpositionen ab null gezählt werden. Der erste Wert wird durch wortListe.get(0) gefunden, der zweite durch wortListe.get(1) und so weiter.

import java.util.ArrayList;

public class WortlistenBeispiel {

    public static void main(String[] args) {
        ArrayList<String> wortListe = new ArrayList<>();

        wortListe.add("Erste");
        wortListe.add("Zweite");

        System.out.println(wortListe.get(1));
    }
}

Informationen aus einem "nicht existierenden" Bereich abrufen

Wenn Sie versuchen, Informationen aus einer Stelle abzurufen, die in der Liste nicht existiert, gibt das Programm einen IndexOutOfBoundsException-Fehler aus. Im folgenden Beispiel werden zwei Werte zu einer Liste hinzugefügt, danach wird versucht, den Wert an der Position zwei in der Liste auszugeben.

import java.util.ArrayList;

public class Example {

    public static void main(String[] args) {
        ArrayList<String> wordList = new ArrayList<>();

        wordList.add("First");
        wordList.add("Second");

        System.out.println(wordList.get(2));
    }
}

Da die Nummerierung (d. h. Indizierung) der Listenelemente bei Null beginnt, kann das Programm nichts an der Stelle zwei finden, und die Ausführung endet mit einem Fehler. Unten ist die Fehlermeldung beschrieben, die durch das Programm verursacht wird.

Die Fehlermeldung gibt Hinweise auf die interne Implementierung eines ArrayList-Objekts. Sie listet alle Methoden auf, die zum Fehler geführt haben. Zuerst wurde die main-Methode des Programms aufgerufen, woraufhin die get-Methode von ArrayList aufgerufen wurde. Anschließend rief die get-Methode von ArrayList die rangeCheck-Methode auf, in der der Fehler auftrat. Dies verdeutlicht auch die Bedeutung der richtigen Benennung von Methoden. Selbst wenn wir noch nie von der rangeCheck-Methode gehört hätten, könnten wir vernünftigerweise vermuten, dass sie überprüft, ob ein gesuchter Platz innerhalb eines bestimmten Bereichs liegt. Der Fehler trat wahrscheinlich auf, weil dies nicht der Fall war.

Durchlaufen einer Liste

Als Nächstes untersuchen wir Methoden, mit denen die Werte auf einer Liste durchlaufen werden können. Beginnen wir mit einem einfachen Beispiel, bei dem eine Liste mit vier Werten gedruckt wird.

ArrayList<String> teachers = new ArrayList<>();

teachers.add("Simon");
teachers.add("Samuel");
teachers.add("Ann");
teachers.add("Anna");

System.out.println(teachers.get(0));
System.out.println(teachers.get(1));
System.out.println(teachers.get(2));
System.out.println(teachers.get(3));

Das Beispiel ist offensichtlich umständlich. Was wäre, wenn mehr Werte auf der Liste stünden? Oder weniger? Was, wenn wir die Anzahl der Werte auf der Liste nicht wüssten?

Die Anzahl der Werte auf einer Liste wird durch die size-Methode der Liste angegeben, die die Anzahl der Elemente in der Liste zurückgibt. Diese Zahl ist eine Ganzzahl (int), und sie kann als Teil eines Ausdrucks verwendet oder in einer Ganzzahlvariablen für die spätere Verwendung gespeichert werden.

ArrayList<String> list = new ArrayList<>();
System.out.println("Anzahl der Werte in der Liste: " + list.size());

list.add("First");
System.out.println("Anzahl der Werte in der Liste: " + list.size());

int values = list.size();

list.add("Second");
System.out.println("Anzahl der Werte in der Liste: " + values);

Iteration über eine Liste Fortsetzung

Lassen Sie uns eine neue Version des Programms erstellen, die jeden Index manuell ausgibt. In dieser Zwischenversion verwenden wir die Variable index, um die Position zu verfolgen, die ausgegeben werden soll.

ArrayList<String> teachers = new ArrayList<>();

teachers.add("Simon");
teachers.add("Samuel");
teachers.add("Ann");
teachers.add("Anna");

int index = 0;

if (index < teachers.size()) {
    System.out.println(teachers.get(index)); // index = 0
    index = index + 1; // index = 1
}

if (index < teachers.size()) {
    System.out.println(teachers.get(index)); // index = 1
    index = index + 1; // index = 2
    }

if (index < teachers.size()) {
    System.out.println(teachers.get(index)); // index = 2
        index = index + 1; // index = 3
	}

if (index < teachers.size()) {
    System.out.println(teachers.get(index)); // index = 3
        index = index + 1; // index = 4
	}

if (index < teachers.size()) {
    // dies wird nicht ausgeführt, da index = 4 und teachers.size() = 4
        System.out.println(teachers.get(index));
	    index = index + 1;
	    }

Wir sehen, dass es im obigen Programm Wiederholungen gibt.

Wir können die if-Anweisungen in eine while-Schleife umwandeln, die so lange wiederholt wird, bis die Bedingung index < teachers.size() nicht mehr zutrifft (d.h. der Wert der Variablen index zu groß wird).

ArrayList<String> teachers = new ArrayList<>();

teachers.add("Simon");
teachers.add("Samuel");
teachers.add("Ann");
teachers.add("Anna");

int index = 0;
// Wiederholen, solange der Wert der Variablen `index`
// kleiner ist als die Größe der Lehrerliste
while (index < teachers.size()) {
    System.out.println(teachers.get(index));
    index = index + 1;

Jetzt funktioniert die Ausgabe unabhängig von der Anzahl der Elemente.

Die zuvor untersuchte for-Schleife, die verwendet wird, um über eine bekannte Anzahl von Elementen zu iterieren, ist hier äußerst nützlich. Wir können die obige Schleife in eine for-Schleife umwandeln, nach der das Programm so aussieht.

ArrayList<String> teachers = new ArrayList<>();

teachers.add("Simon");
teachers.add("Samuel");
teachers.add("Ann");
teachers.add("Anna");

for (int index = 0; index < teachers.size(); index++) {
    System.out.println(teachers.get(index));
}

Die Indexvariable der for-Schleife wird typischerweise als i bezeichnet:

for (int i = 0; i < teachers.size(); i++) {
    System.out.println(teachers.get(i));
}

Betrachten wir die Verwendung einer Liste zum Speichern von Ganzzahlen. Die Funktionalität ist größtenteils dieselbe wie im vorherigen Beispiel. Der größte Unterschied besteht in der Initialisierung der Liste – der Typ des zu speichernden Werts wird als Integer definiert, und der auszugebende Wert wird vor der Ausgabe in einer Variablen namens number gespeichert.

ArrayList<Integer> numbers = new ArrayList<>();

numbers.add(1);
numbers.add(2);
numbers.add(3);
numbers.add(4);

for (int i = 0; i < numbers.size(); i++) {
    int number = numbers.get(i);
    System.out.println(number);
    // alternativ: System.out.println(numbers.get(i));
}

Das Ausgeben der Zahlen in der Liste in umgekehrter Reihenfolge wäre ebenfalls einfach.

ArrayList<Integer> numbers = new ArrayList<>();

numbers.add(1);
numbers.add(2);
numbers.add(3);
numbers.add(4);

int index = numbers.size() - 1;
while (index >= 0) {
    int number = numbers.get(index);
    System.out.println(number);
    index = index - 1;
}

Die Ausführung des Programms wird unten visualisiert. Die Visualisierung zeigt jedoch nicht den internen Zustand der ArrayList (d.h. die darin enthaltenen Werte).

Versuchen Sie, das vorherige Beispiel mit der for-Schleife nachzubilden!

Iteration über eine Liste mit einer For-Each-Schleife

Wenn Sie den Index nicht verfolgen müssen, während Sie die Werte einer Liste durchlaufen, können Sie die for-each-Schleife verwenden. Sie unterscheidet sich von den vorherigen Schleifen dadurch, dass sie keine separate Bedingung für die Wiederholung oder das Inkrementieren hat.

ArrayList<String> teachers = new ArrayList<>();

teachers.add("Simon");
teachers.add("Samuel");
teachers.add("Ann");
teachers.add("Anna");

for (String teacher: teachers) {
    System.out.println(teacher);
}

In der Praxis verbirgt die oben beschriebene for-each-Schleife einige Teile der for-Schleife, die wir zuvor geübt haben. Die for-each-Schleife würde so aussehen, wenn sie als for-Schleife implementiert würde:

ArrayList<String> teachers = new ArrayList<>();

teachers.add("Simon");
teachers.add("Samuel");
teachers.add("Ann");
teachers.add("Anna");

for (int i = 0; i < teachers.size(); i++) {
    String teacher = teachers.get(i);
    // Inhalt der for-each-Schleife:
    System.out.println(teacher);
}

Beachten Sie die Syntax: for (TypeOfVariable nameOfVariable: nameOfList) Hierbei steht TypeOfVariable für den Typ der Listenelemente, und nameOfList ist die Variable, in der jeweils ein Wert der Liste gespeichert wird, während wir durch die Liste iterieren.

Entfernen von einer Liste und Überprüfen der Existenz eines Wertes

Die Methode remove der Liste entfernt den Wert, der sich an dem als Parameter angegebenen Index befindet. Der Parameter ist ein Integer.

ArrayList<String> list = new ArrayList<>();

list.add("First");
list.add("Second");
list.add("Third");

list.remove(1);

System.out.println("Index 0, also der erste Wert: " + list.get(0));
System.out.println("Index 1, also der zweite Wert: " + list.get(1));

Wenn der angegebene Parameter für remove denselben Typ wie die Werte in der Liste hat, aber kein Integer ist (Integer wird verwendet, um an einem bestimmten Index zu entfernen), kann er verwendet werden, um einen Wert direkt aus der Liste zu entfernen.

ArrayList<String> list = new ArrayList<>();

list.add("First");
list.add("Second");
list.add("Third");

list.remove("First");

System.out.println("Index 0, also der erste Wert: " + list.get(0));
System.out.println("Index 1, also der zweite Wert: " + list.get(1));

Wenn die Liste Integer enthält, können Sie keinen Zahlenwert entfernen, indem Sie der Methode remove einen Parameter vom Typ int übergeben. Dies würde die Zahl am angegebenen Index entfernen, anstatt ein Element in der Liste, das denselben Wert wie der Parameter hat. Um einen Wert vom Typ Integer zu entfernen, können Sie den Parameter in den Typ Integer konvertieren. Dies wird durch die Methode valueOf der Klasse Integer erreicht.

ArrayList<Integer> list = new ArrayList<>();

list.add(15);
list.add(18);
list.add(21);
list.add(24);

list.remove(2);
list.remove(Integer.valueOf(15));

System.out.println("Index 0, also der erste Wert: " + list.get(0));
System.out.println("Index 1, also der zweite Wert: " + list.get(1));

Die Listenmethode contains kann verwendet werden, um das Vorhandensein eines Wertes in der Liste zu überprüfen. Die Methode erhält den zu suchenden Wert als Parameter und gibt einen Wert des Typs boolean (true oder false) zurück, der angibt, ob dieser Wert in der Liste gespeichert ist oder nicht.

ArrayList<String> list = new ArrayList<>();

list.add("First");
list.add("Second");
list.add("Third");

System.out.println("Wurde der erste Wert gefunden? " + list.contains("First"));

boolean found = list.contains("Second");
if (found) {
    System.out.println("Second wurde gefunden");
}

// oder einfacher
if (list.contains("Second")) {
    System.out.println("Second kann immer noch gefunden werden");
}

Liste als Methodenparameter

Wie andere Variablen kann auch eine Liste als Parameter einer Methode verwendet werden. Wenn die Methode so definiert ist, dass sie eine Liste als Parameter akzeptiert, wird der Typ des Parameters als der Typ der Liste und der Typ der in dieser Liste enthaltenen Werte definiert. Unten druckt die Methode print die Werte in der Liste nacheinander aus.

public static void print(ArrayList<String> list) {
    for (String value: list) {
        System.out.println(value);
    }
}

Wir sind bereits mit Methoden vertraut, und es funktioniert hier genauso. Im folgenden Beispiel verwenden wir die oben implementierte print-Methode.

ArrayList<String> strings = new ArrayList<>();

strings.add("First");
strings.add("Second");
strings.add("Third");

print(strings);

Der gewählte Parametername in der Methodendefinition hängt nicht von der Liste ab, die beim Methodenaufruf als Parameter übergeben wird. Im Programm, das print aufruft, heißt die Listenvariable strings, aber in der Methode print wird die Variable list genannt - der Name der Variablen, die die Liste speichert, könnte auch printables sein.

Es ist auch möglich, mehrere Variablen für eine Methode zu definieren. Im folgenden Beispiel empfängt die Methode zwei Parameter: eine Liste von Zahlen und einen Schwellenwert. Sie druckt dann alle Zahlen in der Liste aus, die kleiner als der zweite Parameter sind.

public static void printSmallerThan(ArrayList<Integer> numbers, int threshold) {
    for (int number: numbers) {
        if (number < threshold) {
            System.out.println(number);
        }
    }
}

ArrayList<Integer> list = new ArrayList<>();

list.add(1);
list.add(2);
list.add(3);
list.add(2);
list.add(1);

printSmallerThan(list, 3);

Wie zuvor kann eine Methode auch einen Wert zurückgeben. Die Methoden, die Werte zurückgeben, haben den Typ des Rückgabewerts anstelle des void-Schlüsselworts, und die eigentliche Rückgabe des Werts erfolgt durch den Befehl return. Die folgende Methode gibt die Größe der Liste zurück.

public static int size(ArrayList<String> list) {
    return list.size();
}

Sie können auch eigene Variablen für Methoden definieren. Die folgende Methode berechnet den Durchschnitt der Zahlen in der Liste. Wenn die Liste leer ist, gibt sie den Wert -1 zurück.

public static double average(ArrayList<Integer> numbers) {
    if (numbers.size() == 0) {
        return -1.0;
    }

    int sum = 0;
    for (int number : numbers) {
        sum = sum + number;
    }

    return 1.0 * sum / numbers.size();
}

Zum Kopieren der Liste als Methodenparameter

Früher haben wir Ganzzahlen, Gleitkommazahlen usw. als Methodenparameter verwendet. Wenn Variablen wie int als Methodenparameter verwendet werden, wird der Wert der Variable für die Verwendung in der Methode kopiert. Dasselbe passiert, wenn der Parameter eine Liste ist.

int und double (und viele weiter) sind sogenannte "primitive types". Im Gegensatz dazu sind Variablen die Listen bezeichnen, sowie nahezu alle Variablen, die große Informationsmengen speichern können, Referenztypen-Variablen (reference typs). Das bedeutet, dass der Wert der Variablen eine Referenz ist, die auf den Speicherort zeigt, der die Informationen enthält.

Wenn eine Liste (oder eine andere Referenztypen-Variable) für die Verwendung in einer Methode kopiert wird, erhält die Methode den Wert der Listenvariable, d.h. eine Referenz. In einem solchen Fall erhält die Methode eine Referenz auf den tatsächlichen Wert einer Referenztypen-Variable, und die Methode kann den Wert der ursprünglichen Referenztypen-Variable, wie einer Liste, ändern. In der Praxis ist die Liste, die die Methode als Parameter erhält, dieselbe Liste, die im Programm verwendet wird, das die Methode aufruft.

Schauen wir uns dies kurz mit der folgenden Methode an.

public static void removeFirst(ArrayList<Integer> numbers) {
    if (numbers.size() == 0) {
        return;
    }

    numbers.remove(0);
}

ArrayList<Integer> numbers = new ArrayList<>();
numbers.add(3);
numbers.add(2);
numbers.add(6);
numbers.add(-1);

System.out.println(numbers);

removeFirst(numbers);

System.out.println(numbers);

removeFirst(numbers);
removeFirst(numbers);
removeFirst(numbers);

System.out.println(numbers);

Eine Zusammenfassung der List-Methoden

Die ArrayList enthält eine Reihe nützlicher Methoden. Die Methode arbeitet immer auf dem Listenobjekt, das mit dem Methodenaufruf verbunden ist - diese Verbindung wird mit einem Punkt hergestellt. Das folgende Beispiel zeigt, dass ein Programm mehrere Listen enthalten kann, was auch für andere Variablen gilt. Unten werden zwei separate Listen erstellt.

ArrayList<String> exercises1 = new ArrayList<>();
ArrayList<String> exercises2 = new ArrayList<>();

exercises1.add("Ada Lovelace");
exercises1.add("Hello World! (Ja Mualima!)");
exercises1.add("Six");

exercises2.add("Adding a positive number");
exercises2.add("Employee's pension insurance");

System.out.println("The size of list 1: " + exercises1.size());
System.out.println("The size of list 2: " + exercises2.size());

System.out.println("The first value of the first list " + exercises1.get(0));
System.out.println("The last value of the second list " + exercises2.get(exercises2.size() - 1));

Jede Liste ist ihre eigene separate Entität, und die Methoden der Liste betreffen immer die Liste, die verwendet wurde, um die Methode aufzurufen. Eine Zusammenfassung einiger Listenmethoden wird unten bereitgestellt. Es wird davon ausgegangen, dass die erstellte Liste Variablen des Typs String enthält.

• Das Hinzufügen zu einer Liste erfolgt mit der Methode add, die den hinzuzufügenden Wert als Parameter erhält.

ArrayList<String> list = new ArrayList<>();
list.add("hello world!");

• Die Anzahl der Elemente in einer Liste kann mit der nicht-parametrisierten Methode size ermittelt werden; sie gibt eine Ganzzahl zurück.

ArrayList<String> list = new ArrayList<>();
int size = list.size();
System.out.println(size);

• Sie können einen Wert von einem bestimmten Index mit der Methode get abrufen, die den Index erhält, an dem sich der Wert befindet.

ArrayList<String> list = new ArrayList<>();
list.add("hello world!");
String string = list.get(0);
System.out.println(string);

• Das Entfernen von Elementen aus einer Liste erfolgt mit Hilfe von remove. Es erhält entweder den zu entfernenden Wert oder den Index des zu entfernenden Werts als Parameter.

ArrayList<String> list = new ArrayList<>();
// remove the string "hello world!"
list.remove("hello world!");
// remove the value at index 3
list.remove(3);

• Das Überprüfen auf das Vorhandensein eines Werts erfolgt mit der Methode contains. Sie wird mit dem gesuchten Wert als Parameter bereitgestellt und gibt einen booleschen Wert zurück.

ArrayList<String> list = new ArrayList<>();
boolean found = list.contains("hello world!");