Tudo parece certo, mas esse código pode ser bastante problemático. A simples ausência de algum desses valores pode resultar no tão frequente NullPointerException. Claro, você pode contornar esse problema de diversas formas, como por exemplo inicializar suas listas ou sempre verificar que os valores são diferentes de antes de fazer qualquer operação com eles.
Autor(a)
rodrigo.turini
Inscreva-se em nossa Newsletter
Fique por dentro de conteúdos, insights e oportunidades do universo tech. Receba novidades e lançamentos direto no seu e-mail.
null
Nosso código pode ficar parecido com:
List<Matricula> matriculas = turma.getMatriculas();
for (Matricula matricula : matriculas) { if (matricula.getCurso() != null) { System.out.println(matricula.getCurso().getNome()); } }
Nada mal, mas e os outros atributos? A quantidade de ifs perdidos pelo nosso código para fazer esse tipo de verificação só tende a aumentar, isso faz com que ele fique cada vez mais ilegível e difícil de manter. E esse nem é o pior dos problemas, esquecer de fazer uma verificação como essa é um risco muito grande... em algum momento isso vai acontecer e você receberá um NullPointerException.
Como resolver o problema? A mais nova versão do Java nos prove uma forma muito mais interessante de representar esses atributos que podem ou não estar presentes em nosso código, utilizando o java.util.Optional.
Você pode pensar em um Optional como uma classe que pode ou não conter um valor não nulo. Repare como fica o código da classe Matricula declarando o atributo Curso como Optional:
publicclassMatricula {
private Optional<Curso> curso = Optional.empty();
// outros atributos, getters e setters }
Utilizamos o factory method empty para criar e inicializar o atributo com um Optional vazio. Há outras formas de se criar um Optional, você pode por exemplo utilizar seu método of:
Mas é importante saber que caso o valor da variável algumCurso seja null, esse código irá lançar um NullPointerException. Para evitar isso podemos utilizar o método ofNullable:
Agora que o método getCurso retorna um Optional, precisamos chamar seu método get para recuperar o curso que esse Optional está guardando:
for (Matricula matricula : matriculas) { if (matricula.getCurso() != null) { System.out.println(matricula.getCurso().get().getNome()); } }
Mas dessa forma, se o curso não existir vamos receber um java.util.NoSuchElementException: No value present. Como prevenir isso? Uma das possíveis formas seria verificando se o valor desse Optional está presente, algo como:
Bem mais interessante, não acha? Esse é um dos vários métodos funcionais que essa classe possui. O método ifPresent recebe um Consumer que pode ser traduzido em uma expressão lambda c -> System.out.println(c.getNome()). Mas note que você não precisa se preocupar com nenhum desses detalhes, não importa o nome da interface funcional por traz desse código, não importa o nome de seu único método, tudo que importa nesse momento é a expressão: tenho um curso e quero imprimir seu nome.
Se você está se perguntando, podemos sim fazer o for da maneira nova! Utilizando o já conhecido forEach:
Quer mais? Considere que a classe Curso possui uma descrição (String). É comum escrever um código parecido com esse para mostrar a descrição ou alguma outra mensagem caso ela não esteja presente:
Resolvemos o problema, mas o código não está nem um pouco legível!
Para evitar esse encadeamento desnecessário, podemos utilizar o método map para fazer uma projeção do curso para sua descrição. Isso mesmo, assim como o Stream, um Optional também possui o método map! Vamos ver o resultado:
Pois é... o map vai nos retornar um Optional>. Ainda não é o que estamos esperando. Se você já conhece a API de Streams ou programa com alguma linguagem funcional, já deve ter pensado em uma solução. Sim, o Optional também possui o método flatMap! Utilizando esse método podemos achatar o Optional> para um Optional com a descrição:
Estamos quase lá. Para imprimir a descrição apenas quando ela não for vazia, podemos utilizar o método filter seguido pelo ifPresent que já conhecemos:
