Algorithmen und Datenstrukturen in Java: Vollständiger Leitfaden für Entwickler

Online Python-Trainer für Anfänger

Lernen Sie Python einfach ohne theoretische Überlastung. Lösen Sie praktische Aufgaben mit automatischer Überprüfung und schreiben Sie Code direkt im Browser.

Kurs starten

Algorithmen und Datenstrukturen in Java: Grundlagen effizienter Programmierung

Das Erlernen von Algorithmen und Datenstrukturen ist ein Eckpfeiler der professionellen Java-Programmierung. Ob Sie Microservices, mobile Anwendungen oder komplexe Datenverarbeitungssysteme schreiben – ein tiefes Verständnis dieser Konzepte wirkt sich direkt auf die Leistung, Skalierbarkeit und Lesbarkeit Ihres Codes aus. In diesem Artikel werden wir die wichtigsten in Java implementierten Datenstrukturen und die wichtigsten Algorithmen zu deren Verarbeitung aufschlüsseln, die für jeden Java-Entwickler nützlich sind.

1. Grundlegende Datenstrukturen im Java Collections Framework

Java bietet ein leistungsstarkes und flexibles Collections Framework, das die meisten gängigen Datenstrukturen implementiert. Zu verstehen, wann und welche Struktur verwendet werden soll, ist der erste Schritt, um optimalen Code zu schreiben.

1.1. Dynamische Arrays: ArrayList

ArrayList ist eine Implementierung eines dynamischen Arrays. Im Gegensatz zu einem regulären Array expandiert es automatisch, wenn Elemente hinzugefügt werden. Es ist ideal für Fälle, in denen ein schneller Zugriff per Index erforderlich ist (O(1)), aber das Einfügen oder Löschen in der Mitte der Liste kann teuer sein (O(n)).

import java.util.ArrayList;

public class ArrayListExample {    public static void main(String[] args) {        ArrayList<String> names = new ArrayList<>();        names.add("Anna");        names.add("Boris");        names.add("Victor");

        // Fast access by index        System.out.println("First element: " + names.get(0));

        // Removing an element (shifting elements)        names.remove(1); // Removing "Boris"        System.out.println("After removal: " + names);    }}

1.2. Verkettete Listen: LinkedList

LinkedList ist als doppelt verkettete Liste implementiert. Sie eignet sich gut für häufige Einfüge- und Löschoperationen am Anfang oder Ende der Liste (O(1)). Der Zugriff per Index erfordert jedoch das Durchlaufen der Liste (O(n)).

import java.util.LinkedList;

public class LinkedListExample {    public static void main(String[] args) {        LinkedList<Integer> queue = new LinkedList<>();        queue.addLast(10); // Adding to the end        queue.addLast(20);        queue.addFirst(5); // Adding to the beginning

        System.out.println("First: " + queue.getFirst());        System.out.println("Last: " + queue.getLast());

        // Removing the first element        Integer first = queue.pollFirst();        System.out.println("Removed: " + first + ", remaining: " + queue);    }}

1.3. Stapel und Warteschlange: Deque und Queue

Für die Arbeit nach dem LIFO- (Last In, First Out) oder FIFO-Prinzip (First In, First Out) stellt Java die Schnittstellen Deque und Queue bereit. Die Implementierung ArrayDeque ist für diese Aufgaben oft schneller als LinkedList.

import java.util.ArrayDeque;import java.util.Deque;

public class StackQueueExample {    public static void main(String[] args) {        // Stack (LIFO)        Deque<String> stack = new ArrayDeque<>();        stack.push("First");        stack.push("Second");        stack.push("Third");        System.out.println("Top of stack: " + stack.peek()); // Third        System.out.println("Popping: " + stack.pop()); // Third

        // Queue (FIFO) - using as Queue        Deque<String> queue = new ArrayDeque<>();        queue.offer("Client 1");        queue.offer("Client 2");        System.out.println("First in queue: " + queue.peek()); // Client 1        System.out.println("Serving: " + queue.poll()); // Client 1    }}