Java Spickzettel
Zuletzt aktualisiert
Hello World & Programmaufbau
Jedes Java-Programm läuft von einer main-Methode innerhalb einer Klasse aus.
| Element | Code |
|---|---|
| Klassendeklaration | public class Main { ... } |
| Einstiegspunkt | public static void main(String[] args) { ... } |
| Eine Zeile ausgeben | System.out.println("Hello, World!"); |
| Ohne Zeilenumbruch ausgeben | System.out.print("text"); |
| Eingabe lesen | Scanner sc = new Scanner(System.in); |
| Eine Klasse importieren | import java.util.ArrayList; |
| Kommentare | // line und /* block */ |
Datentypen
Primitive werden kleingeschrieben; ihre Wrapper-Klassen großgeschrieben.
| Typ | Beschreibung |
|---|---|
int | 32-Bit-Ganzzahl mit Vorzeichen |
long | 64-Bit-Ganzzahl mit Vorzeichen |
double / float | Gleitkommazahlen |
boolean | true oder false |
char | Einzelnes 16-Bit-Unicode-Zeichen |
byte / short | 8-Bit- / 16-Bit-Ganzzahlen |
String | Unveränderlicher Text (eine Klasse, kein Primitiv) |
Integer, Double, Boolean | Wrapper-Klassen für Primitive |
var | Abgeleiteter lokaler Typ (Java 10+) |
Variablen
| Operation | Syntax |
|---|---|
| Deklarieren & initialisieren | int x = 5; |
| Typinferenz (lokal) | var name = "Ada"; |
| Konstante | final double PI = 3.14159; |
| String-Verkettung | String s = "Hi " + name; |
| String in int umwandeln | int n = Integer.parseInt("42"); |
| int in String umwandeln | String s = String.valueOf(42); |
| Formatierter String | String.format("%d items", n) |
Kontrollfluss
| Anweisung | Syntax |
|---|---|
| If / else | if (x > 0) { ... } else { ... } |
| Switch-Anweisung | switch (n) { case 1: ...; break; default: ...; } |
| Switch-Ausdruck | var s = switch (n) { case 1 -> "one"; default -> "other"; }; |
| While-Schleife | while (i < n) { ... } |
| Do-while-Schleife | do { ... } while (i < n); |
| For-Schleife | for (int i = 0; i < n; i++) { ... } |
| Erweiterte For (for-each) | for (String item : list) { ... } |
| Break / continue | break; verlässt eine Schleife, continue; springt zur nächsten Iteration |
Methoden
| Operation | Syntax |
|---|---|
| Eine Methode definieren | int add(int a, int b) { return a + b; } |
| Kein Rückgabewert | void greet() { ... } |
| Statische Methode | static int square(int x) { return x * x; } |
| Öffentliche Methode | public String getName() { return name; } |
| Varargs | int sum(int... nums) { ... } |
| Eine Methode aufrufen | int r = add(2, 3); |
| Eine statische Methode aufrufen | Math.max(a, b); |
| Methodenüberladung | int max(int a, int b) und double max(double a, double b) |
Klassen & OOP
| Operation | Syntax |
|---|---|
| Eine Klasse definieren | public class Dog { ... } |
| Feld | private String name; |
| Konstruktor | public Dog(String name) { this.name = name; } |
| Ein Objekt erstellen | Dog d = new Dog("Rex"); |
| Getter / Setter | public String getName() { return name; } |
| Vererbung | class Puppy extends Dog { ... } |
| Interface | interface Runnable { void run(); } |
| Ein Interface implementieren | class Task implements Runnable { ... } |
| Eine Methode überschreiben | @Override public void speak() { ... } |
Collections
Generische Collections aus java.util.
| Typ | Verwendung & Beispiel |
|---|---|
ArrayList<T> | Dynamisches Array: list.add(1); list.get(0); list.size(); |
HashMap<K, V> | Schlüssel-Wert: map.put("a", 1); map.get("a"); |
HashSet<T> | Eindeutige Werte: set.add(5); set.contains(5); |
LinkedList<T> | Doppelt verkettete Liste, gut als Queue/Deque |
ArrayDeque<T> | Stack/Queue: dq.push(x); dq.pop(); |
| Array | int[] nums = {1, 2, 3}; |
| Eine Liste durchlaufen | for (T x : list) { ... } |
| Eine Map durchlaufen | for (var e : map.entrySet()) { e.getKey(); e.getValue(); } |
Streams & Lambdas
Pipelines im funktionalen Stil über Collections (Java 8+).
| Operation | Syntax |
|---|---|
| Lambda-Ausdruck | x -> x * 2 |
| Einen Stream erstellen | list.stream() |
| Filtern | .filter(n -> n > 0) |
| Map / transformieren | .map(n -> n * 2) |
| Sortieren | .sorted() oder .sorted(Comparator.reverseOrder()) |
| Reduce / Summe | .reduce(0, Integer::sum) |
| Zählen / Abgleich | .count(), .anyMatch(n -> n > 5) |
| Zu Liste sammeln | .collect(Collectors.toList()) |
| For each | .forEach(System.out::println) |
Häufige Muster (try/catch, Generics)
| Muster | Syntax |
|---|---|
| Try / catch | try { ... } catch (Exception e) { ... } |
| Bestimmte Exception abfangen | catch (IOException e) { ... } |
| Finally | finally { ... } läuft immer |
| Try-with-resources | try (Scanner sc = new Scanner(...)) { ... } |
| Eine Exception werfen | throw new IllegalArgumentException("bad"); |
| Generische Klasse | class Box<T> { T value; } |
| Generische Methode | <T> T first(List<T> list) { ... } |
| Beschränkter Typ | <T extends Number> |
Die Java-Syntax, Collections und Stream-Operationen, die du am häufigsten brauchst, auf einer Seite. Dieser Java-Spickzettel ist eine Schnellreferenz zum Schreiben von Java - die Datentypen, der Kontrollfluss, Klassen, die ArrayList/HashMap-Collections, die Streams-API sowie die Exception- und Generics-Muster, die du täglich verwendest.
Alles hier ist Standard-Java (Java 8 und neuer) und kompiliert mit javac. Kopiere, was du brauchst, oder probiere jeden Codeschnipsel live im Java-Playground aus - kein JDK zu installieren.
Java-Spickzettel FAQ
Ist dieser Java-Spickzettel kostenlos?
Ja. Dieser Java-Spickzettel ist völlig kostenlos, ohne erforderliche Anmeldung. Setze ein Lesezeichen und komm jederzeit wieder, wenn du Syntax, eine Collection oder eine Stream-Operation nachschlagen möchtest.
Was ist der Unterschied zwischen == und .equals() in Java?
Bei Objekten vergleicht
== Referenzen - ob zwei Variablen auf genau dasselbe Objekt zeigen - während .equals() die Inhalte vergleicht. Zwei verschiedene String-Objekte mit demselben Text sind .equals(), aber möglicherweise nicht ==. Verwende immer .equals(), um Strings und andere Objekte auf Wertgleichheit zu vergleichen; verwende == nur für Primitive (int, boolean usw.) oder um auf null zu prüfen.Wofür werden Streams in Java verwendet?
Mit der Streams-API (Java 8+) kannst du Collections mit einer gut lesbaren Pipeline von Operationen verarbeiten -
filter, map, sorted, reduce, collect - statt mit manuellen Schleifen. Du beginnst mit list.stream(), verkettest Zwischenoperationen und schließt mit einer terminalen Operation wie collect(Collectors.toList()) oder forEach ab. Das hält den Code zur Datentransformation kompakt und ausdrucksstark.Kann ich Java online üben?
Ja. Öffne den Java-Playground, um jeden Codeschnipsel aus diesem Spickzettel in deinem Browser zu kompilieren und auszuführen - kein JDK zu installieren. Wenn du Struktur möchtest, führt dich Coddys kostenloser interaktiver Java-Kurs Schritt für Schritt von Variablen und Schleifen zu Klassen, Collections und Streams.
Ist dieser Spickzettel für Anfänger geeignet?
Ja. Er ist von den häufigsten Bausteinen (Typen, Kontrollfluss, Methoden) hin zu den fortgeschrittenen (Streams, Generics, Exceptions) gegliedert, sodass du die oberen Abschnitte schon am ersten Tag nutzen und in den Rest hineinwachsen kannst.
Verwandte Ressourcen
Weitere Spickzettel
