Java Collections Algorithmen meistern: Sortieren, Mischen und mehr

Java Algorithmen

In diesem Tutorial erkunden wir die leistungsstarken Algorithmen, die Javas Collections Framework durch klare, praxisnahe Beispiele bereitstellt.

Das Java Collections Framework liefert einen reichen Satz an statischen Methoden – oft als generische Algorithmen bezeichnet –, mit denen Sie Datenstrukturen manipulieren können, ohne Boilerplate-Code zu schreiben. Diese Utilities funktionieren mit jeder Collection, die das Collection Interface implementiert, und bieten sowohl Einfachheit als auch Performance.

Im Folgenden gehen wir die am häufigsten verwendeten Algorithmen durch und illustrieren ihre Syntax, ihr Verhalten und praktische Anwendungsfälle.

1. Sortieren mit Collections.sort()

Die sort() Methode ordnet Elemente in natürlicher (aufsteigender) Reihenfolge. Für benutzerdefinierte Reihenfolge übergeben Sie eine Comparator Implementierung.

import java.util.ArrayList;
import java.util.Collections;

class Main {
    public static void main(String[] args) {
        ArrayList<Integer> numbers = new ArrayList<>();
        numbers.add(4);
        numbers.add(2);
        numbers.add(3);
        System.out.println("Unsortierte ArrayList: " + numbers);
        Collections.sort(numbers);
        System.out.println("Sortierte ArrayList: " + numbers);
    }
}

Ausgabe

Unsortierte ArrayList: [4, 2, 3]
Sortierte ArrayList: [2, 3, 4]

Für absteigende Reihenfolge oder domänenspezifische Kriterien verwenden Sie einen benutzerdefinierten Comparator – siehe den Java Sorting Leitfaden für Details.

2. Zufällige Reihenfolge mit Collections.shuffle()

Verwenden Sie shuffle(), um die Reihenfolge der Elemente zu randomisieren, ideal für Spiele oder Stichproben-Szenarien.

import java.util.ArrayList;
import java.util.Collections;

class Main {
    public static void main(String[] args) {
        ArrayList<Integer> numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        System.out.println("Sortierte ArrayList: " + numbers);
        Collections.shuffle(numbers);
        System.out.println("ArrayList nach shuffle: " + numbers);
    }
}

Ausgabe

Sortierte ArrayList: [1, 2, 3]
ArrayList nach shuffle: [2, 1, 3]

Jeder Durchlauf erzeugt eine andere Permutation, dank des zugrundeliegenden Fisher-Yates Algorithmus.

3. Routinemäßige Datenmanipulation

Java bietet eine Suite von Utility-Methoden zur Transformation von Collections:

• reverse() – kehrt die Elementreihenfolge um.
• fill() – ersetzt jedes Element durch einen angegebenen Wert.
• copy() – kopiert Elemente von einer Collection in eine andere (gleich groß).
• swap() – tauscht zwei Elemente per Index.
• addAll() – fügt alle Elemente einer Collection zu einer anderen hinzu.

import java.util.ArrayList;
import java.util.Collections;

class Main {
    public static void main(String[] args) {
        ArrayList<Integer> numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(2);
        System.out.println("ArrayList1: " + numbers);
        Collections.reverse(numbers);
        System.out.println("Umgekehrte ArrayList1: " + numbers);
        Collections.swap(numbers, 0, 1);
        System.out.println("ArrayList1 nach swap(): " + numbers);
        ArrayList<Integer> newNumbers = new ArrayList<>();
        newNumbers.addAll(numbers);
        System.out.println("ArrayList2 mit addAll(): " + newNumbers);
        Collections.fill(numbers, 0);
        System.out.println("ArrayList1 nach fill(): " + numbers);
        Collections.copy(newNumbers, numbers);
        System.out.println("ArrayList2 nach copy(): " + newNumbers);
    }
}

Ausgabe

ArrayList1: [1, 2]
Umgekehrte ArrayList1: [2, 1]
ArrayList1 nach swap(): [1, 2]
ArrayList2 mit addAll(): [1, 2]
ArrayList1 nach fill(): [0, 0]
ArrayList2 nach copy(): [0, 0]

Hinweis: Die copy() Methode erfordert, dass die Ziel-Collection mindestens so viele Elemente wie die Quelle hat.

4. Binäre Suche mit Collections.binarySearch()

Effizientes Auffinden eines Elements in einer sortierten Collection. Die Methode gibt den Index des Elements oder einen negativen Einfügepunkt zurück, wenn nicht gefunden.

import java.util.ArrayList;
import java.util.Collections;

class Main {
    public static void main(String[] args) {
        ArrayList<Integer> numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        int pos = Collections.binarySearch(numbers, 3);
        System.out.println("Die Position von 3 ist " + pos);
    }
}

Ausgabe

Die Position von 3 ist 2.

Tipp: Sortieren Sie die Collection immer vor dem Aufruf von binarySearch(); andernfalls ist das Ergebnis undefiniert.

Mehr dazu im Artikel Java Binary Search.

5. Collection Composition

Diese Utilities analysieren Beziehungen zwischen Collections:

• frequency() – zählt Vorkommen eines bestimmten Elements.
• disjoint() – prüft, ob zwei Collections keine gemeinsamen Elemente haben.

import java.util.ArrayList;
import java.util.Collections;

class Main {
    public static void main(String[] args) {
        ArrayList<Integer> numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        numbers.add(2);
        System.out.println("ArrayList1: " + numbers);
        int count = Collections.frequency(numbers, 2);
        System.out.println("Anzahl von 2: " + count);
        ArrayList<Integer> newNumbers = new ArrayList<>();
        newNumbers.add(5);
        newNumbers.add(6);
        System.out.println("ArrayList2: " + newNumbers);
        boolean disjoint = Collections.disjoint(numbers, newNumbers);
        System.out.println("Zwei Listen sind disjunkt: " + disjoint);
    }
}

Ausgabe

ArrayList1: [1, 2, 3, 2]
Anzahl von 2: 2
ArrayList2: [5, 6]
Zwei Listen sind disjunkt: true

6. Minimum und Maximum finden

Rufen Sie das kleinste oder größte Element mit min() und max() ab – nützlich für Analysen und Grenzprüfungen.

import java.util.ArrayList;
import java.util.Collections;

class Main {
    public static void main(String[] args) {
        ArrayList<Integer> numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        int min = Collections.min(numbers);
        System.out.println("Minimales Element: " + min);
        int max = Collections.max(numbers);
        System.out.println("Maximales Element: " + max);
    }
}

Ausgabe

Minimales Element: 1
Maximales Element: 3