Datenstrukturen Grundlagen: Array, Liste, Stack & Queue erklärt

Stell dir vor, du sitzt im ersten Semester Informatik oder im ersten Lehrjahr als Fachinformatiker. Deine Aufgabe: Verwalte 1.000 Kunden-Daten. Du erstellst dir 1.000 einzelne Variablen - `kunde1`, `kunde2`, `kunde3`... Spätestens bei `kunde847` merkst du: Das kann nicht der richtige Weg sein. Genau hier kommen Datenstrukturen Grundlagen ins Spiel. Datenstrukturen sind Container, die mehrere Werte logisch organisieren und dir den Zugriff darauf erleichtern - egal ob du Azubi, Student oder Berufseinsteiger bist.

Was sind Datenstrukturen?

Eine Datenstruktur ist eine konkrete Art, Daten im Arbeitsspeicher deines Computers abzulegen und zu verwalten. Stell sie dir vor wie verschiedene Schränke im Büro: Ein Aktenschrank ist super, um Dokumente alphabetisch zu sortieren. Ein Posteingangskorb ist besser, wenn du Dinge nach dem Prinzip "was zuerst reinkommt, wird zuerst bearbeitet" abarbeiten willst. Gleiche Daten, unterschiedliche Organisation - und je nach Aufgabe ist eine Struktur deutlich effizienter als die andere.

Merke: Die Wahl der richtigen Datenstruktur entscheidet darüber, ob dein Programm in Millisekunden oder in Minuten läuft.

Java liefert dir für die meisten Datenstrukturen bereits fertige Klassen über die Java Collections API (ein Paket vorgefertigter Datenstrukturen im Java-Standardframework). Du musst also das Rad nicht neu erfinden - du musst nur wissen, welches Rad du wann benutzt.

Mehr zu den Grundlagen von Java findest du auch in unserem Beitrag zu Java Variablen & Datentypen.

Was ist ein Array?

Ein Array ist die einfachste Datenstruktur in Java. Es speichert eine feste Anzahl von Elementen desselben Datentyps an einem zusammenhängenden Speicherbereich. Die Größe legst du bei der Erstellung fest - danach lässt sie sich nicht mehr ändern.

Stell dir ein Array wie einen Tablettenstreifen vor: Jedes Fach hat dieselbe Größe, und wenn alle Fächer belegt sind, brauchst du einen neuen Streifen.

// Array mit 5 Plaetzen fuer ganze Zahlen
int[] zahlen = new int[5];

// Werte zuweisen
zahlen[0] = 10;
zahlen[1] = 20;
zahlen[2] = 30;
zahlen[3] = 40;
zahlen[4] = 50;

// Zugriff auf das erste Element (Index beginnt bei 0)
System.out.println(zahlen[0]); // Ausgabe: 10

Wichtig: Der Index (die Positionsnummer) beginnt in Java immer bei `0`. Das letzte Element eines Arrays mit 5 Plätzen hat also den Index `4`, nicht `5`.

Merke: Arrays haben eine feste Größe. Wenn du zur Laufzeit mehr Platz brauchst als ursprünglich geplant, musst du ein neues Array anlegen und alle Werte umkopieren.

Die offizielle Dokumentation dazu findest du bei Oracle.

Was ist eine Liste (ArrayList)?

Eine Liste (in Java meist als `ArrayList` implementiert) ist eine dynamische Datenstruktur. Sie verhält sich wie ein Array, das automatisch mitwächst, wenn du neue Elemente hinzufügst. Du musst beim Erstellen keine feste Größe angeben.

Die Analogie: Ein Array ist wie ein Notizblock mit genau 50 Seiten. Eine Liste ist wie ein Ringbuch - du kannst jederzeit neue Blätter einheften, ohne ein ganz neues Buch zu kaufen.

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

List<String> namen = new ArrayList<>();

namen.add("Anna");
namen.add("Max");
namen.add("Lisa");

System.out.println(namen.get(1)); // Ausgabe: Max

