Java 8 - Guia rápido

JAVA 8 é um grande lançamento de recurso de desenvolvimento de linguagem de programação JAVA. Sua versão inicial foi lançada em 18 de março de 2014. Com o lançamento do Java 8, o Java forneceu suporte para programação funcional, novo mecanismo JavaScript, novas APIs para manipulação de data e hora, nova API de streaming, etc.

Novas características

  • Lambda expression - Adiciona capacidade de processamento funcional ao Java.

  • Method references- Referenciar funções por seus nomes em vez de invocá-las diretamente. Usando funções como parâmetro.

  • Default method - Interface para implementação de método padrão.

  • New tools - Novas ferramentas e utilitários do compilador são adicionados como 'jdeps' para descobrir dependências.

  • Stream API - Nova API de fluxo para facilitar o processamento de pipeline.

  • Date Time API - API de data e hora aprimorada.

  • Optional - Ênfase nas melhores práticas para lidar com valores nulos corretamente.

  • Nashorn, JavaScript Engine - Um mecanismo baseado em Java para executar código JavaScript.

Considere o seguinte trecho de código.

import java.util.Collections;
import java.util.List;
import java.util.ArrayList;
import java.util.Comparator;

public class Java8Tester {

   public static void main(String args[]) {
   
      List<String> names1 = new ArrayList<String>();
      names1.add("Mahesh ");
      names1.add("Suresh ");
      names1.add("Ramesh ");
      names1.add("Naresh ");
      names1.add("Kalpesh ");
		
      List<String> names2 = new ArrayList<String>();
      names2.add("Mahesh ");
      names2.add("Suresh ");
      names2.add("Ramesh ");
      names2.add("Naresh ");
      names2.add("Kalpesh ");
		
      Java8Tester tester = new Java8Tester();
      System.out.println("Sort using Java 7 syntax: ");
		
      tester.sortUsingJava7(names1);
      System.out.println(names1);
      System.out.println("Sort using Java 8 syntax: ");
		
      tester.sortUsingJava8(names2);
      System.out.println(names2);
   }
   
   //sort using java 7
   private void sortUsingJava7(List<String> names) {   
      Collections.sort(names, new Comparator<String>() {
         @Override
         public int compare(String s1, String s2) {
            return s1.compareTo(s2);
         }
      });
   }
   
   //sort using java 8
   private void sortUsingJava8(List<String> names) {
      Collections.sort(names, (s1, s2) -> s1.compareTo(s2));
   }
}

Execute o programa para obter o seguinte resultado.

Sort using Java 7 syntax:
[ Kalpesh Mahesh Naresh Ramesh Suresh ]
Sort using Java 8 syntax:
[ Kalpesh Mahesh Naresh Ramesh Suresh ]

Aqui o sortUsingJava8() método usa a função de classificação com uma expressão lambda como parâmetro para obter os critérios de classificação.

Configuração de ambiente local

Se você deseja configurar seu próprio ambiente para a linguagem de programação Java, esta seção o orienta em todo o processo. Siga as etapas abaixo para configurar seu ambiente Java.

Java SE pode ser baixado gratuitamente no seguinte link -

https://www.oracle.com/technetwork/java/javase/downloads/index-jsp-138363.html

Você baixa uma versão com base em seu sistema operacional.

Siga as instruções para baixar o Java e execute o .exepara instalar o Java em sua máquina. Depois de instalar o Java em sua máquina, você precisará definir as variáveis ​​de ambiente para apontar para os diretórios de instalação corretos.

Configurando o caminho para Windows 2000 / XP

Supondo que você tenha instalado o Java no diretório c: \ Arquivos de programas \ java \ jdk -

  • Clique com o botão direito em 'Meu Computador' e selecione 'Propriedades'.

  • Clique no botão 'Variáveis ​​de ambiente' na guia 'Avançado'.

  • Agora, altere a variável 'Path' para que também contenha o caminho para o executável Java. Por exemplo, se o caminho estiver definido atualmente para 'C: \ WINDOWS \ SYSTEM32', altere seu caminho para 'C: \ WINDOWS \ SYSTEM32; c: \ Arquivos de programas \ java \ jdk \ bin'.

Configurando o Caminho para Windows 95/98 / ME

Supondo que você tenha instalado o Java no diretório c: \ Arquivos de programas \ java \ jdk -

  • Edite o arquivo 'C: \ autoexec.bat' e adicione a seguinte linha no final -

    SET PATH =% PATH%; C: \ Arquivos de programas \ java \ jdk \ bin

Configurando o caminho para Linux, UNIX, Solaris, FreeBSD

A variável de ambiente PATH deve ser definida para apontar para onde os binários Java foram instalados. Consulte a documentação do shell se tiver problemas para fazer isso.

Por exemplo, se você usar bash como shell, adicione a seguinte linha no final de seu '.bashrc: export PATH = / path / to / java: $ PATH'

Editores Java populares

Para escrever programas Java, você precisa de um editor de texto. Existem IDEs ainda mais sofisticados disponíveis no mercado. Mas, por agora, você pode considerar um dos seguintes -

  • Notepad - Na máquina Windows, você pode usar qualquer editor de texto simples como o Notepad (recomendado para este tutorial) ou TextPad.

  • Netbeans- É um IDE Java de código aberto e gratuito. Ele pode ser baixado dehttps://netbeans.org/index.html.

  • Eclipse - Também é um IDE Java desenvolvido pela comunidade de código aberto Eclipse e pode ser baixado de https://www.eclipse.org/.

As expressões lambda são introduzidas no Java 8 e são tidas como o maior recurso do Java 8. A expressão lambda facilita a programação funcional e simplifica muito o desenvolvimento.

Sintaxe

Uma expressão lambda é caracterizada pela seguinte sintaxe.

parameter -> expression body

A seguir estão as características importantes de uma expressão lambda.

  • Optional type declaration- Não há necessidade de declarar o tipo de um parâmetro. O compilador pode inferir o mesmo do valor do parâmetro.

  • Optional parenthesis around parameter- Não há necessidade de declarar um único parâmetro entre parênteses. Para vários parâmetros, os parênteses são obrigatórios.

  • Optional curly braces - Não há necessidade de usar chaves no corpo da expressão se o corpo contiver uma única instrução.

  • Optional return keyword- O compilador retorna automaticamente o valor se o corpo tiver uma única expressão para retornar o valor. Os colchetes são necessários para indicar que a expressão retorna um valor.

Exemplo de expressões lambda

Crie o seguinte programa Java usando qualquer editor de sua escolha em, digamos, C: \> JAVA.

Java8Tester.java

public class Java8Tester {

   public static void main(String args[]) {
      Java8Tester tester = new Java8Tester();
		
      //with type declaration
      MathOperation addition = (int a, int b) -> a + b;
		
      //with out type declaration
      MathOperation subtraction = (a, b) -> a - b;
		
      //with return statement along with curly braces
      MathOperation multiplication = (int a, int b) -> { return a * b; };
		
      //without return statement and without curly braces
      MathOperation division = (int a, int b) -> a / b;
		
      System.out.println("10 + 5 = " + tester.operate(10, 5, addition));
      System.out.println("10 - 5 = " + tester.operate(10, 5, subtraction));
      System.out.println("10 x 5 = " + tester.operate(10, 5, multiplication));
      System.out.println("10 / 5 = " + tester.operate(10, 5, division));
		
      //without parenthesis
      GreetingService greetService1 = message ->
      System.out.println("Hello " + message);
		
      //with parenthesis
      GreetingService greetService2 = (message) ->
      System.out.println("Hello " + message);
		
      greetService1.sayMessage("Mahesh");
      greetService2.sayMessage("Suresh");
   }
	
