Evolução e melhorias do Java da versão 7 à 17, com exemplos

Desde sua origem, em janeiro de 1996, até os dias atuais, o Java vem se consolidando como uma linguagem robusta, segura e altamente eficiente em termos de performance, especialmente quando se trata de grandes projetos corporativos.

Criada com o objetivo de ser uma linguagem de programação simples, portátil e orientada a objetos, caiu no gosto popular devido à possibilidade de ser executada em diferentes plataformas.

Neste artigo, trago uma descrição resumida da evolução da linguagem Java, desde sua origem até os dias atuais, mostrando as principais mudanças ao longo do tempo acompanhadas com alguns exemplos de como eram feitas algumas implementações e como melhoraram ao longo do tempo.

Java 1.0 (1996):

• Conhecida como Java 1.0, a primeira versão foi lançada em janeiro de 1996 e incluía as principais características da linguagem, como orientação a objetos, tratamento de exceções, manipulação de threads e uma biblioteca básica (API) para desenvolvimento de aplicativos.

Java 1.1 (1997):

• A versão 1.1 trouxe melhorias significativas como:
• Inner Classes, que permitiam a definição de classes dentro de outras classes resultando na melhora da modularidade e organização do código Java;
• A compilação Just-In-Time (JIT), responsável por otimizar o desempenho do código Java em tempo de execução, convertendo partes do código Java (bytecode) que são executadas com mais frequência, em código nativo de máquina específico para a plataforma em que a JVM está sendo executada;
• JavaBeans, um padrão de projeto (design pattern) para a criação de componentes reutilizáveis e encapsulados.

Java 1.2 (1998):

• Conhecida como Java 2, trouxe uma série de melhorias e recursos adicionais, como:
• Swing para criação de interfaces gráficas;
• Melhorias na API de coleções com a introdução das classes java.util.Collection e java.util.Map;
• Adição do modelo de programação de eventos (event model), amplamente utilizado em interfaces gráficas de usuário (GUI), manipulação de eventos de teclado e mouse, jogos, aplicações web etc.

Java 1.3 (2000):

• A versão 1.3 trouxe melhorias de desempenho, estabilidade e escalabilidade para a plataforma Java sendo adicionados novos recursos, como:
• API Java Sound para manipulação de áudio;
• API Java Naming and Directory Interface (JNDI) para acesso a manipulação de pastas e arquivos;
• HotSpot JVM, que se tornou a JVM padrão na plataforma Java devido ao seu desempenho, otimização e recursos avançados de gerenciamento de memória.

Java 1.4 (2002):

• A versão 1.4 do Java trouxe melhorias significativas, como:
• Classe java.nio para operações de I/O não bloqueantes (I/O assíncrono);
• API assert para testes e depuração;
• API de manipulação de XML (Java API for XML Processing - JAXP);
• Classes java.util.logging para registro de log.

Java 5 (2004):

• Também conhecido como Java 1.5, representou uma das maiores evoluções da linguagem. Foram adicionados recursos importantes, como:
• Generics (tipos genéricos) para permitir a criação de classes e métodos parametrizados;
• Suporte a anotações (annotations) para fornecer metadados ao código;
• Tipos enumerados (enum);
• Classes java.util.concurrent para programação concorrente;
• AutoBox and Unbox, que permitiu conversões de tipos de dados primitivos para seus objetos equivalentes, e vice-versa, de forma automática.

Java 6 (2006):

• A versão 6 do Java trouxe melhorias de desempenho, estabilidade e segurança e alguuns outros recursos como:
• API de formatação de data e hora (java.time);
• Melhoria do suporte a web services (JAX-WS).

Java 7 (2011):

• A versão 7 do java trouxe melhorias na linguagem e na plataforma Java, como:
• Suporte a strings em switch (switch com strings);
• Melhorias na API de I/O para arquivos (java.nio.file).
• Melhorias na legibilidade de strings numéricas longas através do uso do caractere sublinhado ('_'). Ex:

Antes do Java 7.0:

Após o Java 7.0:

• Bloco try-with-resources para gerenciamento automático de recursos, permitindo que conexões de banco de dados ou fluxos de arquivos, sejam automaticamente fechados após o uso, evitando a necessidade de um bloco "finally". Ex:

Antes do Java 7.0:

Após o Java 7.0:

Java 8 (2014):

