0Pricing
Java Academy · Lekcja

Tworzenie i sprawdzanie obiektów Optional

Bezpiecznie używaj Optional.of, ofNullable, empty, isPresent, isEmpty i get.

Tworzenie i sprawdzanie obiektów Optional to bezpłatna lekcja Java Academy na CoddyKit. To lekcja 2 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Java Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Java Academy zawiera 4 lekcji w sumie.

Tworzenie i sprawdzanie Optional

Ta lekcja omawia metody tworzenia instancji Optional i sprawdzania ich zawartości: isPresent, isEmpty, get oraz bezpieczne alternatywy.

Trzy sposoby tworzenia Optional

Optional można utworzyć za pomocą Optional.of(), Optional.ofNullable() lub 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 i isEmpty

isPresent() zwraca true, jeśli wartość jest obecna. isEmpty() (Java 11+) jest logicznym przeciwieństwem tej metody.

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(): używaj ostrożnie

get() zwraca wartość lub zgłasza NoSuchElementException. Nigdy nie należy wywoływać tej metody bez wcześniejszego sprawdzenia.

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 i orElseGet

orElse(default) zwraca wartość domyślną, gdy Optional jest pusty. orElseGet(supplier) wywołuje dostawcę leniwie — jest lepszym wyborem w przypadku kosztownych wartości domyślnych.

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() zgłasza NoSuchElementException lub własny wyjątek, gdy Optional jest pusty. Należy używać tej metody, gdy brak wartości rzeczywiście oznacza błąd.

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 i ifPresentOrElse

Metody te pozwalają wykonać operację na wartości bez jej wyodrębniania. Są czytelnym rozwiązaniem w przypadku efektów ubocznych.

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

Sprawdzanie obecności tekstu

Częsty przypadek użycia: zwracanie wartości domyślnej, gdy tekst konfiguracyjny jest nieobecny lub pusty.

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() dla alternatywnych wartości Optional

or() (Java 9+) zwraca ten sam Optional, jeśli zawiera on wartość, albo inny Optional dostarczony przez dostawcę.

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 do warunkowego zachowania wartości

filter(predicate) zachowuje wartość tylko wtedy, gdy spełnia ona predykat; w przeciwnym razie zwraca pusty Optional.

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());

Praktyka: wyszukiwanie użytkownika z wartością zapasową

Połączenie isPresent, orElse i ifPresentOrElse w realistycznym scenariuszu wyszukiwania użytkownika.

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

Szybkie sprawdzenie

Czym orElseGet() różni się od orElse()?

Podsumowanie: tworzenie i sprawdzanie Optional

Najważniejsze informacje:

  • Optional.of() wymaga wartości innej niż null, a Optional.ofNullable() akceptuje null
  • isPresent() / isEmpty() sprawdzają obecność; należy unikać wywoływania get() bez wcześniejszego sprawdzenia
  • orElse() służy do tanich wartości domyślnych, a orElseGet() do kosztownych wartości domyślnych obliczanych na żądanie
  • orElseThrow() należy stosować, gdy brak wartości oznacza błąd
  • ifPresent() i ifPresentOrElse() służą do wykonywania efektów ubocznych bez wyodrębniania wartości
  • filter() zachowuje wartość tylko po spełnieniu predykatu, a or() łączy zapasowe wartości Optional

Często zadawane pytania

Czy lekcja „Tworzenie i sprawdzanie obiektów Optional” jest bezpłatna?

Tak — pełny tekst „Tworzenie i sprawdzanie obiektów Optional” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Java Academy, przejdź na CoddyKit PRO. Kurs Java Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Tworzenie i sprawdzanie obiektów Optional”?

Bezpiecznie używaj Optional.of, ofNullable, empty, isPresent, isEmpty i get. Ćwiczysz Java Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Java Academy?

Nie wymagamy żadnego doświadczenia. Java Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 4.

Ile czasu zajmuje lekcja „Tworzenie i sprawdzanie obiektów Optional”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Java Academy?

Tak. Każda lekcja Java Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Dlaczego istnieje Optional
  2. Tworzenie i sprawdzanie obiektów Optional
  3. Przekształcanie obiektów Optional: map i flatMap
  4. Dobre praktyki używania Optional
← Powrót do Java Academy