   interface MathOperation {
      int operation(int a, int b);
   }
	
   interface GreetingService {
      void sayMessage(String message);
   }
	
   private int operate(int a, int b, MathOperation mathOperation) {
      return mathOperation.operation(a, b);
   }
}

Verifique o resultado

Compile a classe usando javac compilador da seguinte forma -

C:\JAVA>javac Java8Tester.java

Agora execute o Java8Tester da seguinte maneira -

C:\JAVA>java Java8Tester

Ele deve produzir a seguinte saída -

10 + 5 = 15
10 - 5 = 5
10 x 5 = 50
10 / 5 = 2
Hello Mahesh
Hello Suresh

A seguir estão os pontos importantes a serem considerados no exemplo acima.

  • As expressões lambda são usadas principalmente para definir a implementação sequencial de uma interface funcional, ou seja, uma interface com um único método apenas. No exemplo acima, usamos vários tipos de expressões lambda para definir o método de operação da interface MathOperation. Em seguida, definimos a implementação de sayMessage de GreetingService.

  • A expressão lambda elimina a necessidade de classe anônima e fornece uma capacidade de programação funcional muito simples, mas poderosa para Java.

Escopo

Usando a expressão lambda, você pode se referir a qualquer variável final ou variável efetivamente final (que é atribuída apenas uma vez). A expressão lambda gera um erro de compilação, se um valor for atribuído a uma variável pela segunda vez.

Exemplo de escopo

Crie o seguinte programa Java usando qualquer editor de sua escolha em, digamos, C: \> JAVA.

Java8Tester.java

public class Java8Tester {

   final static String salutation = "Hello! ";
   
   public static void main(String args[]) {
      GreetingService greetService1 = message -> 
      System.out.println(salutation + message);
      greetService1.sayMessage("Mahesh");
   }
	
   interface GreetingService {
      void sayMessage(String message);
   }
}

Verifique o resultado

Compile a classe usando javac compilador da seguinte forma -

C:\JAVA>javac Java8Tester.java

Agora execute o Java8Tester da seguinte maneira -

C:\JAVA>java Java8Tester

Ele deve produzir a seguinte saída -

Hello! Mahesh

As referências de método ajudam a apontar os métodos por seus nomes. Uma referência de método é descrita usando o símbolo "::". Uma referência de método pode ser usada para apontar os seguintes tipos de métodos -

  • Métodos estáticos
  • Métodos de instância
  • Construtores usando novo operador (TreeSet :: new)

Exemplo de referência de método

Crie o seguinte programa Java usando qualquer editor de sua escolha em, digamos, C: \> JAVA.

Java8Tester.java

import java.util.List;
import java.util.ArrayList;

public class Java8Tester {

   public static void main(String args[]) {
      List names = new ArrayList();
		
      names.add("Mahesh");
      names.add("Suresh");
      names.add("Ramesh");
      names.add("Naresh");
      names.add("Kalpesh");
		
      names.forEach(System.out::println);
   }
}

Aqui, passamos o método System.out :: println como uma referência de método estático.

Verifique o resultado

Compile a classe usando javac compilador da seguinte forma -

C:\JAVA>javac Java8Tester.java

Agora execute o Java8Tester da seguinte maneira -

C:\JAVA>java Java8Tester

Ele deve produzir a seguinte saída -

Mahesh
Suresh
Ramesh
Naresh
Kalpesh

As interfaces funcionais têm uma única funcionalidade para exibir. Por exemplo, uma interface Comparable com um único método 'compareTo' é usada para fins de comparação. Java 8 definiu várias interfaces funcionais para serem usadas extensivamente em expressões lambda. A seguir está a lista de interfaces funcionais definidas no pacote java.util.Function.

Sr. Não. Interface e descrição
1

BiConsumer<T,U>

Representa uma operação que aceita dois argumentos de entrada e não retorna nenhum resultado.
2

BiFunction<T,U,R>

Representa uma função que aceita dois argumentos e produz um resultado.
3

BinaryOperator<T>

Representa uma operação sobre dois operandos do mesmo tipo, produzindo um resultado do mesmo tipo que os operandos.
4

BiPredicate<T,U>

Representa um predicado (função com valor booleano) de dois argumentos.
5

BooleanSupplier

Representa um fornecedor de resultados com valor booleano.
6

Consumer<T>

Representa uma operação que aceita um único argumento de entrada e não retorna nenhum resultado.
7

DoubleBinaryOperator

Representa uma operação em dois operandos de valor duplo e produzindo um resultado de valor duplo.
8

DoubleConsumer

Representa uma operação que aceita um único argumento de valor duplo e não retorna nenhum resultado.
9

DoubleFunction<R>

Representa uma função que aceita um argumento de valor duplo e produz um resultado.
10

DoublePredicate

Representa um predicado (função com valor booleano) de um argumento com valor duplo.
11

DoubleSupplier

Representa um fornecedor de resultados de valor duplo.
12

DoubleToIntFunction

Representa uma função que aceita um argumento com valor duplo e produz um resultado com valor int.
13

DoubleToLongFunction

Representa uma função que aceita um argumento de valor duplo e produz um resultado de valor longo.
14

DoubleUnaryOperator

Representa uma operação em um único operando de valor duplo que produz um resultado de valor duplo.
15

Function<T,R>

Representa uma função que aceita um argumento e produz um resultado.
16

IntBinaryOperator

Representa uma operação sobre dois operandos com valor int e produz um resultado com valor int.
17

IntConsumer

Representa uma operação que aceita um único argumento com valor int e não retorna nenhum resultado.
18

IntFunction<R>

Representa uma função que aceita um argumento com valor int e produz um resultado.
19

IntPredicate

Representa um predicado (função com valor booleano) de um argumento com valor int.
20

IntSupplier

Representa um fornecedor de resultados com valor int.
21

IntToDoubleFunction

Representa uma função que aceita um argumento com valor int e produz um resultado com valor duplo.
22

IntToLongFunction

Representa uma função que aceita um argumento com valor int e produz um resultado com valor longo.
23

IntUnaryOperator

Representa uma operação em um único operando com valor interno que produz um resultado com valor interno.
24

LongBinaryOperator

Representa uma operação sobre dois operandos de valor longo e produz um resultado de valor longo.
25

LongConsumer

Representa uma operação que aceita um único argumento de valor longo e não retorna nenhum resultado.
26

LongFunction<R>

Representa uma função que aceita um argumento de valor longo e produz um resultado.
27

LongPredicate

Representa um predicado (função de valor booleano) de um argumento de valor longo.
28

LongSupplier

Representa um fornecedor de resultados de longo valor.
29

LongToDoubleFunction

Representa uma função que aceita um argumento de valor longo e produz um resultado de valor duplo.
30

LongToIntFunction

Representa uma função que aceita um argumento de valor longo e produz um resultado de valor int.
31