namen.remove("Max"); // Element entfernen
System.out.println(namen.size()); // Ausgabe: 2

Hier siehst du Generics (die `<String>`-Schreibweise). Das bedeutet einfach: Du sagst Java beim Erstellen, dass diese Liste nur Textwerte (Strings) enthalten darf. Versuchst du, eine Zahl hinzuzufügen, blockt der Compiler das ab.

Merke: Eine ArrayList ist die Standardwahl, wenn du eine flexible Sammlung von Elementen brauchst und ungefähr weißt, dass du häufiger lesend darauf zugreifst als einfügst.

Weitere Details zu Listen und Iteration findest du in unserem Artikel zu Java Schleifen: for, while und do-while.

Was ist ein Stack?

Ein Stack (auf Deutsch: Stapel) funktioniert nach dem LIFO-Prinzip: Last In, First Out. Das zuletzt abgelegte Element wird als Erstes wieder entnommen. Stell dir einen Stapel Teller vor: Du legst neue Teller oben drauf und nimmst auch von oben wieder einen weg.

In Java nutzt du dafür die Klasse `java.util.Stack` oder - die modernere Empfehlung - `java.util.ArrayDeque`.

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

Deque<String> browserHistory = new ArrayDeque<>();

browserHistory.push("google.com");  // Unten
browserHistory.push("github.com");  // Darueber
browserHistory.push("stackoverflow.com"); // Oben

// pop() holt das oberste Element und entfernt es
System.out.println(browserHistory.pop()); // Ausgabe: stackoverflow.com
System.out.println(browserHistory.pop()); // Ausgabe: github.com

Stacks brauchst du in der Praxis zum Beispiel für die Verwaltung von Funktionsaufrufen (den Call-Stack), für Undo-Funktionen in Texteditoren oder beim Parsen von Klammerausdrücken.

Was ist eine Queue?

Eine Queue (auf Deutsch: Warteschlange) arbeitet nach dem FIFO-Prinzip: First In, First Out. Das erste Element, das hineinkommt, wird auch als Erstes wieder herausgenommen. Genau wie an der Supermarktkasse: Wer zuerst ansteht, wird zuerst bedient.

import java.util.LinkedList;
import java.util.Queue;

Queue<String> druckauftraege = new LinkedList<>();

druckauftraege.add("Dokument1.pdf");
druckauftraege.add("Dokument2.pdf");
druckauftraege.add("Dokument3.pdf");

// poll() holt das vorderste Element und entfernt es
System.out.println(druckauftraege.poll()); // Ausgabe: Dokument1.pdf
System.out.println(druckauftraege.poll()); // Ausgabe: Dokument2.pdf

Queues brauchst du überall, wo Aufgaben in der Reihenfolge ihres Eintreffens abgearbeitet werden sollen: Druckerwarteschlangen, Event-Processing oder Message-Systeme.

Datenstrukturen Grundlagen: Vergleich auf einen Blick

Merke: Wenn du weißt, wie viele Elemente du brauchst, nimm ein Array. Wenn die Anzahl variabel ist, nimm eine ArrayList. Wenn du eine bestimmte Reihenfolge brauchst (LIFO oder FIFO), wähle Stack oder Queue.

Häufige Anfängerfehler

Fehler 1: Array-Index-Out-Of-Bounds

Der Klassiker. Du versuchst, auf einen Index zuzugreifen, der gar nicht existiert.

Falsch:

int[] zahlen = new int[3];
zahlen[3] = 99; // Exception! Index 3 existiert nicht

Richtig:

int[] zahlen = new int[3];
zahlen[2] = 99; // Letzter gueltiger Index ist 2

Warum? Weil der Index bei `0` beginnt. Bei einem Array der Länge 3 sind das die Indizes `0`, `1` und `2`.

Fehler 2: Stack mit `add()` statt `push()` nutzen

Wenn du einen Stack verwendest, solltest du konsequent die Stack-Methoden (`push`, `pop`, `peek`) nutzen und nicht die Listen-Methoden (`add`, `get`).

