0Pricing
Java Academy · Lektion

Optionals erstellen und untersuchen

Verwenden Sie Optional.of, ofNullable, empty, isPresent, isEmpty und get sicher.

Optionals erstellen und untersuchen ist eine kostenlose Java Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Java Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.

Optionals erstellen und untersuchen

Diese Lektion behandelt die Methoden zum Erstellen von Optional-Instanzen und zum Untersuchen ihres Inhalts: isPresent, isEmpty, get und sichere Alternativen.

Drei Möglichkeiten zum Erstellen eines Optional

Erstellen Sie ein Optional mit Optional.of(), Optional.ofNullable() oder Optional.empty().

import java.util.Optional;

// 1. of: must be non-null
Optional<String> a = Optional.of("hello");

// 2. ofNullable: safely wraps null
String maybeNull = null;
Optional<String> b = Optional.ofNullable(maybeNull); // empty
Optional<String> c = Optional.ofNullable("world");   // present

// 3. empty: explicitly empty
Optional<Integer> empty = Optional.empty();

System.out.println(a.isPresent()); // true
System.out.println(b.isPresent()); // false
System.out.println(c.isEmpty());   // false

isPresent und isEmpty

isPresent() liefert true, wenn ein Wert vorhanden ist. isEmpty() (Java 11+) ist das logische Gegenteil.

import java.util.Optional;

Optional<String> opt = Optional.of("Java");

System.out.println(opt.isPresent()); // true
System.out.println(opt.isEmpty());   // false

Optional<String> empty = Optional.empty();
System.out.println(empty.isPresent()); // false
System.out.println(empty.isEmpty());   // true

// Prefer ifPresent() over if (isPresent()) get() — more readable
opt.ifPresent(v -> System.out.println(v.toUpperCase())); // JAVA

get(): Mit Vorsicht verwenden

get() liefert den Wert oder löst NoSuchElementException aus. Rufen Sie die Methode niemals auf, ohne vorher zu prüfen.

import java.util.Optional;

Optional<String> opt = Optional.of("present");
System.out.println(opt.get()); // present

Optional<String> empty = Optional.empty();
try {
    empty.get(); // NoSuchElementException!
} catch (java.util.NoSuchElementException e) {
    System.out.println("No value!");
}

// Better pattern: always use orElse/orElseGet/orElseThrow
// instead of isPresent() + get()

orElse und orElseGet

orElse(default) liefert den Standardwert, wenn das Optional leer ist. orElseGet(supplier) ruft den Supplier verzögert auf – das ist bei aufwendig zu ermittelnden Standardwerten besser.

import java.util.Optional;

Optional<String> plan = Optional.empty();

// orElse: default value always evaluated
String basic = plan.orElse("FREE");
System.out.println(basic); // FREE

// orElseGet: supplier only called when empty (lazy)
String lazy = plan.orElseGet(() -> {
    System.out.println("Computing default...");
    return "FREE";
});
System.out.println(lazy); // Computing default... FREE

// When present, orElseGet supplier is NOT called
Optional.of("PRO").orElseGet(() -> {
    System.out.println("Not called!");
    return "FREE";
}); // silent — present, no computation needed

orElseThrow

orElseThrow() löst NoSuchElementException oder eine benutzerdefinierte Exception aus, wenn das Optional leer ist. Verwenden Sie die Methode, wenn das Fehlen eines Werts tatsächlich einen Fehler darstellt.

import java.util.Optional;

Optional<String> userId = Optional.empty();

// Default: throws NoSuchElementException
try {
    userId.orElseThrow();
} catch (java.util.NoSuchElementException e) {
    System.out.println("Empty!");
}

// Custom exception
try {
    userId.orElseThrow(() -> new IllegalStateException("User ID required"));
} catch (IllegalStateException e) {
    System.out.println(e.getMessage()); // User ID required
}

ifPresent und ifPresentOrElse

Mit diesen Methoden können Sie auf den Wert reagieren, ohne ihn zu extrahieren. Sie eignen sich gut für Seiteneffekte.

import java.util.Optional;

Optional<String> username = Optional.of("alice");

// ifPresent: callback only when present
username.ifPresent(u -> System.out.println("Welcome, " + u));
// Welcome, alice

Optional<String> missing = Optional.empty();

// ifPresentOrElse (Java 9+): callback or else action
missing.ifPresentOrElse(
    u -> System.out.println("Hello " + u),
    () -> System.out.println("Anonymous user")
);
// Anonymous user