LongUnaryOperator

Representa uma operação em um único operando de valor longo que produz um resultado de valor longo.
32

ObjDoubleConsumer<T>

Representa uma operação que aceita um argumento de valor de objeto e um de valor duplo e não retorna nenhum resultado.
33

ObjIntConsumer<T>

Representa uma operação que aceita um argumento com valor de objeto e um argumento com valor int e não retorna nenhum resultado.
34

ObjLongConsumer<T>

Representa uma operação que aceita um argumento de valor de objeto e um de valor longo e não retorna nenhum resultado.
35

Predicate<T>

Representa um predicado (função com valor booleano) de um argumento.
36

Supplier<T>

Representa um fornecedor de resultados.
37

ToDoubleBiFunction<T,U>

Representa uma função que aceita dois argumentos e produz um resultado de valor duplo.
38

ToDoubleFunction<T>

Representa uma função que produz um resultado de valor duplo.
39

ToIntBiFunction<T,U>

Representa uma função que aceita dois argumentos e produz um resultado com valor int.
40

ToIntFunction<T>

Representa uma função que produz um resultado com valor int.
41

ToLongBiFunction<T,U>

Representa uma função que aceita dois argumentos e produz um resultado de valor longo.
42

ToLongFunction<T>

Representa uma função que produz um resultado de valor longo.
43

UnaryOperator<T>

Representa uma operação em um único operando que produz um resultado do mesmo tipo de seu operando.

Exemplo de interface funcional

A interface Predicate <T> é uma interface funcional com um método test (Object) para retornar um valor booleano. Essa interface significa que um objeto foi testado para ser verdadeiro ou falso.

Crie o seguinte programa Java usando qualquer editor de sua escolha em, digamos, C: \> JAVA.

Java8Tester.java

import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;

public class Java8Tester {

   public static void main(String args[]) {
      List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
		
      // Predicate<Integer> predicate = n -> true
      // n is passed as parameter to test method of Predicate interface
      // test method will always return true no matter what value n has.
		
      System.out.println("Print all numbers:");
		
      //pass n as parameter
      eval(list, n->true);
		
      // Predicate<Integer> predicate1 = n -> n%2 == 0
      // n is passed as parameter to test method of Predicate interface
      // test method will return true if n%2 comes to be zero
		
      System.out.println("Print even numbers:");
      eval(list, n-> n%2 == 0 );
		
      // Predicate<Integer> predicate2 = n -> n > 3
      // n is passed as parameter to test method of Predicate interface
      // test method will return true if n is greater than 3.
		
      System.out.println("Print numbers greater than 3:");
      eval(list, n-> n > 3 );
   }
	
   public static void eval(List<Integer> list, Predicate<Integer> predicate) {

      for(Integer n: list) {

         if(predicate.test(n)) {
            System.out.println(n + " ");
         }
      }
   }
}

Aqui, passamos a interface Predicate, que recebe uma única entrada e retorna Boolean.

Verifique o resultado

Compile a classe usando javac compilador da seguinte forma -

C:\JAVA>javac Java8Tester.java

Agora execute o Java8Tester da seguinte maneira -

C:\JAVA>java Java8Tester

Ele deve produzir a seguinte saída -

Print all numbers:
1
2
3
4
5
6
7
8
9
Print even numbers:
2
4
6
8
Print numbers greater than 3:
4
5
6
7
8
9

Java 8 apresenta um novo conceito de implementação de método padrão em interfaces. Esse recurso é adicionado para compatibilidade com versões anteriores, de forma que interfaces antigas possam ser usadas para alavancar o recurso de expressão lambda do Java 8.

Por exemplo, as interfaces 'Lista' ou 'Coleção' não têm declaração de método 'forEach'. Portanto, adicionar esse método simplesmente interromperá as implementações do framework de coleção. Java 8 apresenta o método padrão para que a interface Lista / Coleção possa ter uma implementação padrão do método forEach, e a classe que implementa essas interfaces não precisa implementar o mesmo.

Sintaxe

public interface vehicle {

   default void print() {
      System.out.println("I am a vehicle!");
   }
}

Vários padrões

Com funções padrão em interfaces, existe a possibilidade de que uma classe esteja implementando duas interfaces com os mesmos métodos padrão. O código a seguir explica como essa ambigüidade pode ser resolvida.

public interface vehicle {

   default void print() {
      System.out.println("I am a vehicle!");
   }
}

public interface fourWheeler {

   default void print() {
      System.out.println("I am a four wheeler!");
   }
}

A primeira solução é criar um método próprio que substitua a implementação padrão.

public class car implements vehicle, fourWheeler {

   public void print() {
      System.out.println("I am a four wheeler car vehicle!");
   }
}

A segunda solução é chamar o método padrão da interface especificada usando super.

public class car implements vehicle, fourWheeler {

   public void print() {
      vehicle.super.print();
   }
}

Métodos estáticos padrão

Uma interface também pode ter métodos auxiliares estáticos do Java 8 em diante.

public interface vehicle {

   default void print() {
      System.out.println("I am a vehicle!");
   }
	
   static void blowHorn() {
      System.out.println("Blowing horn!!!");
   }
}

Exemplo de método padrão

Crie o seguinte programa Java usando qualquer editor de sua escolha em, digamos, C: \> JAVA.

Java8Tester.java

public class Java8Tester {

   public static void main(String args[]) {
      Vehicle vehicle = new Car();
      vehicle.print();
   }
}

interface Vehicle {

   default void print() {
      System.out.println("I am a vehicle!");
   }
	
   static void blowHorn() {
      System.out.println("Blowing horn!!!");
   }
}

interface FourWheeler {

   default void print() {
      System.out.println("I am a four wheeler!");
   }
}

class Car implements Vehicle, FourWheeler {

   public void print() {
      Vehicle.super.print();
      FourWheeler.super.print();
      Vehicle.blowHorn();
      System.out.println("I am a car!");
   }
}

Verifique o resultado

Compile a classe usando javac compilador da seguinte forma -

C:\JAVA>javac Java8Tester.java

Agora execute o Java8Tester da seguinte maneira -

C:\JAVA>java Java8Tester

Ele deve produzir a seguinte saída -

I am a vehicle!
I am a four wheeler!
Blowing horn!!!
I am a car!

Stream é uma nova camada abstrata introduzida no Java 8. Usando stream, você pode processar dados de maneira declarativa semelhante às instruções SQL. Por exemplo, considere a seguinte instrução SQL.

SELECT max(salary), employee_id, employee_name FROM Employee

A expressão SQL acima retorna automaticamente os detalhes do funcionário assalariado máximo, sem fazer nenhum cálculo por parte do desenvolvedor. Usando a estrutura de coleções em Java, um desenvolvedor precisa usar loops e fazer verificações repetidas. Outra preocupação é a eficiência; como os processadores multi-core estão facilmente disponíveis, um desenvolvedor Java precisa escrever um processamento de código paralelo que pode ser bastante sujeito a erros.

Para resolver esses problemas, o Java 8 introduziu o conceito de fluxo que permite ao desenvolvedor processar dados declarativamente e aproveitar a arquitetura multicore sem a necessidade de escrever qualquer código específico para ele.

O que é o Stream?

