Inovações do Java 8

Este é o material teórico utilizado nas aulas de Java que eu ministrei aos meus colegas de trabalho. O material original está em slides de Power Point, por isso o conteúdo está basicamente todo em bullet points.

O objetivo do treinamento foi reforçar a compreensão dos fundamentos de Java 8 por meio de aprendizado prático e aplicado.

Você pode encontrar a parte prática (código e exercícios) no post Java 8 Innovations.

Java 8: um marco na história do Java

O Java 8 é considerado um marco histórico na linguagem Java, talvez o maior desde o lançamento original.

Ele revolucionou a forma como se programa em Java, tanto no estilo de código quanto na performance e no ecossistema.

O que mudou?

• Lançado em março de 2014.
• Introdução do paradigma funcional (programação funcional):
  • Java não é uma linguagem funcional, mas passou a utilizar alguns de seus recursos.
• Incrementos em APIs internas, novas APIs, bibliotecas, mudança na JVM (compilador).

Por que mudou?

• Java é uma linguagem mais antiga.
• Era bastante popular, mas perdeu popularidade com surgimento de novas linguagens.
• Introduziram novos recursos para fazer a linguagem voltar a ganhar popularidade.

Programação funcional

• É o processo de construir software através de composição de funções puras, evitando compartilhamento de estados, dados mutáveis e efeitos colaterais.
• Proporciona mais dinamismo.
• Torna o código mais legível, mais simples, menos verborrágico.
• Proporciona ganho de performance.
• Exemplos de uso: iterar, filtrar e alterar dados em apenas uma linha, e ainda conseguir atribuir isso a uma variável, por meio de expressões lambda.

Principais adições

Lambdas

• Diminuem a quantidade de código
• São usados em classes anônimas
  • classes anônimas são um tipo especial de inner class que não possuem nome
  • são usadas, em geral, para fornecer rapidamente uma implementação de uma interface ou para estender uma classe, normalmente quando essa implementação será utilizada apenas uma única vez

Antes do Java 8 (classe anônima):

Runnable r = new Runnable() {
    @Override
    public void run() {
        System.out.println("Rodando!");
    }
};
r.run();

Depois do Java 8 (lambda):

Runnable r = () -> System.out.println("Rodando!");
r.run();

Method reference

• Acessa um método que já existe dentro da classe
• Sintaxe enxuta, com double colon

Antes do Java 8 (loop tradicional):

List<String> list = Arrays.asList("Ana", "Bruno", "Carlos");

for (String s : list) {
    System.out.println(s);
}

Depois do Java 8 (method reference):

List<String> list = Arrays.asList("Ana", "Bruno", "Carlos");

list.forEach(System.out::println);

Functional interfaces

• Interface que contém somente um método que seja abstrato
• SAM (Single Abstract Method)
• Foram criadas para dar suporte às expressões lambda e method references

Antes do Java 8 (classe anônima):

interface CheckString {
    boolean test(String s);
}

CheckString startsWithA = new CheckString() {
    @Override
    public boolean test(String s) {
        return s.startsWith("A");
    }
};

System.out.println(startsWithA.test("Apple"));

Depois do Java 8 (lambda):

Predicate<String> startsWithA = s -> s.startsWith("A");
System.out.println(startsWithA.test("Apple"));

Streams

• Fluxo de dados
• Operações intermediárias
• Operações finais

Antes do Java 8(loop tradicional):

List<String> names = Arrays.asList("Ana", "Bruno", "Carlos");
List<String> filtered = new ArrayList<>();

for (String name : names) {
    if (name.startsWith("A")) {
        filtered.add(name);
    }
}
System.out.println(filtered);

Depois do Java 8 (Streams):

List<String> names = Arrays.asList("Ana", "Bruno", "Carlos");

List<String> filtered = names.stream()
                             .filter(n -> n.startsWith("A"))
                             .toList();

System.out.println(filtered);

Optional

• Lida com valores que podem ser null

Antes do Java 8 (checando null manualmente):

String name = getName(); // pode ser null

if (name != null) {
    System.out.println(name.toUpperCase());
} else {
    System.out.println("Nome vazio");
}

Depois do Java 8 (Optional):

Optional<String> name = getNameOptional();

name.map(String::toUpperCase)
    .ifPresentOrElse(
        System.out::println,
        () -> System.out.println("Nome vazio")
    );

Date & Time

• Facilitou muito o trabalho com datas e com tempo
• Tem muitos métodos estáticos dentro das classes da API

Antes do Java 8 (java.util.Date / Calendar):

Calendar cal = Calendar.getInstance();
cal.set(2023, Calendar.DECEMBER, 25);
Date date = cal.getTime();
System.out.println(date);

Depois do Java 8 (java.time):

LocalDate date = LocalDate.of(2023, 12, 25);
System.out.println(date);

Leitura recomendada: Java Collections.