Java Academy · Lezione

Buone pratiche per Optional

Applichi orElse, orElseGet e orElseThrow, evitando i più comuni anti-pattern con Optional.

Buone pratiche per Optional è una lezione Java Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Java Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Java Academy include 4 lezioni in totale.

Best practice per Optional

Optional è uno strumento potente se utilizzato correttamente. Questa lezione illustra cosa fare e cosa evitare, con esempi concreti tratti da basi di codice reali.

Da fare: utilizzare Optional come tipo restituito

Il principale caso d'uso di Optional è come tipo restituito da metodi che potrebbero non trovare o produrre un valore.

import java.util.Optional;

// Good: signals to caller that result might be absent
public Optional<User> findByUsername(String username) { ... }
public Optional<Config> getConfig(String key) { ... }
public Optional<String> getHeader(String name) { ... }

// These are all cases where absence is a normal outcome,
// not an exceptional condition

Da evitare: Optional come campo

I campi di tipo Optional aggiungono un sovraccarico agli oggetti e complicano la serializzazione. Per i campi opzionali all'interno delle classi, utilizzi null o un valore sentinella.

// BAD
class User {
    private Optional<String> middleName; // wrong
}

// GOOD: use null for absent optional field
class User {
    private final String middleName; // null = absent
    public Optional<String> middleName() {
        return Optional.ofNullable(middleName); // expose as Optional in getter
    }
}
User u = new User(null); // null field
System.out.println(u.middleName().isPresent()); // false

Da evitare: Optional come parametro di metodo

I parametri Optional obbligano i chiamanti a racchiudere inutilmente i valori in un Optional. Utilizzi l'overloading o @Nullable.

// BAD
void sendNotification(String message, Optional<String> subject) { ... }
// caller must write: sendNotification("Hello", Optional.of("News"))

// GOOD: overloading
void sendNotification(String message) { sendNotification(message, null); }
void sendNotification(String message, String subject) {
    // subject may be null
}
// caller writes: sendNotification("Hello", "News") — clean

Da evitare: Optional nelle collezioni

Non inserisca mai Optional all'interno di una List, Set o come valore di una Map. Gli Optional vuoti nelle collezioni non hanno significato: ometta semplicemente l'elemento.

// BAD: List of Optionals
List<Optional<User>> results = ...; // meaningless empty Optionals

// GOOD: List of present values only
List<User> presentUsers = maybeUsers.stream()
    .flatMap(Optional::stream)
    .collect(Collectors.toList());

// BAD: Map with Optional values
Map<String, Optional<String>> config = ...;

// GOOD: just use null or omit the key for absent values
Map<String, String> config2 = ...;
String value = config2.getOrDefault("key", "default");

Da fare: orElseGet per valori predefiniti costosi

Quando il valore predefinito richiede un calcolo (query al database, chiamata di rete), utilizzi sempre orElseGet: supplier viene chiamato solo quando necessario.

import java.util.Optional;

// BAD: buildDefault() always called, even when value is present!
String config = getConfig("timeout").orElse(buildDefault());

// GOOD: supplier called lazily only when empty
String config2 = getConfig("timeout").orElseGet(() -> buildDefault());

// Or with method reference:
String config3 = getConfig("timeout").orElseGet(this::buildDefault);

// For cheap literals, orElse is fine
String name = getConfig("name").orElse("default");

Da fare: orElseThrow per i valori obbligatori

Quando un valore mancante rappresenta un errore di programmazione o una violazione di un'invariante, utilizzi orElseThrow con un'eccezione descrittiva.

import java.util.Optional;

// Good: throw when absence is an error
User user = userRepository.findById(userId)
    .orElseThrow(() -> new UserNotFoundException("User not found: " + userId));

// Good: in validation code
String apiKey = Optional.ofNullable(System.getenv("API_KEY"))
    .orElseThrow(() -> new IllegalStateException(
        "API_KEY environment variable is required"));

System.out.println("Key found: " + apiKey.length() + " chars");

Anti-pattern: isPresent + get()

Eviti l'anti-pattern che consiste nel verificare isPresent() e poi chiamare get(). Non è migliore di un controllo su null e vanifica lo scopo di Optional.

import java.util.Optional;

Optional<String> opt = findValue();

// BAD: isPresent() + get() — no improvement over null check
if (opt.isPresent()) {
    String val = opt.get();
    process(val);
}

// GOOD: use the functional API
opt.ifPresent(this::process);

// GOOD: transform and return
return opt.map(this::process).orElse(null);

// GOOD: provide a default
String result = opt.orElse("default");

Best practice per le concatenazioni

Costruisca una catena chiara: trova → filtra → trasforma → fallback. Ogni passaggio è autoesplicativo.

import java.util.Optional;

record User(long id, String plan, boolean active) {}

static Optional<User> findUser(long id) { return Optional.empty(); }

String result = findUser(42L)
    .filter(User::active)           // keep only active users
    .filter(u -> "PRO".equals(u.plan())) // keep only PRO users
    .map(u -> "Welcome, Pro user #" + u.id()) // transform
    .orElse("Upgrade to Pro!");     // fallback

System.out.println(result); // Upgrade to Pro!

Optional nel livello dei servizi

Un esempio realistico di livello dei servizi che segue le best practice.

import java.util.Optional;

class OrderService {
    public Optional<OrderSummary> getOrderSummary(long orderId) {
        return orderRepo.findById(orderId)
            .filter(o -> !o.isCancelled())
            .map(this::toSummary);
    }

    public OrderSummary requireOrderSummary(long orderId) {
        return getOrderSummary(orderId)
            .orElseThrow(() -> new OrderNotFoundException(orderId));
    }

    private OrderSummary toSummary(Order o) { return new OrderSummary(o); }
}
// API callers choose: Optional (handle absence) or require (exception)

Optional e strumenti per la sicurezza rispetto a null

Optional completa le annotazioni @Nullable/@NonNull e strumenti come SpotBugs/NullAway, offrendo una copertura completa per la sicurezza rispetto a null.

// Annotation-based: declares intent for in-class nulls
import org.jetbrains.annotations.*;

class ProductService {
    @Nullable  // may return null — for framework/bean use
    public String getCachedName(String id) { return cache.get(id); }

    // Optional — for service API that handles absence
    public Optional<Product> findProduct(String id) {
        return repo.findById(id);
    }
}
// Use @Nullable for fields/parameters; Optional for return types

Verifica rapida

Qual è il problema del seguente codice?

if (opt.isPresent()) {
    process(opt.get());
}

Riepilogo: best practice per Optional

Punti chiave:

Utilizzi Optional solo come tipo restituito, mai come campo o parametro di metodo
Preferisca orElseGet a orElse quando il valore predefinito è costoso da calcolare
Utilizzi orElseThrow quando l'assenza rappresenta un errore di programmazione
Eviti isPresent() + get(): utilizzi invece ifPresent, map o orElse
Non inserisca mai Optional nelle collezioni: filtri invece gli stream
Costruisca catene leggibili: filter → map → orElse per un flusso dei dati chiaro

Domande Frequenti

La lezione «Buone pratiche per Optional» è gratuita?

Sì — il testo completo di «Buone pratiche per Optional» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Java Academy, passa a CoddyKit PRO. Il corso Java Academy include 4 lezioni in totale.

Cosa imparerò in «Buone pratiche per Optional»?

Applichi orElse, orElseGet e orElseThrow, evitando i più comuni anti-pattern con Optional. Eserciti Java Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Java Academy?

Non è richiesta alcuna esperienza precedente. Java Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Buone pratiche per Optional»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Java Academy?

Sì. Ogni lezione Java Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Java Academy