Stream representa uma sequência de objetos de uma origem, que oferece suporte a operações de agregação. A seguir estão as características de um Stream -

  • Sequence of elements- Um fluxo fornece um conjunto de elementos de um tipo específico de maneira sequencial. Um fluxo obtém / calcula elementos sob demanda. Nunca armazena os elementos.

  • Source - O fluxo usa coleções, matrizes ou recursos de E / S como fonte de entrada.

  • Aggregate operations - Stream suporta operações agregadas como filtrar, mapear, limitar, reduzir, encontrar, combinar e assim por diante.

  • Pipelining- A maioria das operações de fluxo retorna o próprio fluxo para que seu resultado possa ser canalizado. Essas operações são chamadas de operações intermediárias e sua função é obter a entrada, processá-las e retornar a saída para o destino. O método collect () é uma operação terminal que normalmente está presente no final da operação de pipelining para marcar o final do fluxo.

  • Automatic iterations - As operações de fluxo fazem as iterações internamente sobre os elementos de origem fornecidos, em contraste com Coleções onde a iteração explícita é necessária.

Gerando Streams

Com o Java 8, a interface Collection possui dois métodos para gerar um Stream.

  • stream() - Retorna um fluxo sequencial considerando a coleção como sua fonte.

  • parallelStream() - Retorna um fluxo paralelo considerando a coleção como sua fonte.

List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
List<String> filtered = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.toList());

para cada

Stream forneceu um novo método 'forEach' para iterar cada elemento do stream. O segmento de código a seguir mostra como imprimir 10 números aleatórios usando forEach.

Random random = new Random();
random.ints().limit(10).forEach(System.out::println);

mapa

O método 'map' é usado para mapear cada elemento para seu resultado correspondente. O segmento de código a seguir imprime quadrados únicos de números usando mapa.

List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);

//get list of unique squares
List<Integer> squaresList = numbers.stream().map( i -> i*i).distinct().collect(Collectors.toList());

filtro

O método de 'filtro' é usado para eliminar elementos com base em um critério. O segmento de código a seguir imprime uma contagem de strings vazias usando filtro.

List<String>strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");

//get count of empty string
int count = strings.stream().filter(string -> string.isEmpty()).count();

limite

O método 'limit' é usado para reduzir o tamanho do fluxo. O segmento de código a seguir mostra como imprimir 10 números aleatórios usando limite.

Random random = new Random();
random.ints().limit(10).forEach(System.out::println);

classificado

O método 'classificado' é usado para classificar o fluxo. O segmento de código a seguir mostra como imprimir 10 números aleatórios em uma ordem de classificação.

Random random = new Random();
random.ints().limit(10).sorted().forEach(System.out::println);

Processamento paralelo

parallelStream é a alternativa de stream para processamento paralelo. Dê uma olhada no seguinte segmento de código que imprime uma contagem de strings vazias usando parallelStream.

List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");

//get count of empty string
long count = strings.parallelStream().filter(string -> string.isEmpty()).count();

É muito fácil alternar entre streams sequenciais e paralelos.

Colecionadores

Os coletores são usados ​​para combinar o resultado do processamento nos elementos de um fluxo. Os coletores podem ser usados ​​para retornar uma lista ou uma string.

List<String>strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
List<String> filtered = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.toList());

System.out.println("Filtered List: " + filtered);
String mergedString = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.joining(", "));
System.out.println("Merged String: " + mergedString);

Estatisticas

Com o Java 8, os coletores de estatísticas são introduzidos para calcular todas as estatísticas quando o processamento do fluxo está sendo feito.

List numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);

IntSummaryStatistics stats = numbers.stream().mapToInt((x) -> x).summaryStatistics();

System.out.println("Highest number in List : " + stats.getMax());
System.out.println("Lowest number in List : " + stats.getMin());
System.out.println("Sum of all numbers : " + stats.getSum());
System.out.println("Average of all numbers : " + stats.getAverage());

Exemplo de fluxo

Crie o seguinte programa Java usando qualquer editor de sua escolha em, digamos, C: \> JAVA.

Java8Tester.java

import java.util.ArrayList;
import java.util.Arrays;
import java.util.IntSummaryStatistics;
import java.util.List;
import java.util.Random;
import java.util.stream.Collectors;
import java.util.Map;

public class Java8Tester {

   public static void main(String args[]) {
      System.out.println("Using Java 7: ");
		
      // Count empty strings
      List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
      System.out.println("List: " +strings);
      long count = getCountEmptyStringUsingJava7(strings);
		
      System.out.println("Empty Strings: " + count);
      count = getCountLength3UsingJava7(strings);
		
      System.out.println("Strings of length 3: " + count);
		
      //Eliminate empty string
      List<String> filtered = deleteEmptyStringsUsingJava7(strings);
      System.out.println("Filtered List: " + filtered);
		
      //Eliminate empty string and join using comma.
      String mergedString = getMergedStringUsingJava7(strings,", ");
      System.out.println("Merged String: " + mergedString);
      List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
		
      //get list of square of distinct numbers
      List<Integer> squaresList = getSquares(numbers);
      System.out.println("Squares List: " + squaresList);
      List<Integer> integers = Arrays.asList(1,2,13,4,15,6,17,8,19);
		
      System.out.println("List: " +integers);
      System.out.println("Highest number in List : " + getMax(integers));
      System.out.println("Lowest number in List : " + getMin(integers));
      System.out.println("Sum of all numbers : " + getSum(integers));
      System.out.println("Average of all numbers : " + getAverage(integers));
      System.out.println("Random Numbers: ");
		
      //print ten random numbers
      Random random = new Random();
		
      for(int i = 0; i < 10; i++) {
         System.out.println(random.nextInt());
      }
		
      System.out.println("Using Java 8: ");
      System.out.println("List: " +strings);
		
      count = strings.stream().filter(string->string.isEmpty()).count();
      System.out.println("Empty Strings: " + count);
		
      count = strings.stream().filter(string -> string.length() == 3).count();
      System.out.println("Strings of length 3: " + count);
		
      filtered = strings.stream().filter(string ->!string.isEmpty()).collect(Collectors.toList());
      System.out.println("Filtered List: " + filtered);
		
      mergedString = strings.stream().filter(string ->!string.isEmpty()).collect(Collectors.joining(", "));
      System.out.println("Merged String: " + mergedString);
		
      squaresList = numbers.stream().map( i ->i*i).distinct().collect(Collectors.toList());
      System.out.println("Squares List: " + squaresList);
      System.out.println("List: " +integers);
		
      IntSummaryStatistics stats = integers.stream().mapToInt((x) ->x).summaryStatistics();
		
      System.out.println("Highest number in List : " + stats.getMax());
      System.out.println("Lowest number in List : " + stats.getMin());
      System.out.println("Sum of all numbers : " + stats.getSum());
      System.out.println("Average of all numbers : " + stats.getAverage());
      System.out.println("Random Numbers: ");
		
      random.ints().limit(10).sorted().forEach(System.out::println);
		
      //parallel processing
      count = strings.parallelStream().filter(string -> string.isEmpty()).count();
      System.out.println("Empty Strings: " + count);
   }
	
   private static int getCountEmptyStringUsingJava7(List<String> strings) {
      int count = 0;

      for(String string: strings) {
		
         if(string.isEmpty()) {
            count++;
         }
      }
      return count;
   }
	
