prominent java 8 features with code examples
Uma lista abrangente e uma explicação de todos os recursos proeminentes introduzidos na versão Java 8 com exemplos:
O lançamento do Java 8 da Oracle foi um lançamento revolucionário da plataforma de desenvolvimento nº 1 do mundo. Ele incluiu uma grande atualização do modelo de programação Java como um todo, juntamente com a evolução da JVM, linguagem Java e bibliotecas de maneira coordenada.
Esta versão inclui vários recursos para facilidade de uso, produtividade, programação poliglota aprimorada, segurança e desempenho geral aprimorado.
O que você aprenderá:
- Recursos adicionados à versão Java 8
- Interfaces funcionais e expressões lambda
- Método forEach () na interface iterável
- Aula Opcional
- Métodos padrão e estáticos em interfaces
- Referências de Método
- Java Stream API para operações de dados em massa em coleções
- API Java Date Time
- Motor Rhinoceros JavaScript
- Decodificação de codificação Base64
- Melhorias na API de coleta
- Alterações / aprimoramentos da API de simultaneidade
- Melhorias Java IO
- Aprimoramentos diversos da API principal
- Conclusão
Recursos adicionados à versão Java 8
Entre as principais mudanças, a seguir estão os recursos notáveis que foram adicionados a esta versão.
- Interfaces Funcionais e expressões lambda
- Método forEach () na interface Iterable
- Aula opcional,
- métodos padrão e estáticos em interfaces
- Referências de método
- Java Stream API para operações de dados em massa em coleções
- API Java Date Time
- Melhorias na API de coleta
- Melhorias na API de simultaneidade
- Melhorias Java IO
- Motor Rhinoceros JavaScript
- Decodificação de codificação Base64
- Diversas melhorias na API principal
Neste tutorial, discutiremos cada um desses recursos brevemente e tentaremos explicar cada um deles com a ajuda de exemplos simples e fáceis.
Interfaces funcionais e expressões lambda
Java 8 apresenta uma anotação conhecida como @FunctionalInterface, que geralmente é para erros no nível do compilador. Normalmente é usado quando a interface que você está usando viola os contratos de interface funcional.
Como alternativa, você pode chamar uma interface funcional como interface SAM ou interface Single Abstract Method. Uma interface funcional permite exatamente um “método abstrato” como seu membro.
Abaixo, está um exemplo de Interface Funcional:
@FunctionalInterface public interface MyFirstFunctionalInterface { public void firstWork(); }
Você pode omitir a anotação @FunctionalInterface e sua interface funcional ainda será válida. Usamos essa anotação apenas para informar ao compilador que a interface terá um único método abstrato.
Observação: Por definição, os métodos padrão são não abstratos e você pode adicionar quantos métodos padrão desejar na interface funcional.
Em segundo lugar, se uma interface tem um método abstrato que substitui um dos métodos públicos de “java.lang.object”, então ele não é considerado o método abstrato da interface.
A seguir está um exemplo de interface funcional válido.
@FunctionalInterface public interface FunctionalInterface_one { public void firstInt_method(); @Override public String toString(); //Overridden from Object class @Override public boolean equals(Object obj); //Overridden from Object class }
Uma Expressão Lambda (ou função) pode ser definida como uma função anônima (uma função sem nome e um identificador). As expressões lambda são definidas exatamente no local onde são necessárias, geralmente como um parâmetro para alguma outra função.
De uma perspectiva diferente, as expressões lambda expressam instâncias de Interfaces Funcionais (descrito acima). As expressões lambda implementam a única função abstrata presente na interface funcional e, portanto, implementam interfaces funcionais.
A sintaxe básica de uma Expressão Lambda é:
Um exemplo básico da Expressão Lambda é:
A expressão acima usa dois parâmetros xey e retorna sua soma x + y. Com base no tipo de dados de x e y, o método pode ser usado várias vezes em vários lugares. Assim, os parâmetros xey corresponderão a int ou Integer e string e, com base no contexto, adicionará dois inteiros (quando os parâmetros forem int) ou concatará as duas strings (quando os parâmetros são uma string).
Vamos implementar um programa que demonstra expressões Lambda.
interface MyInterface { void abstract_func(int x,int y); default void default_Fun() { System.out.println('This is default method'); } } class Main { public static void main(String args[]) { //lambda expression MyInterface fobj = (int x, int y)->System.out.println(x+y); System.out.print('The result = '); fobj.abstract_func(5,5); fobj.default_Fun(); } }
Resultado:
O programa acima mostra o uso da Expressão Lambda para adicionar aos parâmetros e exibe sua soma. Em seguida, usamos isso para implementar o método abstrato “abstract_fun” que declaramos na definição da interface. O resultado de chamar a função “abstract_fun” é a soma dos dois inteiros passados como parâmetros ao chamar a função.
Aprenderemos mais sobre Expressões Lambda posteriormente neste tutorial.
Método forEach () na interface iterável
Java 8 introduziu um método “forEach” na interface java.lang.Iterable que pode iterar sobre os elementos da coleção. “ForEach” é um método padrão definido na interface Iterable. É usado pelas classes Collection que estendem a interface Iterable para iterar elementos.
O método “forEach” usa a Interface Funcional como um único parâmetro, ou seja, você pode passar a Expressão Lambda como um argumento.
Exemplo do método forEach ().
importjava.util.ArrayList; importjava.util.List; public class Main { public static void main(String[] args) { List subList = new ArrayList(); subList.add('Maths'); subList.add('English'); subList.add('French'); subList.add('Sanskrit'); subList.add('Abacus'); System.out.println('------------Subject List--------------'); subList.forEach(sub -> System.out.println(sub)); } }
Resultado:
Portanto, temos uma coleção de assuntos, ou seja, subList. Exibimos o conteúdo da subList usando o método forEach que usa a expressão Lambda para imprimir cada elemento.
Aula Opcional
Java 8 introduziu uma classe opcional no pacote “java.util”. “Opcional” é uma classe final pública e é usada para lidar com NullPointerException no aplicativo Java. Usando Opcional, você pode especificar códigos ou valores alternativos a serem executados. Ao usar Optional, você não precisa usar muitas verificações de nulos para evitar nullPointerException.
Você pode usar a classe Opcional para evitar o encerramento anormal do programa e impedir que o programa trave. A classe opcional fornece métodos que são usados para verificar a presença de valor para uma determinada variável.
O programa a seguir demonstra o uso da classe Opcional.
import java.util.Optional; public class Main{ public static void main(String[] args) { String[] str = new String[10]; OptionalcheckNull = Optional.ofNullable(str[5]); if (checkNull.isPresent()) { String word = str[5].toLowerCase(); System.out.print(str); } else System.out.println('string is null'); } }
Resultado:
Neste programa, usamos a propriedade “ofNullable” da classe Optional para verificar se a string é nula. Se for, a mensagem apropriada é impressa para o usuário.
Métodos padrão e estáticos em interfaces
No Java 8, você pode adicionar métodos na interface que não são abstratos, ou seja, você pode ter interfaces com implementação de método. Você pode usar as palavras-chave Default e Static para criar interfaces com implementação de método. Os métodos padrão ativam principalmente a funcionalidade Lambda Expression.
Usando métodos padrão, você pode adicionar novas funcionalidades às suas interfaces em suas bibliotecas. Isso garantirá que o código escrito para as versões anteriores seja compatível com essas interfaces (compatibilidade binária).
Vamos entender o método padrão com um exemplo:
import java.util.Optional; interface interface_default { default void default_method(){ System.out.println('I am default method of interface'); } } class derived_class implements interface_default{ } class Main{ public static void main(String[] args){ derived_class obj1 = new derived_class(); obj1.default_method(); } }
Resultado:
Temos uma interface chamada “interface_default” com o método default_method () com uma implementação padrão. A seguir, definimos uma classe “associated_class” que implementa a interface “interface_default”.
Observe que não implementamos nenhum método de interface nesta classe. Em seguida, na função principal, criamos um objeto da classe “associated_class” e chamamos diretamente o “default_method” da interface sem ter que defini-lo na classe.
Este é o uso de métodos padrão e estáticos na interface. No entanto, se uma classe deseja personalizar o método padrão, você pode fornecer sua própria implementação substituindo o método.
Referências de Método
O recurso de referência de método introduzido em Java 8 é uma notação abreviada para expressões Lambda para chamar um método de Interface Funcional. Portanto, cada vez que você usa uma Expressão Lambda para referir-se a um método, pode substituir sua Expressão Lambda pela referência de método.
Exemplo de referência do método.
import java.util.Optional; interface interface_default { void display(); } class derived_class{ public void classMethod(){ System.out.println('Derived class Method'); } } class Main{ public static void main(String[] args){ derived_class obj1 = new derived_class(); interface_default ref = obj1::classMethod; ref.display(); } }
Resultado:
Neste programa, temos uma interface “interface_default” com um método abstrato “display ()”. Em seguida, há uma classe “classe derivada” que possui um método público “método de classe” que imprime uma mensagem.
Na função principal, temos um objeto para a classe, e então temos uma referência à interface que faz referência a um método de classe “classMethod” através de obj1 (objeto de classe). Agora, quando a exibição do método abstrato é chamada por referência de interface, o conteúdo de classMethod é exibido.
Java Stream API para operações de dados em massa em coleções
A API de fluxo é outra mudança importante introduzida no Java 8. A API de fluxo é usada para processar a coleção de objetos e suporta um tipo diferente de iteração. Um Stream é uma sequência de objetos (elementos) que permite que você canalize diferentes métodos para produzir os resultados desejados.
Um fluxo não é uma estrutura de dados e recebe sua entrada de coleções, matrizes ou outros canais. Podemos canalizar várias operações intermediárias usando Streams e as operações do terminal retornam o resultado. Discutiremos a API de fluxo em mais detalhes em um tutorial Java separado.
API Java Date Time
Java 8 apresenta uma nova API de data e hora no pacote java.time.
As classes mais importantes entre eles são:
- Local: API de data e hora simplificada sem complexidade de manuseio de fuso horário.
- Zoneado: API de data e hora especializada para lidar com vários fusos horários.
datas
A classe de data tornou-se obsoleta no Java 8.
A seguir estão as novas classes introduzidas:
- A classe LocalDate define uma data. Não tem representação de hora ou fuso horário.
- The LocalTime aula define um tempo. Não tem representação para data ou fuso horário.
- A classe LocalDateTime define uma data e hora. Não tem representação de um fuso horário.
Para incluir informações de fuso horário com funcionalidade de data, você pode usar o Lambda que fornece 3 classes, ou seja, OffsetDate, OffsetTime e OffsetDateTime. Aqui, a diferença de fuso horário é representada usando outra classe - “ZoneId”. Cobriremos esse tópico em detalhes nas partes posteriores desta série Java.
Motor Rhinoceros JavaScript
Java 8 introduziu um mecanismo muito melhorado para JavaScript, ou seja, Nashorn que substitui o Rhino existente. O Nashorn compila diretamente o código na memória e então passa o bytecode para a JVM, melhorando assim o desempenho em 10 vezes.
Nashorn apresenta uma nova ferramenta de linha de comando - jjs que executa código JavaScript no console.
Vamos criar um arquivo JavaScript ‘sample.js’ que contém o código a seguir.
print (‘Hello, World!!’);
Dê o seguinte comando no console:
C: Java jjs sample.js
Resultado: Olá Mundo!!
Também podemos executar programas JavaScript no modo interativo e também fornecer argumentos para os programas.
Decodificação de codificação Base64
No Java 8, há codificação e decodificação embutidas para codificação Base64. A classe para codificação Base64 é java.util.Base64.
Esta classe fornece três codificadores e decodificadores Base64:
- Básico: Neste, a saída é mapeada para um conjunto de caracteres entre A-Za-z0-9 + /. Nenhuma alimentação de linha é adicionada à saída pelo codificador e o decodificador rejeita qualquer caractere diferente do acima.
- URL: Aqui, a saída é a URL e o nome do arquivo seguro é mapeado para o conjunto de caracteres entre A-Za-z0-9 + /.
- MIME: Nesse tipo de codificador, a saída é mapeada para um formato compatível com MIME.
Melhorias na API de coleta
Java 8 adicionou os seguintes novos métodos à API Collection:
- forEachRemaining (ação do consumidor): este é um método padrão e é para o iterador. Ele executa a “ação” para cada um dos elementos restantes até que todos os elementos sejam processados ou a “ação” lance uma exceção.
- O método padrão para a coleção removeIf (filtro de predicado): Remove todos os elementos da coleção que satisfazem o “filtro” fornecido.
- Spliterator (): Este é um método de coleta e retorna a instância do divisor que você pode usar para percorrer os elementos de forma sequencial ou paralela.
- A coleção de mapas tem os métodos replaceAll (), compute () e merge ().
- A classe HashMap com colisões de chave foi aprimorada para aprimorar o desempenho.
Alterações / aprimoramentos da API de simultaneidade
A seguir estão as melhorias importantes na API simultânea:
- ConcurrentHashMap é aprimorado com os seguintes métodos:
- compute (),
- para cada (),
- forEachEntry (),
- forEachKey (),
- forEachValue (),
- vai (),
- reduzir () e
- procurar ()
- O método “newWorkStealingPool ()” para executores cria um pool de threads de roubo de trabalho. Ele usa os processadores disponíveis como seu nível de paralelismo de destino.
- O método “completableFuture” é aquele que podemos concluir explicitamente (definindo seu valor e status).
Melhorias Java IO
As melhorias de IO feitas no Java 8 incluem:
- Files.list (caminho dir): Isso retorna um fluxo populado jlazily, em que cada elemento é a entrada no diretório.
- Files.lines (caminho do caminho): Lê todas as linhas de um fluxo.
- Files.find (): Pesquisa por arquivos na árvore de arquivos com raiz em um determinado arquivo inicial e retorna um fluxo preenchido por um caminho.
- BufferedReader.lines (): Retorna um stream com todos os seus elementos conforme as linhas lidas do BufferedReader.
Aprimoramentos diversos da API principal
Temos as seguintes melhorias na API mista:
- Método estático withInitial (fornecedor fornecedor) de ThreadLocal para criar instância facilmente.
- A interface “Comparator” é estendida com os métodos padrão e estáticos para ordenação natural em ordem reversa etc.
- As classes de invólucro inteiro, longo e duplo possuem os métodos min (), max () e sum ().
- A classe booleana é aprimorada com os métodos logicalAnd (), logicalOr () e logicalXor ().
- Vários métodos utilitários são introduzidos na classe Math.
- A ponte JDBC-ODBC foi removida.
- O espaço de memória PermGen foi removido.
Conclusão
Neste tutorial, discutimos os principais recursos que foram adicionados à versão Java 8. Como Java 8 é uma versão principal do Java, é importante que você conheça todos os recursos e aprimoramentos que foram feitos como parte desta versão.
Embora a versão mais recente do Java seja 13, ainda é uma boa ideia se familiarizar com os recursos do Java 8. Todos os recursos discutidos neste tutorial ainda estão presentes na versão mais recente do Java e iremos discuti-los como tópicos individuais posteriormente nesta série.
Esperamos que este tutorial tenha ajudado você a aprender sobre os vários recursos do Java 8 !!
app cartão de ponto para iphone e android
Leitura recomendada
- Tutorial de comprimento de array Java com exemplos de código
- Java 'this' Palavra-chave: Tutorial com exemplos de código
- Interface Java e tutorial de classe abstrata com exemplos
- Tutorial de JAVA para iniciantes: mais de 100 tutoriais práticos em vídeo Java
- Implantação Java: Criação e execução de arquivo JAR Java
- C ++ Vs Java: 30 principais diferenças entre C ++ e Java com exemplos
- Método MongoDB Sort () com exemplos
- Explore os fundamentos de Java no Selenium com exemplos