• A versão 8 do Java trouxe uma das maiores mudanças na história da linguagem. Foram adicionados recursos, como:
• Expressões lambda, que permitem escrever código funcionalmente orientado de forma mais concisa. Ex:

Antes do Java 8.0:

Após o Java 8.0:

• API de Streams. Antes, para processar coleções de dados, precisávamos usar loops tradicionais. Agora, podemos usar a API de Streams para processamento de forma paralela ou sequencial. Ex:

Antes do Java 8.0:

Após o Java 8.0:

• Melhorias na API de datas e horários (java.time);
• Interfaces funcionais (Functional Interfaces) e adição de métodos default em interfaces, permitindo uma maneira de estender interfaces existentes sem quebrar a compatibilidade com implementações antigas.

Java 9 (2017):

• A versão 9 do do Java, trouxe melhorias como:
• Módulos (Java Platform Module System - JPMS) que permitiu a modularização de grandes aplicações através do agrupamento dos códigos relacionados em um único pacote, controlando quais classes são acessíveis de fora do módulo.
• JShell: Introduziu uma ferramenta interativa de linha de comando chamada que permite escrever e executar código Java rapidamente sem a necessidade de escrever um programa completo;
• Melhorias em coleções: Introduziu novos métodos para manipulação de coleções, como takeWhile, dropWhile, ofNullable, entre outros;
• Adição de recursos de programação reativa com a API Flow.

Java 10 (março de 2018):

• A versão 10 do Java, trouxe como principal melhoria a :Inferência de tipos para variáveis locais sem a necessidade de especificar o tipo. O compilador pode inferir o tipo da expressão inicial atribuída à variável. Ex:

Antes do Java 10.0:

Após o Java 10.0:

Java 11 (setembro de 2018):

• A versão 11 do Java, trouxe como principal melhoria o uso do tipo de variável var em expressões lambda, possibilitando uma sintaxe mais concisa ao escrever lambdas com tipos complexos. Ex:

Java 12 (março de 2019):

• A versão 12 do Java, trouxe como principal melhoria as Switch Expressions, uma nova forma de escrever declarações "switch" com expressões permitindo atribuir um valor a uma variável diretamente no switch. Ex:

Antes do Java 12.0:

Após o Java 12.0:

Java 13.0 (setembro de 2019):

• A versão 13 do Java trouxe como principal melhoria a possibilidade de escrever strings em multilinha sem a necessdidade de caracteres de quebra de linha. Ex:

Antes do Java 13.0:

Após o Java 13.0:

Java 14.0 (março de 2020):

• A versão 14 do Java trouxe algumas melhorias à API de Streams.

Java 15.0 (2020)

• A versão 15 do Java trouxe, como principal implementação, a introdução do conceito de records, que são classes imutáveis e com uma sintaxe concisa para definir classes DTO (Data Transfer Object) e Value Objects. Ex:

Antes do Java 15.0:

Após o Java 15.0:

Java 16 (março de 2021):

• A versão do Java 16 trouxe como principais melhorias:
• Novos métodos adicionados à classe String, como "startsWith", "endsWith" e "stripIndent".
• A possibilidade de verificar a instância de uma variável em uma única expressão "instanceof". Ex:

Antes do Java 16.0:

Após o Java 16.0:

Java 17 (setembro de 2021):

• A versão do Java 17 trouxe melhorias e novas funcionalidades à API de concorrência, como o método "orElseThrow" para tratamento de exceções em CompletableFuture e melhorias no desempenho da classe ThreadLocalRandom.

Como podemos ver, a linguagem Java evoluiu bastante ao longo do tempo. Lógico que esse é apenas um pequeno apanhado das principais mudanças ocorridas e que trouxeram uma melhoria considerada na codificação. Atualmente, de acordo com o OpenJDK, já estão em desenvolvimento as versões superiores ao Java 17. Para acompanhamento de todas melhorias que foram e estão sendo desenvolvidas, sugiro o material abaixo.

Referências:

• Documentação do Java da Oracle: https://docs.oracle.com/en/java/
• Blog da Oracle sobre Java: https://blogs.oracle.com/java/
• Site do OpenJDK: https://openjdk.org/
• Documentação do Java no GitHub: https://github.com/openjdk/jdk/
• Usando sublinhado em literais numéricos: https://acervolima.com/usando-sublinhado-em-literais-numericos-em-java/