   private static int getCountLength3UsingJava7(List<String> strings) {
      int count = 0;
		
      for(String string: strings) {
		
         if(string.length() == 3) {
            count++;
         }
      }
      return count;
   }
	
   private static List<String> deleteEmptyStringsUsingJava7(List<String> strings) {
      List<String> filteredList = new ArrayList<String>();
		
      for(String string: strings) {
		
         if(!string.isEmpty()) {
             filteredList.add(string);
         }
      }
      return filteredList;
   }
	
   private static String getMergedStringUsingJava7(List<String> strings, String separator) {
      StringBuilder stringBuilder = new StringBuilder();
		
      for(String string: strings) {
		
         if(!string.isEmpty()) {
            stringBuilder.append(string);
            stringBuilder.append(separator);
         }
      }
      String mergedString = stringBuilder.toString();
      return mergedString.substring(0, mergedString.length()-2);
   }
	
   private static List<Integer> getSquares(List<Integer> numbers) {
      List<Integer> squaresList = new ArrayList<Integer>();
		
      for(Integer number: numbers) {
         Integer square = new Integer(number.intValue() * number.intValue());
			
         if(!squaresList.contains(square)) {
            squaresList.add(square);
         }
      }
      return squaresList;
   }
	
   private static int getMax(List<Integer> numbers) {
      int max = numbers.get(0);
		
      for(int i = 1;i < numbers.size();i++) {
		
         Integer number = numbers.get(i);
			
         if(number.intValue() > max) {
            max = number.intValue();
         }
      }
      return max;
   }
	
   private static int getMin(List<Integer> numbers) {
      int min = numbers.get(0);
		
      for(int i= 1;i < numbers.size();i++) {
         Integer number = numbers.get(i);
		
         if(number.intValue() < min) {
            min = number.intValue();
         }
      }
      return min;
   }
	
   private static int getSum(List numbers) {
      int sum = (int)(numbers.get(0));
		
      for(int i = 1;i < numbers.size();i++) {
         sum += (int)numbers.get(i);
      }
      return sum;
   }
	
   private static int getAverage(List<Integer> numbers) {
      return getSum(numbers) / numbers.size();
   }
}

Verifique o resultado

Compile a classe usando javac compilador da seguinte forma -

C:\JAVA>javac Java8Tester.java

Agora execute o Java8Tester da seguinte maneira -

C:\JAVA>java Java8Tester

Deve produzir o seguinte resultado -

Using Java 7:
List: [abc, , bc, efg, abcd, , jkl]
Empty Strings: 2
Strings of length 3: 3
Filtered List: [abc, bc, efg, abcd, jkl]
Merged String: abc, bc, efg, abcd, jkl
Squares List: [9, 4, 49, 25]
List: [1, 2, 13, 4, 15, 6, 17, 8, 19]
Highest number in List : 19
Lowest number in List : 1
Sum of all numbers : 85
Average of all numbers : 9
Random Numbers:
-1279735475
903418352
-1133928044
-1571118911
628530462
18407523
-881538250
-718932165
270259229
421676854
Using Java 8:
List: [abc, , bc, efg, abcd, , jkl]
Empty Strings: 2
Strings of length 3: 3
Filtered List: [abc, bc, efg, abcd, jkl]
Merged String: abc, bc, efg, abcd, jkl
Squares List: [9, 4, 49, 25]
List: [1, 2, 13, 4, 15, 6, 17, 8, 19]
Highest number in List : 19
Lowest number in List : 1
Sum of all numbers : 85
Average of all numbers : 9.444444444444445
Random Numbers:
-1009474951
-551240647
-2484714
181614550
933444268
1227850416
1579250773
1627454872
1683033687
1798939493
Empty Strings: 2

Opcional é um objeto de contêiner usado para conter objetos não nulos. O objeto opcional é usado para representar nulo com valor ausente. Esta classe possui vários métodos utilitários para facilitar o código para manipular valores como 'disponíveis' ou 'não disponíveis' em vez de verificar valores nulos. Ele foi introduzido no Java 8 e é semelhante ao opcional do Guava.

Declaração de Classe

A seguir está a declaração para java.util.Optional<T> classe -

public final class Optional<T> extends Object

Método de Classe

Sr. Não. Método e Descrição
1

static <T> Optional<T> empty()

Retorna uma instância opcional vazia.
2

boolean equals(Object obj)

Indica se algum outro objeto é "igual a" este Opcional.
3

Optional<T> filter(Predicate<? super <T> predicate)

Se um valor estiver presente e o valor corresponder a um determinado predicado, ele retornará um opcional que descreve o valor; caso contrário, retornará um opcional vazio.
4

<U> Optional<U> flatMap(Function<? super T,Optional<U>> mapper)

Se um valor estiver presente, ele aplica a função de mapeamento de rolamento opcional fornecida a ele, retorna esse resultado, caso contrário, retorna um opcional vazio.
5

T get()

Se um valor estiver presente neste opcional, retorna o valor, caso contrário, lança NoSuchElementException.
6

int hashCode()

Retorna o valor do código hash do valor presente, se houver, ou 0 (zero) se nenhum valor estiver presente.
7

void ifPresent(Consumer<? super T> consumer)

Se um valor estiver presente, ele chama o consumidor especificado com o valor, caso contrário, não faz nada.
8

boolean isPresent()

Retorna verdadeiro se houver um valor presente; caso contrário, é falso.
9

<U>Optional<U> map(Function<? super T,? extends U> mapper)

Se um valor estiver presente, aplica a função de mapeamento fornecida a ele e, se o resultado não for nulo, retorna um opcional que descreve o resultado.
10

static <T> Optional<T> of(T value)

Retorna um opcional com o valor não nulo presente especificado.
11

static <T> Optional<T> ofNullable(T value)

Retorna um Opcional que descreve o valor especificado, se não nulo; caso contrário, retorna um Opcional vazio.
12

T orElse(T other)

Retorna o valor se presente; caso contrário, retorna outro.
13

T orElseGet(Supplier<? extends T> other)

Retorna o valor se presente; caso contrário, invoca other e retorna o resultado dessa invocação.
14

<X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier)

Retorna o valor contido, se presente, caso contrário, lança uma exceção a ser criada pelo fornecedor fornecido.
15

String toString()

Retorna uma representação de string não vazia deste Opcional adequado para depuração.

Esta classe herda métodos da seguinte classe -

  • java.lang.Object

Exemplo Opcional

Crie o seguinte programa Java usando qualquer editor de sua escolha em, digamos, C: \> JAVA.

Java8Tester.java

import java.util.Optional;

public class Java8Tester {

   public static void main(String args[]) {
      Java8Tester java8Tester = new Java8Tester();
      Integer value1 = null;
      Integer value2 = new Integer(10);
		
      //Optional.ofNullable - allows passed parameter to be null.
      Optional<Integer> a = Optional.ofNullable(value1);
		
      //Optional.of - throws NullPointerException if passed parameter is null
      Optional<Integer> b = Optional.of(value2);
      System.out.println(java8Tester.sum(a,b));
   }
	
