Qual é o objetivo da aula opcional de Guava

Recentemente li sobre isso e vi pessoas usando essa classe, mas em quase todos os casos, usar nulltambém funcionaria - se não de forma mais intuitiva. Alguém pode dar um exemplo concreto de onde Optionalconseguiria algo que nullnão poderia ou de uma forma muito mais limpa? A única coisa que posso pensar é em usá-lo com chaves Mapsque não aceitam null, mas mesmo isso poderia ser feito com um "mapeamento" lateral do valor de null. Alguém pode me fornecer um argumento mais convincente? Obrigado.

Membro da equipe Guava aqui.

Provavelmente, a maior desvantagem de nullé que não é óbvio o que deveria significar em qualquer contexto: ele não tem um nome ilustrativo. Nem sempre é óbvio que nullsignifica "nenhum valor para este parâmetro" - diabos, como um valor de retorno, às vezes significa "erro", ou mesmo "sucesso" (!!), ou simplesmente "a resposta correta não é nada". Optionalé frequentemente o conceito que você realmente quer dizer quando torna uma variável anulável, mas nem sempre. Quando não for, recomendamos que você escreva sua própria classe, semelhante a, Optionalmas com um esquema de nomenclatura diferente, para deixar claro o que você realmente quer dizer.

Mas eu diria que a maior vantagem de Optionalnão está na legibilidade: a vantagem é sua prova de idiota. Ele força você a pensar ativamente sobre o caso ausente se você deseja que seu programa compile, já que você tem que desembrulhar ativamente o Optionale resolver esse caso. Null torna perturbadoramente fácil simplesmente esquecer as coisas e, embora FindBugs ajude, não acho que resolva o problema tão bem. Isso é especialmente relevante quando você retorna valores que podem ou não estar "presentes". Você (e outros) são muito mais propensos a esquecer que other.method(a, b)poderia retornar um nullvalor do que é provável que você se esqueça de que apoderia ser nullquando você está implementando other.method. RetornandoOptional torna impossível para os chamadores esquecerem esse caso, uma vez que eles próprios precisam desembrulhar o objeto.

Por esses motivos, recomendamos que você use Optionalcomo um tipo de retorno para seus métodos, mas não necessariamente em seus argumentos de método.

(A propósito, isso é totalmente baseado na discussão aqui ).

Realmente se parece com o Maybepadrão Monad de Haskell.

Você deve ler o seguinte, Wikipedia Monad (programação funcional) :

E leia Do Opcional à Mônada com Goiaba no Blog de Kerflyn, que discute sobre o Opcional da Goiaba usada como Mônada:

Edit: Com Java8, há um opcional embutido que possui operadores monádicos como flatMap. Este tem sido um assunto controverso, mas finalmente foi implementado.

Consulte http://www.nurkiewicz.com/2013/08/optional-in-java-8-cheat-sheet.html

public Optional<String> tryFindSimilar(String s)  //...

Optional<Optional<String>> bad = opt.map(this::tryFindSimilar);
Optional<String> similar =       opt.flatMap(this::tryFindSimilar);

O flatMapoperador é essencial para permitir operações monádicas e permite encadear facilmente chamadas que retornem resultados opcionais.

Pense nisso, se você usasse o mapoperador 5 vezes, acabaria com um Optional<Optional<Optional<Optional<Optional<String>>>>>, enquanto o uso flatMapdaria a vocêOptional<String>

Desde Java8 eu prefiro não usar Guava's Optional que é menos poderoso.

Um bom motivo para usá-lo é que torna seus valores nulos muito significativos. Em vez de retornar um nulo que pode significar muitas coisas (como erro, falha ou vazio, etc), você pode colocar um 'nome' em seu nulo. Veja este exemplo:

vamos definir um POJO básico:

class PersonDetails {

String person;
String comments;

public PersonDetails(String person, String comments) {
    this.person = person;
    this.comments = comments;
}

public String getPerson() {
    return person;
}


public String getComments() {
    return comments;
}

}

Agora vamos usar este POJO simples:

public Optional<PersonDetails> getPersonDetailstWithOptional () {

  PersonDetails details = null; /*details of the person are empty but to the caller this is meaningless,
  lets make the return value more meaningful*/


    if (details == null) {
      //return an absent here, caller can check for absent to signify details are not present
        return Optional.absent();
    } else {
      //else return the details wrapped in a guava 'optional'
        return Optional.of(details);   
    }
}

Agora vamos evitar o uso de nulo e fazer nossas verificações com Opcional para que seja significativo

public void checkUsingOptional () {

    Optional<PersonDetails> details = getPersonDetailstWithOptional();

    /*below condition checks if persons details are present (notice we dont check if person details are null,
    we use something more meaningful. Guava optional forces this with the implementation)*/
    if (details.isPresent()) {

      PersonDetails details = details.get();

        // proceed with further processing
        logger.info(details);

    } else {
        // do nothing
        logger.info("object was null"); 
    }

    assertFalse(details.isPresent());
}

portanto, no final, é uma maneira de tornar os nulos significativos e menos ambigüos.

A vantagem mais importante de Optional é que ele adiciona mais detalhes ao contrato entre o implementador e o responsável pela chamada de uma função. Por esse motivo, é útil para parâmetros e tipo de retorno.

Se você fizer a convenção de sempre ter Optionalpara possíveis objetos nulos, você adicionará mais esclarecimentos a casos como:

1. Optional<Integer> maxPrime(Optional<Integer> from, Optional<Integer> to)

   O contrato aqui especifica claramente que há uma chance de um resultado não ser retornado, mas também mostra que funcionará com frome tocomo ausente.

2. Optional<Integer> maxPrime(Optional<Integer> from, Integer to)

   O contrato especifica que de é opcional, portanto, um valor ausente pode ter um significado especial, como começar de 2. Posso esperar que um valor nulo para o toparâmetro lance uma exceção.

Portanto, a parte boa de usar Optional é que o contrato se tornou descritivo (semelhante à @NotNullanotação), mas também formal, uma vez que você deve escrever código .get()para lidar com ele Optional.