Item Be careful when returning options

Pre-Java 8 Approaches:

• Throw exception: reserved for exceptional situations and expensive due to stack trace capture.
• Return null: requires special code to deal with the possibility of returning null, which can cause errors such as NullPointerException.

The Java 8 approach:

• Introduction of the Optional class, an immutable container that can contain a value or be empty.
• Avoids the use of null and simplifies the handling of missing values ​​without throwing exceptions.
• Methods can return Optional to represent the absence of a value.

Advantages of using Optional:

• Avoids exceptions and problems with null.
• Allows the client to decide what to do when the value is missing (provide default value, throw exception, etc.).
• Makes code easier without the need for explicit null handling.

Useful methods of the Optional class:

• Optional.of(value): creates an Optional with a non-null value.
• Optional.ofNullable(value): creates an Optional, but accepts null values.
• orElse(value): returns a default value if Optional is empty.
• orElseThrow(): throws exception if the value is not present.
• map(), flatMap(), filter(): allow manipulation of values ​​within the Optional.

Avoid involving collections in Optional:

• For container types like lists or arrays, return empty collections instead of Optional>.

Performance considerations:

• Using Optional has a cost in terms of object allocation.
• For primitive types, use OptionalInt, OptionalLong and OptionalDouble to avoid marshaling cost.

Be careful with other uses of Optional:
Avoid using them as Map keys or values ​​or in collections.
Avoid using them as instance fields unless it makes sense, like in optional getters.

Code Examples
Example 1: Basic use of Optional

import java.util.Optional;

public class ExemploOptional {
    public static Optional<String> encontrarNome(String[] nomes, String nomeBuscado) {
        for (String nome : nomes) {
            if (nome.equalsIgnoreCase(nomeBuscado)) {
                return Optional.of(nome);
            }
        }
        return Optional.empty();  // Retorna Optional vazio se não encontrar o nome
    }

    public static void main(String[] args) {
        String[] nomes = {"João", "Maria", "Ana"};
        Optional<String> nomeEncontrado = encontrarNome(nomes, "Maria");

        nomeEncontrado.ifPresent(nome -> System.out.println("Nome encontrado: " + nome));
        System.out.println(nomeEncontrado.orElse("Nome não encontrado"));
    }
}

Example 2: Using orElseThrow

import java.util.Optional;

public class ExemploOrElseThrow {
    public static Optional<Integer> buscarIdade(String nome) {
        if (nome.equals("João")) {
            return Optional.of(30);
        }
        return Optional.empty();  // Retorna Optional vazio se o nome não for "João"
    }

    public static void main(String[] args) {
        Optional<Integer> idade = buscarIdade("Maria");

        // Lança uma exceção se o valor não estiver presente
        int valorIdade = idade.orElseThrow(() -> new IllegalArgumentException("Idade não encontrada!"));
        System.out.println("Idade: " + valorIdade);
    }
}

Example 3: Optional with primitive types

import java.util.OptionalInt;

public class ExemploOptionalInt {
    public static OptionalInt buscarIdade(String nome) {
        if (nome.equals("João")) {
            return OptionalInt.of(30);
        }
        return OptionalInt.empty();  // Retorna OptionalInt vazio se o nome não for "João"
    }

    public static void main(String[] args) {
        OptionalInt idade = buscarIdade("João");

        if (idade.isPresent()) {
            System.out.println("Idade encontrada: " + idade.getAsInt());
        } else {
            System.out.println("Idade não encontrada");
        }
    }
}

The above is the detailed content of Item Be careful when returning options. For more information, please follow other related articles on the PHP Chinese website!