   public Integer sum(Optional<Integer> a, Optional<Integer> b) {
      //Optional.isPresent - checks the value is present or not
		
      System.out.println("First parameter is present: " + a.isPresent());
      System.out.println("Second parameter is present: " + b.isPresent());
		
      //Optional.orElse - returns the value if present otherwise returns
      //the default value passed.
      Integer value1 = a.orElse(new Integer(0));
		
      //Optional.get - gets the value, value should be present
      Integer value2 = b.get();
      return value1 + value2;
   }
}

Verifique o resultado

Compile a classe usando javac compilador da seguinte forma -

C:\JAVA>javac Java8Tester.java

Agora execute o Java8Tester da seguinte maneira -

C:\JAVA>java Java8Tester

Ele deve produzir a seguinte saída -

First parameter is present: false
Second parameter is present: true
10

Com o Java 8, Nashorn, um motor javascript muito melhorado é introduzido, para substituir o Rhino existente. O Nashorn oferece um desempenho 2 a 10 vezes melhor, pois compila diretamente o código na memória e passa o bytecode para a JVM. Nashorn usa o recurso de dinâmica de chamada, introduzido no Java 7 para melhorar o desempenho.

jjs

Para o motor Nashorn, JAVA 8 apresenta uma nova ferramenta de linha de comando, jjs, para executar códigos javascript no console.

Interpretando arquivo js

Crie e salve o arquivo sample.js em c: \> pasta JAVA.

sample.js

print('Hello World!');

Abra o console e use o seguinte comando.

C:\JAVA>jjs sample.js

Ele produzirá a seguinte saída:

Hello World!

jjs no modo interativo

Abra o console e use o seguinte comando.

C:\JAVA>jjs
jjs> print("Hello, World!")
Hello, World!
jjs> quit()
>>

Passar argumentos

Abra o console e use o seguinte comando.

C:\JAVA> jjs -- a b c
jjs> print('letters: ' +arguments.join(", "))
letters: a, b, c
jjs>

Chamando JavaScript de Java

Usando ScriptEngineManager, o código JavaScript pode ser chamado e interpretado em Java.

Exemplo

Crie o seguinte programa Java usando qualquer editor de sua escolha em, digamos, C: \> JAVA.

Java8Tester.java

import javax.script.ScriptEngineManager;
import javax.script.ScriptEngine;
import javax.script.ScriptException;

public class Java8Tester {

   public static void main(String args[]) {
      ScriptEngineManager scriptEngineManager = new ScriptEngineManager();
      ScriptEngine nashorn = scriptEngineManager.getEngineByName("nashorn");
		
      String name = "Mahesh";
      Integer result = null;
      
      try {
         nashorn.eval("print('" + name + "')");
         result = (Integer) nashorn.eval("10 + 2");
         
      } catch(ScriptException e) {
         System.out.println("Error executing script: "+ e.getMessage());
      }
      System.out.println(result.toString());
   }
}

Verifique o resultado

Compile a classe usando javac compilador da seguinte forma -

C:\JAVA>javac Java8Tester.java

Agora execute o Java8Tester da seguinte maneira -

C:\JAVA>java Java8Tester

Deve produzir o seguinte resultado -

Mahesh
12

Chamando Java de JavaScript

O exemplo a seguir explica como importar e usar classes Java em java script.

Criar e salvar sample.js em c: \> pasta JAVA.

sample.js

var BigDecimal = Java.type('java.math.BigDecimal');

function calculate(amount, percentage) {

   var result = new BigDecimal(amount).multiply(new BigDecimal(percentage)).divide(
      new BigDecimal("100"), 2, BigDecimal.ROUND_HALF_EVEN);
   
   return result.toPlainString();
}
var result = calculate(568000000000000000023,13.9);
print(result);

Abra o console e use o seguinte comando.

C:\JAVA>jjs sample.js

Ele deve produzir a seguinte saída -

78952000000000000003.20

Com o Java 8, uma nova API de data e hora é introduzida para cobrir as seguintes desvantagens da API de data e hora antiga.

  • Not thread safe- java.util.Date não é seguro para thread, portanto, os desenvolvedores precisam lidar com o problema de simultaneidade ao usar data. A nova API de data e hora é imutável e não possui métodos setter.

  • Poor design- A data padrão começa em 1900, o mês começa em 1 e o dia começa em 0, portanto, não há uniformidade. A API antiga tinha métodos menos diretos para operações de data. A nova API fornece vários métodos utilitários para tais operações.

  • Difficult time zone handling- Os desenvolvedores tiveram que escrever muitos códigos para lidar com problemas de fuso horário. A nova API foi desenvolvida tendo em mente o design específico do domínio.

Java 8 apresenta uma nova API de data e hora no pacote java.time. A seguir estão algumas das classes importantes introduzidas no pacote java.time.

  • Local - API de data e hora simplificada sem complexidade de manuseio de fuso horário.

  • Zoned - API de data e hora especializada para lidar com vários fusos horários.

API de data e hora local

As classes LocalDate / LocalTime e LocalDateTime simplificam o desenvolvimento onde os fusos horários não são necessários. Vamos vê-los em ação.

Crie o seguinte programa java usando qualquer editor de sua escolha em, digamos, C: \> JAVA.

Java8Tester.java

import java.time.LocalDate;
import java.time.LocalTime;
import java.time.LocalDateTime;
import java.time.Month;

public class Java8Tester {

   public static void main(String args[]) {
      Java8Tester java8tester = new Java8Tester();
      java8tester.testLocalDateTime();
   }
	
   public void testLocalDateTime() {
      // Get the current date and time
      LocalDateTime currentTime = LocalDateTime.now();
      System.out.println("Current DateTime: " + currentTime);
		
      LocalDate date1 = currentTime.toLocalDate();
      System.out.println("date1: " + date1);
		
      Month month = currentTime.getMonth();
      int day = currentTime.getDayOfMonth();
      int seconds = currentTime.getSecond();
		
      System.out.println("Month: " + month +"day: " + day +"seconds: " + seconds);
		
      LocalDateTime date2 = currentTime.withDayOfMonth(10).withYear(2012);
      System.out.println("date2: " + date2);
		
      //12 december 2014
      LocalDate date3 = LocalDate.of(2014, Month.DECEMBER, 12);
      System.out.println("date3: " + date3);
		
      //22 hour 15 minutes
      LocalTime date4 = LocalTime.of(22, 15);
      System.out.println("date4: " + date4);
		
      //parse a string
      LocalTime date5 = LocalTime.parse("20:15:30");
      System.out.println("date5: " + date5);
   }
}

Verifique o resultado

Compile a classe usando javac compilador da seguinte forma -

C:\JAVA>javac Java8Tester.java

Agora execute o Java8Tester da seguinte maneira -

C:\JAVA>java Java8Tester

Ele deve produzir a seguinte saída -

Current DateTime: 2014-12-09T11:00:45.457
date1: 2014-12-09
Month: DECEMBERday: 9seconds: 45
date2: 2012-12-10T11:00:45.457
date3: 2014-12-12
date4: 22:15
date5: 20:15:30

API Zoned Date-Time

A API de data e hora zoneada deve ser usada quando o fuso horário deve ser considerado. Vamos vê-los em ação.

Crie o seguinte programa Java usando qualquer editor de sua escolha em, digamos, C: \> JAVA.

Java8Tester.java

import java.time.ZonedDateTime;
import java.time.ZoneId;

public class Java8Tester {