Problematisch:

Deque<String> stack = new ArrayDeque<>();
stack.add("Erstes"); // Funktioniert, ist aber semantisch falsch fuer einen Stack

Besser:

Deque<String> stack = new ArrayDeque<>();
stack.push("Erstes"); // Klar: Das ist eine Stack-Operation

Warum? Weil `add()` ein Element am Ende einfügt, `push()` aber am Anfang. Bei korrekter Nutzung als LIFO-Stack musst du das mit `push` tun, damit `pop` dasselbe Element zurückgibt.

Fehler 3: `==` statt `.equals()` bei Strings in Listen

Beim Suchen oder Vergleichen von Strings in Datenstrukturen führt `==` oft zu falschen Ergebnissen, da es Referenzen vergleicht, nicht den Inhalt. Java String Methoden behandeln das Thema vertieft.

Übungstipp: Baue dir einen Task-Manager

Nimm dir 30 Minuten Zeit und baue ein kleines Programm, das drei Datenstrukturen kombiniert:

1. Ein Array für die Wochentage (fest, unveränderlich)

2. Eine ArrayList für offene Aufgaben (dynamisch, jederzeit erweiterbar)

3. Einen Stack für gelöschte Aufgaben (für eine Undo-Funktion)

Diese Übung zwingt dich, über die Eigenschaften jeder Struktur nachzudenken. Du merkst schnell: Für jeden Anwendungsfall gibt es eine optimale Wahl - und die falsche Wahl kostet Performance oder Code-Lesbarkeit.

FAQ: Häufige Fragen zu Datenstrukturen Grundlagen

Was ist der Unterschied zwischen Array und ArrayList?

Ein Array hat eine feste Größe, die bei der Erstellung festgelegt wird. Eine ArrayList ist dynamisch und wächst automatisch mit. Arrays sind minimal schneller, ArrayLists sind flexibler.

Wann nutze ich einen Stack und wann eine Queue?

Einen Stack, wenn du das zuletzt hinzugefügte Element zuerst brauchst (z. B. Undo-Funktion). Eine Queue, wenn du Elemente in der Reihenfolge ihres Eintreffens verarbeiten willst (z. B. Druckaufträge).

Was bedeutet LIFO und FIFO?

LIFO steht für "Last In, First Out" (Stack - das letzte Element kommt zuerst raus). FIFO steht für "First In, First Out" (Queue - das erste Element kommt zuerst raus).

Sind Datenstrukturen in jeder Programmiersprache gleich?

Die Konzepte sind universell, aber die Implementierung unterscheidet sich. Java bietet mit der Collections API eine besonders umfangreiche Auswahl an fertigen Datenstrukturen.

Was ist der Unterschied zwischen einer LinkedList und einer ArrayList?

Eine LinkedList speichert jedes Element als separaten Knoten mit Verweis auf den nächsten. Das macht Einfügen in der Mitte sehr schnell, aber den Zugriff auf ein bestimmtes Element langsamer. Eine ArrayList nutzt intern ein Array - Zugriff ist schnell, Einfügen in der Mitte erfordert Verschieben aller folgenden Elemente.

Fazit

Datenstrukturen sind das Fundament jeder Softwareentwicklung. Wenn du die vier Grundtypen - Array, Liste, Stack und Queue - verstanden hast, kannst du 80 % aller alltäglichen Programmieraufgaben effizient lösen. Der Schlüssel liegt nicht darin, alle Details auswendig zu kennen, sondern die richtige Struktur für den jeweiligen Anwendungsfall auszuwählen.

Brauchst du Hilfe dabei, diese Konzepte wirklich zu verstehen? Ob du Azubi im ersten Lehrjahr, Informatik-Student im ersten Semester oder Berufseinsteiger bist - bei study-it.education findest du individuelle IT-Nachhilfe, die genau dort ansetzt, wo du stehst. Schau vorbei und buche deine erste Session.