Só alguns poucos (6) anos atrasado, venho publicar esse post com as principais novidades do Java 8 que foi lançado em Março de 2014 através da especificação JSR 337.
Esse post é o primeiro da série onde pretendo centralizar as melhorias de cada uma das versões que vieram após o Java 7.
Lambda Expression
Também conhecida como funções anônimas, acredito que essa seja maior mudança na versão 8, as expressões lambdas podem causar estranhesa a primeira vista por quem apenas programou utilizando Java. Mas elas já são bem comuns para programadores que tiveram contato com linguagens como C#, Clojure, Go, Groovy, Javascript, Kotlin, Ruby, Scala e muitas outras.
Essas expressões facilitam a implementação dos comportamentos de inferfaces funcionais, que são aquelas interfaces que possuem apenas um único método abstrato.
Como por exemplo a clássica interface java.util.Comparator, comumente utilizada para ordenar coleções. Anteriormente precisaríamos implementar essa interface em uma classe ou instância-la como classe anonima como no exemplo abaixo:
List<String> linguagens = Arrays.asList("Java", "C#", "Php", "Html");
Comparator<String> comparadorPorTamanho = new Comparator() {
public int compare(String s1, String s2) {
return Integer.compare(s1.length(), s2.length());
}};
Collections.sort(linguagens, comparadorPorTamanho);
Agora abaixo um código equivalente ao de cima, substituindo a instanciação da classe anonima pela expressão lambda:
List<String> linguagens = Arrays.asList("Java", "C#", "Php", "Html");
Comparator<String> comparadorPorTamanho = (s1, s2) -> Integer.compare(s1.length(), s2.length());
Collections.sort(linguagens, comparadorPorTamanho);
Podemos fazer uma versão mais enxuta ainda, passando a expressão lambda direto como argumento para o método sort:
List <String> linguagens = Arrays.asList("Java", "C#", "Php", "Html");
Collections.sort(linguagens, (s1, s2) -> Integer.compare(s1.length(), s2.length()));
Detalhando um pouco mais a sintaxe da expressão lambda apresentada:
(s1, s2) -> Integer.compare(s1.length(), s2.length())
É iniciada com a declaração dos parametros do método que estamos implementando. O método da interface Comparator aguarda 2 parametros do tipo String, a tipagem dos parâmetros é opcional, já que temos apenas um único método na interface, o compilador ja sabe com quais tipos ele está lidando, por isso declaramos apenas o nome que desejamos para as variáveis:
(s1, s2) ...
Se o método aguardasse apenas 1 parametro, então declaramos somente o nome do parametro, sendo que neste cenário os parênteses passam a ser opcionais.
s1 ...
Caso o método não tivesse parametros, seria declarado com parenteses vazios:
() ...
Após a declaração dos parametros colocamos o arrow token, que é composto por um hífen, seguido por um sinal de maior (->):
(s1, s2) -> ...
Em seguida devemos colocar o conteúdo do nosso método, no exemplo que estamos utilizando é { return Integer.compare(s1.length(), s2.length()); }, como o nosso corpo é simples e tem apenas uma única linha (instrução), podemos suprimir as chaves, o return e o ponto e vírgula (;), pois nesse caso tornan-se opcionais:
(s1, s2) -> Integer.compare(s1.length(), s2.length())
Caso o nosso conteúdo fosse ‘mais complexo’, com mais de uma linha (instrução), necessitaríamos da utilização das chaves, do return (caso o método não seja void, claro :D) e do ponto e vírgula (;) no final de cada comando, como por exemplo:
(s1, s2) -> {
// imagine qualquer comando aqui
int resultado = Integer.compare(s1.length(), s2.length());
// imagine qualquer comando aqui
return resultado;
}
Ordenando Collections
Como vimos no exemplo acima, ordenavamos nossas coleções utilizando o método utiitário Collections.sort (Classe), agora no java 8 temos outra maneira mais simples de efetuar tal ação, temos o método Collection.sort (Interface), que espera como parâmetro apenas um Comparator compatível com o tipo da lista, o qual está disponível em todas as nossas coleções, como por exemplo na interface List.
List<String> linguagens = Arrays.asList("Java", "C#", "Php", "Html");
linguagens.sort((s1, s2) -> Integer.compare(s1.length(), s2.length()));
A interface Comparator ganhou um método estático (sim! agora é possível :D) Comparator.comparing, que facilitar a criação de uma instância de um comparador simples:
List<String> linguagens = Arrays.asList("Java", "C#", "Php", "Html");
linguagens.sort(Comparator.comparing(s -> s.length()));
Podemos simplificar ainda mais com outra novidade, o Method Reference, que nos permite fazer referência a um método específico de uma classe:
List<String> linguagens = Arrays.asList("Java", "C#", "Php", "Html");
linguagens.sort(Comparator.comparing(String::length));
Novos métodos nas Collections
Nas nossas coleções tivemos algumas mudanças, ganhamos diversos métodos novos como o Collection.sort visto acima, muitos deles esperam com parâmetro implementações de interfaces funcionais (assunto que veremos a seguir), segue mais alguns:
Iterable.forEach(Consumer)
Iterator.forEachRemaining(Consumer)
Collection.removeIf(Predicate)
Collection.spliterator()
Collection.stream()
Collection.parallelStream()
List.sort(Comparator)
List.replaceAll(UnaryOperator)
Map.forEach(BiConsumer)
Map.replaceAll(BiFunction)
Map.putIfAbsent(K, V)
Map.remove(Object, Object)
Map.replace(K, V, V)
Map.replace(K, V)
Map.computeIfAbsent(K, Function)
Map.computeIfPresent(K, BiFunction)
Map.compute(K, BiFunction)
Map.merge(K, V, BiFunction)
Map.getOrDefault(Object, V)
Interface
Ocorreram melhorias também nas interfaces, como a possibilidade de declarar métodos concretos, chamados de Default Method, fazendo com que as interfaces tenham uma grande similaridade com as classes abstratas, que até então eram um meio termo entre interfaces e classes concretas. Esse tipo de método necessita do operador default em sua declaração.
Solução criada para possibilitar a evolução das interfaces já existentes, assim quando criarmos novos métodos em interfaces que já estão em uso, essas alterações não irão causar erros de compilação nas outras interfaces e/ou classes que as implementam.
Por exemplo, o novo método sort da interface List:
default void sort(Comparator<? super E> c) {
Collections.sort(this, c);
}
Outra novidade também, como vimos na interface Comparator.comparing, agora podemos declarar métodos estáticos, o que não era possível anteriormente:
Interfaces funcionais
Como ja vimos no começo do post, inferfaces funcionais, que são aquelas interfaces que possuem apenas um único método abstrato.
Antes dessa nova versão ja tinhamos outras interfaces funcionais, é isso mesmo! Um exemplo seria a interface Runnable, que é implementada pela famosa classe Thread.
Agora as interfaces funcionais ganharam mais destaque, e também novas interfaces localizadas no pacote java.util.function:
Function<T, R> − recebe T como entrada, retorna R como saída;
Predicate<T> − recebe T como entrada, retorna um valor booleano como saída;
Consumer<T> − recebe T como entrada, não retorna nada como saída;
Supplier<T> − não recebe entrada, retorna T como saída;
BinaryOperator<T> − recebe duas entradas T, retorna um T como saída.
Também temos uma nova anotação @FunctionalInterface, que deve ser utilizada para indicar que uma interface é funcional. O que obriga o compilador a verificar se existe apenas um método declarado na interface. Em caso negativo, ocorrerá um erro de compilação. Todas as antigas interfaces que são consideradas funcionais, receberam essa anotação.
Optional
Nova classe que nos ajuda a evitar a má prática de retornar null em nosso métodos, e espalhar comparações do tipo if (resultado != null), deixando o nosso código muito mais elegante. Estamos falando da classe java.util.Optional que usufrui de Generics, possibilitando uma codificação tipada. Segue algumas maneira de aplica-la:
Retornando resutado não-nulo:
public Optional<String> buscar() {
String resultado = "XPTO";
return Optional.of(resultado);
}
Retornando resutado que é vazio, antigo return null:
public Optional<String> buscar() {
return Optional.empty();
}
Retornando resultado que tem a possibilidade de ser nulo:
public Optional<String> buscar() {
String resultado = null;
return Optional.ofNullable(resultado);
}
Internamente o método acima verifica o parametro passado e decide se prossegue com o método of ou empty.
Agora segue alguns exemplos do lado de quem recebeu o Optional como retorno, como o utilizamos:
Verificando se temos um resultado preenchido:
Optional<String> opt = buscar();
boolean preenchido = opt.isPresent();
Obtendo o resultado encapsulado, devemos verificar com o método isPresent para evitar receber uma exceção:
Optional<String> opt = buscar();
String resultadoEsperado = opt.get();
Se o resultado estiver presente, você pode ja passar uma função para consumi-lo:
Optional<String> opt = buscar();
opt.ifPresent(r -> System.out.println(r));
Você ja pode deixar seu código preparado para receber outro valor caso o resutado não esteja presente:
Optional<String> opt = buscar();
String outroResultado = opt.orElse("Vazio!");
Lançando exceção caso o resutado não esteja presente:
Optional<String> opt = buscar();
opt.orElseThrow(IllegalStateException::new);
Stream
Uma grande novidade que nos ajuda muito no dia a dia, é o pacote java.util.stream, que nos possibilita uma programação no estilo funcional. Simplificando a forma de iterar, filtrar, transformar, consolidar e coletar os dados.
A forma mais comum de ter acesso a uma instância de Stream é através de collections já populadas, através do método Collection.stream, que nos devolve uma instância de java.util.stream.Stream, possibilitando o uso de uma infinidade de métodos que esperam como parâmetro a implementação de diversas interfaces funcionais (ex.: as que mostramos acima) de acordo com o tipo de operação.
Iterando (ex.: Imprimindo as linguagens):
List<String> linguagens = Arrays.asList("Java", "C#", "Php", "Html");
linguagens.stream()
.forEach( l -> System.out.println("Imprimindo linguagem "+l ));
Obs.: Também podemos ter acesso a esse método de forma mais prática, diretamente na coleção com Iterable.forEach.
Transformando (ex.: Obtendo as iniciais de cada linguagem):
List<String> linguagens = Arrays.asList("Java", "C#", "Php", "Html");
List<Character> iniciais = linguagens.stream()
.map(l -> l.charAt(0))
.collect(Collectors.toList());
Nesse exemplo fizemos chamadas sequenciais/encadeadas de 2 métodos, o map e o collect, onde um faz a transformação de cada objeto e o outro é responsável por obter o resultado da operação anterior.
Ordenando (ex.: Ordem alfabetica)
List<String> linguagens = Arrays.asList("Java", "C#", "Php", "Html");
List<String> novaListaOrdenada = linguagens.stream()
.sorted(Comparator.comparing(String::toString))
.collect(Collectors.toList());
Nesse exemplo ordenamos com sorted e em seguida obtivemos a lista ordenada com o collect.
Removendo duplicados
List<Integer> numeros = Arrays.asList(1, 1, 2, 3, 4, 4, 5);
numeros.stream()
.distinct()
.forEach(n -> System.out.println(n));
Removemos os duplicados através do distinct, o qual se utiliza do método equals do objeto para distinguir os valores, e para variar, não coletamos o resutado, e sim, imprimimos cada um deles com o forEach.
Filtrando (ex.: Linguagens que começam com “J”)
List<String> linguagens = Arrays.asList("Java", "C#", "JavaScript", "Html");
linguagens.stream()
.filter(l -> l.startsWith("J"))
.forEach(l -> System.out.println(l));
Filtramos utilizando o filter e imprimimos utilizando forEach.
Temos muitas outras possibilidades para trabalhar com Stream, para descobrir todas elas, basta dar uma olhada na documentação oficinal 😀
Também temos Streams para trabalhar com tipos primitivos, como IntStream, LongStream e DouleStream, que nos oferecem métodos específicos para trabalhar com números, como average, sum, reduce e muito mais.
Além de tudo isso, podemos efetuar esses processamentos de forma paralela de maneira bem simples, com o uso do método Collection.parallelStream ao invés de Collection.stream, possibilitando um possível ganho de performance.
Datas e horas
Finalmente ganhamos uma nova API para trabalhar com data e hora, baseada no JodaTime, o JodaTime ja era uma biblioteca bastante utilizada pelos desenvolvedores, agora nossa vida será muito mais fácil quando o assunto for lidar com data e hora.
As antigas classes java.util.Date, java.sql.Date, java.util.GregorianCalendar e cia, dão espaço para as classes dos pacotes java.time, como por exemplo LocalDate para trabalhar apenas com data, LocalTime para trabalhar apenas com horas, LocalDateTime para trabalhar com data e hora. Também temos a classe java.time.format.DateTimeFormatter para ajudar na formatação e muitas outras.
Segue um breve exemplo do uso das classes citadas:
System.out.println("Hoje: " + LocalDate.now());
System.out.println("Agora: " + LocalTime.now());
LocalDate nascimento = LocalDate.of(1989, Month.MAY, 22);
System.out.println("Nascimento: " + nascimento);
String nascimentoFormatado = nascimento.format(DateTimeFormatter.ofPattern("dd/MM/yy"));
System.out.println("Nascimento formatado: " + nascimentoFormatado);
A nova API tem muitas classes e muitos métodos, não irei abordar tudo aqui pois não é o intuito desse post. Para ver todas as funcionalidades dê uma olhadinha nesse post da oracle!
Essas classes ja são suportadas pelo JDBC e JPA, então você pode mapear seu modelo utilizando-as sem medo! 😀
Outras mudanças
Melhorias na própria JVM relacionado ao uso da memória disponível (Metaspace);
Melhorias na API de Concorrência;
Melhorias na API de IO/NIO;
Melhorias para trabalhar com Reflection;
Nova implementação para utilizar JavaScript dentro do Java: Nashhorn;
Nova implementações para unir Strings como o método String.join e a classe java.util.StringJoiner;
Conexão com Banco de dados via JDBC-ODBC foi removida;
Não roda no Windows XP;
Fontes:
Caelum, Matera, Feltex, Infoq, Oracle – Docs, Oracle – Specs, Wikipedia