   public static void main(String args[]) {
      Java8Tester java8tester = new Java8Tester();
      java8tester.testZonedDateTime();
   }
	
   public void testZonedDateTime() {
      // Get the current date and time
      ZonedDateTime date1 = ZonedDateTime.parse("2007-12-03T10:15:30+05:30[Asia/Karachi]");
      System.out.println("date1: " + date1);
		
      ZoneId id = ZoneId.of("Europe/Paris");
      System.out.println("ZoneId: " + id);
		
      ZoneId currentZone = ZoneId.systemDefault();
      System.out.println("CurrentZone: " + currentZone);
   }
}

Verifique o resultado

Compile a classe usando javac compilador da seguinte forma -

C:\JAVA>javac Java8Tester.java

Agora execute o Java8Tester da seguinte maneira -

C:\JAVA>java Java8Tester

Ele deve produzir a seguinte saída -

date1: 2007-12-03T10:15:30+05:00[Asia/Karachi]
ZoneId: Europe/Paris
CurrentZone: Etc/UTC

Chrono Units Enum

java.time.temporal.ChronoUnit enum é adicionado ao Java 8 para substituir os valores inteiros usados ​​na API antiga para representar dia, mês, etc. Vamos vê-los em ação.

Crie o seguinte programa Java usando qualquer editor de sua escolha em, digamos, C: \> JAVA.

Java8Tester.java

import java.time.LocalDate;
import java.time.temporal.ChronoUnit;

public class Java8Tester {

   public static void main(String args[]) {
      Java8Tester java8tester = new Java8Tester();
      java8tester.testChromoUnits();
   }
	
   public void testChromoUnits() {
      //Get the current date
      LocalDate today = LocalDate.now();
      System.out.println("Current date: " + today);
		
      //add 1 week to the current date
      LocalDate nextWeek = today.plus(1, ChronoUnit.WEEKS);
      System.out.println("Next week: " + nextWeek);
		
      //add 1 month to the current date
      LocalDate nextMonth = today.plus(1, ChronoUnit.MONTHS);
      System.out.println("Next month: " + nextMonth);
		
      //add 1 year to the current date
      LocalDate nextYear = today.plus(1, ChronoUnit.YEARS);
      System.out.println("Next year: " + nextYear);
		
      //add 10 years to the current date
      LocalDate nextDecade = today.plus(1, ChronoUnit.DECADES);
      System.out.println("Date after ten year: " + nextDecade);
   }
}

Verifique o resultado

Compile a classe usando javac compilador da seguinte forma -

C:\JAVA>javac Java8Tester.java

Agora execute o Java8Tester da seguinte maneira -

C:\JAVA>java Java8Tester

Deve produzir o seguinte resultado -

Current date: 2014-12-10
Next week: 2014-12-17
Next month: 2015-01-10
Next year: 2015-12-10
Date after ten year: 2024-12-10

Período e Duração

Com o Java 8, duas classes especializadas são introduzidas para lidar com as diferenças de tempo.

  • Period - Lida com quantidade de tempo baseada em data.

  • Duration - Lida com quantidade de tempo baseada em tempo.

Vamos vê-los em ação.

Crie o seguinte programa Java usando qualquer editor de sua escolha em, digamos, C: \> JAVA.

Java8Tester.java

import java.time.temporal.ChronoUnit;

import java.time.LocalDate;
import java.time.LocalTime;
import java.time.Duration;
import java.time.Period;

public class Java8Tester {

   public static void main(String args[]) {
      Java8Tester java8tester = new Java8Tester();
      java8tester.testPeriod();
      java8tester.testDuration();
   }
	
   public void testPeriod() {
      //Get the current date
      LocalDate date1 = LocalDate.now();
      System.out.println("Current date: " + date1);
		
      //add 1 month to the current date
      LocalDate date2 = date1.plus(1, ChronoUnit.MONTHS);
      System.out.println("Next month: " + date2);
      
      Period period = Period.between(date2, date1);
      System.out.println("Period: " + period);
   }
	
   public void testDuration() {
      LocalTime time1 = LocalTime.now();
      Duration twoHours = Duration.ofHours(2);
		
      LocalTime time2 = time1.plus(twoHours);
      Duration duration = Duration.between(time1, time2);
		
      System.out.println("Duration: " + duration);
   }
}

Verifique o resultado

Compile a classe usando javac compilador da seguinte forma -

C:\JAVA>javac Java8Tester.java

Agora execute o Java8Tester da seguinte maneira -

C:\JAVA>java Java8Tester

Ele deve produzir a seguinte saída -

Current date: 2014-12-10
Next month: 2015-01-10
Period: P-1M
Duration: PT2H

Ajustadores Temporais

TemporalAdjuster é usado para realizar a matemática de datas. Por exemplo, obtenha o "Segundo sábado do mês" ou "Próxima terça-feira". Vamos vê-los em ação.

Crie o seguinte programa Java usando qualquer editor de sua escolha em, digamos, C: \> JAVA.

Java8Tester.java

import java.time.LocalDate;
import java.time.temporal.TemporalAdjusters;
import java.time.DayOfWeek;

public class Java8Tester {

   public static void main(String args[]) {
      Java8Tester java8tester = new Java8Tester();
      java8tester.testAdjusters();
   }
	
   public void testAdjusters() {
      //Get the current date
      LocalDate date1 = LocalDate.now();
      System.out.println("Current date: " + date1);
		
      //get the next tuesday
      LocalDate nextTuesday = date1.with(TemporalAdjusters.next(DayOfWeek.TUESDAY));
      System.out.println("Next Tuesday on : " + nextTuesday);
		
      //get the second saturday of next month
      LocalDate firstInYear = LocalDate.of(date1.getYear(),date1.getMonth(), 1);
      LocalDate secondSaturday = firstInYear.with(TemporalAdjusters.nextOrSame(
         DayOfWeek.SATURDAY)).with(TemporalAdjusters.next(DayOfWeek.SATURDAY));
      System.out.println("Second Saturday on : " + secondSaturday);
   }
}

Verifique o resultado

Compile a classe usando javac compilador da seguinte forma -

C:\JAVA>javac Java8Tester.java

Agora execute o Java8Tester da seguinte maneira -

C:\JAVA>java Java8Tester

Deve produzir o seguinte resultado -

Current date: 2014-12-10
Next Tuesday on : 2014-12-16
Second Saturday on : 2014-12-13

Compatibilidade com versões anteriores

Um método toInstant () é adicionado aos objetos Date e Calendar originais, que podem ser usados ​​para convertê-los para a nova API Date-Time. Use um método ofInstant (Insant, ZoneId) para obter um objeto LocalDateTime ou ZonedDateTime. Vamos vê-los em ação.

Crie o seguinte programa Java usando qualquer editor de sua escolha em, digamos, C: \> JAVA.

Java8Tester.java

import java.time.LocalDateTime;
import java.time.ZonedDateTime;

import java.util.Date;

import java.time.Instant;
import java.time.ZoneId;

public class Java8Tester {

   public static void main(String args[]) {
      Java8Tester java8tester = new Java8Tester();
      java8tester.testBackwardCompatability();
   }
	