Prüfen, ob ein String vorhanden ist

Ein häufiger Anwendungsfall: Einen Standardwert zurückgeben, wenn ein Konfigurations-String fehlt oder leer ist.

import java.util.Optional;

static Optional<String> getConfig(String key) {
    // Simulate config lookup
    return Optional.ofNullable(System.getenv(key));
}

String port = getConfig("PORT").orElse("8080");
String host = getConfig("HOST").orElse("localhost");

System.out.println("Server: " + host + ":" + port);
// Server: localhost:8080 (when env vars not set)

Optional.or() für alternative Optionals

or() (Java 9+) liefert das Optional selbst, wenn es nicht leer ist, oder ein anderes Optional, das von einem Supplier bereitgestellt wird.

import java.util.Optional;

static Optional<String> findInCache(String key)   { return Optional.empty(); }
static Optional<String> findInDatabase(String key) { return Optional.of("Alice"); }

Optional<String> result = findInCache("user:1")
    .or(() -> findInDatabase("user:1"));

System.out.println(result.get()); // Alice

// Useful for fallback chains:
Optional<String> value = Optional.empty()
    .or(() -> Optional.empty())
    .or(() -> Optional.of("final fallback"));
System.out.println(value.get()); // final fallback

Filter für bedingtes Vorhandensein

filter(predicate) behält den Wert nur dann, wenn er das Prädikat erfüllt; andernfalls wird ein leeres Optional zurückgegeben.

import java.util.Optional;

Optional<Integer> age = Optional.of(17);

Optional<Integer> adult = age.filter(a -> a >= 18);
System.out.println(adult.isPresent()); // false (17 is not >= 18)

Optional<Integer> age2 = Optional.of(25);
Optional<Integer> adult2 = age2.filter(a -> a >= 18);
System.out.println(adult2.get()); // 25

// Chain: find active premium user
Optional<User> premiumActive = findUser(id)
    .filter(u -> "PRO".equals(u.plan()))
    .filter(u -> u.isActive());

Praxisbeispiel: Benutzersuche mit Fallback

isPresent, orElse und ifPresentOrElse in einem realistischen Szenario zur Benutzersuche kombinieren.

import java.util.Optional;

record User(long id, String name, String email) {}

static Optional<User> findById(long id) {
    return id == 1 ? Optional.of(new User(1, "Alice", "alice@co.com"))
                   : Optional.empty();
}

static void displayUser(long id) {
    findById(id).ifPresentOrElse(
        u -> System.out.println("Found: " + u.name() + " <" + u.email() + ">"),
        () -> System.out.println("User " + id + " not found")
    );
}

displayUser(1);  // Found: Alice <alice@co.com>
displayUser(99); // User 99 not found

Kurze Wissensprüfung

Was macht orElseGet() anders als orElse()?

Zusammenfassung: Optionals erstellen und untersuchen

Die wichtigsten Erkenntnisse:

  • Optional.of() erfordert einen Wert ungleich null; Optional.ofNullable() akzeptiert null
  • isPresent() / isEmpty() prüfen, ob ein Wert vorhanden ist; vermeiden Sie get(), ohne vorher zu prüfen
  • orElse() für günstige Standardwerte; orElseGet() für aufwendig berechnete Standardwerte
  • orElseThrow(), wenn das Fehlen eines Werts einen Fehler darstellt
  • ifPresent() und ifPresentOrElse() für Seiteneffekte, ohne den Wert zu extrahieren
  • filter() behält den Wert nur bei erfülltem Prädikat; or() verkettet Fallback-Optionals

Häufig gestellte Fragen

Ist die Lektion „Optionals erstellen und untersuchen“ kostenlos?

Ja — der vollständige Text von „Optionals erstellen und untersuchen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Java Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Optionals erstellen und untersuchen“?

Verwenden Sie Optional.of, ofNullable, empty, isPresent, isEmpty und get sicher. Du übst Java Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Java Academy zu starten?

Keine Vorkenntnisse erforderlich. Java Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „Optionals erstellen und untersuchen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Java Academy-Lektion Code schreiben und ausführen?

Ja. Jede Java Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Warum Optional existiert
  2. Optionals erstellen und untersuchen
  3. Optionals transformieren: map und flatMap
  4. Best Practices für Optional
← Zurück zu Java Academy