   public void testBackwardCompatability() {
      //Get the current date
      Date currentDate = new Date();
      System.out.println("Current date: " + currentDate);
		
      //Get the instant of current date in terms of milliseconds
      Instant now = currentDate.toInstant();
      ZoneId currentZone = ZoneId.systemDefault();
		
      LocalDateTime localDateTime = LocalDateTime.ofInstant(now, currentZone);
      System.out.println("Local date: " + localDateTime);
		
      ZonedDateTime zonedDateTime = ZonedDateTime.ofInstant(now, currentZone);
      System.out.println("Zoned date: " + zonedDateTime);
   }
}

Verifique o resultado

Compile a classe usando javac compilador da seguinte forma -

C:\JAVA>javac Java8Tester.java

Agora execute o Java8Tester da seguinte maneira -

C:\JAVA>java Java8Tester

Ele deve produzir a seguinte saída -

Current date: Wed Dec 10 05:44:06 UTC 2014
Local date: 2014-12-10T05:44:06.635
Zoned date: 2014-12-10T05:44:06.635Z[Etc/UTC]

Com o Java 8, o Base64 finalmente mereceu. Java 8 agora tem codificador e decodificador embutidos para codificação Base64. No Java 8, podemos usar três tipos de codificação Base64.

  • Simple- A saída é mapeada para um conjunto de caracteres em A-Za-z0-9 + /. O codificador não adiciona nenhuma alimentação de linha na saída e o decodificador rejeita qualquer caractere diferente de A-Za-z0-9 + /.

  • URL- A saída é mapeada para um conjunto de caracteres em A-Za-z0-9 + _. A saída é segura para URL e nome de arquivo.

  • MIME- A saída é mapeada para o formato amigável MIME. A saída é representada em linhas de no máximo 76 caracteres cada e usa um retorno de carro '\ r' seguido por um avanço de linha '\ n' como separador de linha. Nenhum separador de linha está presente no final da saída codificada.

Classes aninhadas

Sr. Não. Classe aninhada e descrição
1

static class Base64.Decoder

Esta classe implementa um decodificador para decodificar dados de byte usando o esquema de codificação Base64 conforme especificado no RFC 4648 e no RFC 2045.
2

static class Base64.Encoder

Esta classe implementa um codificador para codificar dados de byte usando o esquema de codificação Base64 conforme especificado no RFC 4648 e no RFC 2045.

Métodos

Sr. Não. Nome e descrição do método
1

static Base64.Decoder getDecoder()

Retorna um Base64.Decoder que decodifica usando o esquema de codificação de base64 do tipo Basic.
2

static Base64.Encoder getEncoder()

Retorna um Base64.Encoder que codifica usando o esquema de codificação de tipo básico base64.
3

static Base64.Decoder getMimeDecoder()

Retorna um Base64.Decoder que decodifica usando o esquema de decodificação de base64 do tipo MIME.
4

static Base64.Encoder getMimeEncoder()

Retorna um Base64.Encoder que codifica usando o esquema de codificação de base64 do tipo MIME.
5

static Base64.Encoder getMimeEncoder(int lineLength, byte[] lineSeparator)

Retorna um Base64.Encoder que codifica usando o esquema de codificação de base64 do tipo MIME com comprimento de linha e separadores de linha especificados.
6

static Base64.Decoder getUrlDecoder()

Retorna um Base64.Decoder que decodifica usando o esquema de codificação base64 do tipo seguro de URL e Nome de arquivo.
7

static Base64.Encoder getUrlEncoder()

Retorna um Base64.Encoder que codifica usando o esquema de codificação base64 do tipo seguro de URL e Nome de arquivo.

Métodos herdados

Esta classe herda métodos da seguinte classe -

  • java.lang.Object

Exemplo Base64

Crie o seguinte programa Java usando qualquer editor de sua escolha, digamos C: /> JAVA.

Java8Tester.java

import java.util.Base64;
import java.util.UUID;
import java.io.UnsupportedEncodingException;

public class HelloWorld {

   public static void main(String args[]) {

      try {
		
         // Encode using basic encoder
         String base64encodedString = Base64.getEncoder().encodeToString(
            "TutorialsPoint?java8".getBytes("utf-8"));
         System.out.println("Base64 Encoded String (Basic) :" + base64encodedString);
		
         // Decode
         byte[] base64decodedBytes = Base64.getDecoder().decode(base64encodedString);
		
         System.out.println("Original String: " + new String(base64decodedBytes, "utf-8"));
         base64encodedString = Base64.getUrlEncoder().encodeToString(
            "TutorialsPoint?java8".getBytes("utf-8"));
         System.out.println("Base64 Encoded String (URL) :" + base64encodedString);
		
         StringBuilder stringBuilder = new StringBuilder();
		
         for (int i = 0; i < 10; ++i) {
            stringBuilder.append(UUID.randomUUID().toString());
         }
		
         byte[] mimeBytes = stringBuilder.toString().getBytes("utf-8");
         String mimeEncodedString = Base64.getMimeEncoder().encodeToString(mimeBytes);
         System.out.println("Base64 Encoded String (MIME) :" + mimeEncodedString);

      } catch(UnsupportedEncodingException e) {
         System.out.println("Error :" + e.getMessage());
      }
   }
}

Verifique o resultado

Compile a classe usando javac compilador da seguinte forma -

C:\JAVA>javac Java8Tester.java

Agora execute o Java8Tester da seguinte maneira -

C:\JAVA>java Java8Tester

Ele deve produzir a seguinte saída -

Base64 Encoded String (Basic) :VHV0b3JpYWxzUG9pbnQ/amF2YTg=
Original String: TutorialsPoint?java8
Base64 Encoded String (URL) :VHV0b3JpYWxzUG9pbnQ_amF2YTg=
Base64 Encoded String (MIME) :YmU3NWY2ODktNGM5YS00ODlmLWI2MTUtZTVkOTk2YzQ1Njk1Y2EwZTg2OTEtMmRiZC00YTQ1LWJl
NTctMTI1MWUwMTk0ZWQyNDE0NDAwYjgtYTYxOS00NDY5LTllYTctNjc1YzE3YWJhZTk1MTQ2MDQz
NDItOTAyOC00ZWI0LThlOTYtZWU5YzcwNWQyYzVhMTQxMWRjYTMtY2MwNi00MzU0LTg0MTgtNGQ1
MDkwYjdiMzg2ZTY0OWU5MmUtZmNkYS00YWEwLTg0MjQtYThiOTQxNDQ2YzhhNTVhYWExZjItNjU2
Mi00YmM4LTk2ZGYtMDE4YmY5ZDZhMjkwMzM3MWUzNDMtMmQ3MS00MDczLWI0Y2UtMTQxODE0MGU5
YjdmYTVlODUxYzItN2NmOS00N2UyLWIyODQtMThlMWVkYTY4M2Q1YjE3YTMyYmItZjllMS00MTFk
LWJiM2UtM2JhYzUxYzI5OWI4
ja/tutorial
es/tutorial
de/tutorial
fr/tutorial
th/tutorial
pt/tutorial
ru/tutorial
vi/tutorial
it/tutorial
ko/tutorial
tr/tutorial
id/tutorial
pl/tutorial
hi/tutorial
japost
espost
depost
frpost
thpost
ptpost
rupost
vipost
itpost
kopost
trpost
idpost
plpost
hipost

© Copyright 2021 - 2024 | All Rights Reserved