Java 8 - Guia rápido

Java 8 - Visão Geral

O JAVA 8 é um dos principais recursos do desenvolvimento da 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

  • Expressão Lambda - Adiciona capacidade de processamento funcional ao Java.

  • Referências de método - referenciando funções por seus nomes, em vez de invocá-las diretamente. Usando funções como parâmetro.

  • Método padrão - Interface para ter implementação de método padrão.

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

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

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

  • Opcional - Ênfase nas práticas recomendadas para manipular valores null corretamente.

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

Considere o seguinte snippet 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 método sortUsingJava8 () usa a função de classificação com uma expressão lambda como parâmetro para obter os critérios de classificação.

Java 8 - Configuração do ambiente

Configuração do ambiente local

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

O 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 no seu sistema operacional.

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

Configurando o caminho para Windows 2000 / XP

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

  • Clique com o botão direito do mouse 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 ela também contenha o caminho para o executável Java. Por exemplo, se o caminho estiver atualmente definido como 'C: \ WINDOWS \ SYSTEM32', altere o caminho para 'C: \ WINDOWS \ SYSTEM32; c: \ Arquivos de Programas \ java \ jdk \ bin'.

Configurando o caminho para Windows 95/98 / ME

Supondo que você instalou 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 configurada para apontar para o local em que os binários Java foram instalados. Consulte a documentação do shell se tiver problemas para fazer isso.

Por exemplo, se você usar o bash como seu shell, adicione a seguinte linha no final do seu '.bashrc: export PATH = / caminho / para / 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 enquanto, você pode considerar um dos seguintes:

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

  • Netbeans - é um IDE Java que é de código aberto e gratuito. Pode ser baixado em https://netbeans.org/index.html .

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

Java 8 - Expressões Lambda

As expressões lambda são introduzidas no Java 8 e são apontadas como o maior recurso do Java 8. A expressão lambda facilita a programação funcional e simplifica bastante 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.

  • Declaração de tipo opcional - Não é necessário declarar o tipo de um parâmetro. O compilador pode deduzir o mesmo do valor do parâmetro.

  • Parênteses opcionais ao redor do parâmetro - Não é necessário declarar um único parâmetro entre parênteses. Para vários parâmetros, parênteses são necessários.

  • Chaves opcionais - Não é necessário usar chaves no corpo da expressão se o corpo contiver uma única instrução.

  • Palavra-chave de retorno opcional - O compilador retornará automaticamente o valor se o corpo tiver uma única expressão para retornar o valor. Chaves entre aspas são necessárias 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 o compilador javac da seguinte maneira -

C:\JAVA>javac Java8Tester.java

Agora execute o Java8Tester da seguinte maneira -

C:\JAVA>java Java8Tester

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 em linha de uma interface funcional, ou seja, uma interface com um único método. 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 do sayMessage of GreetingService.

  • A expressão Lambda elimina a necessidade de classe anônima e fornece ao Java uma capacidade de programação funcional muito simples, porém poderosa.

Escopo

Usando a expressão lambda, você pode se referir a qualquer variável final ou efetivamente variável final (que é designada apenas uma vez). A expressão lambda gera um erro de compilação, se uma variável receber um valor na 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 o compilador javac da seguinte maneira -

C:\JAVA>javac Java8Tester.java

Agora execute o Java8Tester da seguinte maneira -

C:\JAVA>java Java8Tester

Deve produzir a seguinte saída -

Hello! Mahesh

Java 8 - Referências de método

As referências de método ajudam a apontar para 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 o 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 o compilador javac da seguinte maneira -

C:\JAVA>javac Java8Tester.java

Agora execute o Java8Tester da seguinte maneira -

C:\JAVA>java Java8Tester

Deve produzir a seguinte saída -

Mahesh
Suresh
Ramesh
Naresh
Kalpesh

Java 8 - Interfaces Funcionais

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

Dada a seguir, é apresentada a lista de interfaces no Java8.
Sr. Não. Interface e descrição
1

BiConsumidor <T, U>

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

2

BiFunção <T, U, R>

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

3

BinaryOperator <T>

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

4

BiPredicado <T, U>

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

5

BooleanSupplier

Representa um fornecedor de resultados com valor booleano.

6

Consumidor <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 com valor duplo e produzindo um resultado com valor duplo.

8

DoubleConsumer

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

9

Função dupla <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 com 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 com valor duplo e produz um resultado com valor longo.

14

DoubleUnaryOperator

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

15

Função <T, R>

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

16

IntBinaryOperator

Representa uma operação em 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

Função <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 int que produz um resultado com valor int.

24

LongBinaryOperator

Representa uma operação em 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 com valor booleano) de um argumento de valor longo.

28.

LongSupplier

Representa um fornecedor de resultados de longo prazo.

29

LongToDoubleFunction

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

30

LongToIntFunction

Representa uma função que aceita um argumento de valor longo e produz um resultado com 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 com valor de objeto e com valor duplo e não retorna nenhum resultado.

33

ObjIntConsumer <T>

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

34

ObjLongConsumer <T>

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

35

Predicado <T>

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

36.

Fornecedor <T>

Representa um fornecedor de resultados.

37.

ToDoubleBiFunction <T, U>

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

38.

ToDoubleFunction <T>

Representa uma função que produz um resultado com 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 com valor longo.

42.

ToLongFunction <T>

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

43

UnaryOperator <T>

Representa uma operação em um único operando que produz um resultado do mesmo tipo que 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 é testado como 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 pela interface do Predicate, que recebe uma única entrada e retorna Boolean.

Verifique o resultado

Compile a classe usando o compilador javac da seguinte maneira -

C:\JAVA>javac Java8Tester.java

Agora execute o Java8Tester da seguinte maneira -

C:\JAVA>java Java8Tester

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 - Métodos padrão

O Java 8 introduz um novo conceito de implementação de método padrão nas interfaces. Esse recurso é adicionado para compatibilidade com versões anteriores, para 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 possuem a declaração do método 'forEach'. Portanto, adicionar esse método simplesmente interromperá as implementações da estrutura de coleta. O Java 8 introduz o método padrão para que a interface List / Collection 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!");
   }
}

Padrões múltiplos

Com funções padrão nas interfaces, existe a possibilidade de uma classe estar implementando duas interfaces com os mesmos métodos padrão. O código a seguir explica como essa ambiguidade 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 {

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

Métodos padrão estáticos

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 o compilador javac da seguinte maneira -

C:\JAVA>javac Java8Tester.java

Agora execute o Java8Tester da seguinte maneira -

C:\JAVA>java Java8Tester

Deve produzir a seguinte saída -

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

Java 8 - Fluxos

Stream é uma nova camada abstrata introduzida no Java 8. Usando o stream, é possível 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 no final 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 com vários núcleos estão disponíveis com facilidade, um desenvolvedor Java precisa escrever um processamento de código paralelo que pode ser bastante propenso a erros.

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

O que é o Stream?

O fluxo representa uma sequência de objetos de uma fonte, que suporta operações agregadas. A seguir, estão as características de um fluxo -

  • Sequência de elementos - Um fluxo fornece um conjunto de elementos de tipo específico de maneira seqüencial. Um fluxo obtém / calcula elementos sob demanda. Nunca armazena os elementos.

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

  • Operações agregadas - O Stream suporta operações agregadas como filtro, mapa, limite, redução, localização, correspondência e assim por diante.

  • Pipelining - a maioria das operações de fluxo retorna o fluxo propriamente dito para que seu resultado possa ser pipelined. Essas operações são chamadas de operações intermediárias e sua função é receber entradas, processá-las e retornar a saída ao destino. O método collect () é uma operação terminal que normalmente está presente no final da operação de tubulação para marcar o final do fluxo.

  • Iterações automáticas - As operações de fluxo executam as iterações internamente sobre os elementos de origem fornecidos, em contraste com as Coleções, nas quais é necessária uma iteração explícita.

Gerando fluxos

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

  • stream () - Retorna um fluxo seqüencial considerando a coleção como sua origem.

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

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

para cada

O fluxo forneceu um novo método 'forEach' para iterar cada elemento do fluxo. O seguinte segmento de código 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 o resultado correspondente. O seguinte segmento de código imprime quadrados únicos de números usando o 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 'filter' é usado para eliminar elementos com base em um critério. O seguinte segmento de código imprime uma contagem de cadeias vazias usando o 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 seguinte segmento de código mostra como imprimir 10 números aleatórios usando o limite.

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

ordenado

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

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

Processamento paralelo

parallelStream é a alternativa de fluxo para processamento paralelo. Dê uma olhada no seguinte segmento de código que imprime uma contagem de seqüências de caracteres 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 fluxos sequenciais e paralelos.

Colecionadores

Os coletores são usados para combinar o resultado do processamento nos elementos de um fluxo. 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 Stream

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 o compilador javac da seguinte maneira -

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

Java 8 - Classe opcional

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

Declaração de classe

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

public final class Optional<T> extends Object

Método de classe

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

estático <T> Opcional <T> vazio ()

Retorna uma instância opcional vazia.

2

iguais booleanos (Object obj)

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

3

Filtro <T> opcional (predicado <? Super <T>)

Se um valor estiver presente e o valor corresponder a um determinado predicado, ele retornará um Opcional descrevendo o valor, caso contrário, retornará um Opcional vazio.

4

<U> Opcional <U> flatMap (Função <? Super T, mapeador <U>> opcional)

Se um valor estiver presente, ele aplicará a função de mapeamento de rolamentos opcionais fornecida, retornará esse resultado, caso contrário, retornará um opcional opcional.

5

T get ()

Se um valor estiver presente neste Opcional, retornará o valor, caso contrário, lançará NoSuchElementException.

6

int hashCode ()

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

7

void ifPresent (consumidor <? super T> consumidor)

Se um valor estiver presente, ele chamará o consumidor especificado com o valor, caso contrário, não fará nada.

8

booleano isPresent ()

Retorna true se houver um valor presente, caso contrário false.

9

<U> Mapa <U> opcional (Função <? Super T ,? estende U> mapeador)

Se um valor estiver presente, aplique a função de mapeamento fornecida a ele e, se o resultado for não null , retornará um Opcional descrevendo o resultado.

10

estático <T> Opcional <T> de (valor T)

Retorna um Opcional com o valor não null presente especificado.

11

estático <T> Opcional <T> de Null capaz (valor T)

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

12

T ou outro (T outro)

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

13

T orElseGet (o fornecedor <? Estende T> outro)

Retorna o valor, se presente, caso contrário, chama outro e retorna o resultado dessa chamada.

14

<X estende Throwable> T ouElseThrow (Fornecedor <? Estende X> exceptionSupplier)

Retorna o valor contido, se presente, lança uma exceção a ser criada pelo fornecedor fornecido.

15

String toString ()

Retorna uma representação de seqüência de caracteres não vazia deste Opcional adequado para depuração.

Essa 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.of Null able - allows passed parameter to be null .
      Optional<Integer> a = Optional.of Null able(value1);
		
      //Optional.of - throws Null PointerException 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 o compilador javac da seguinte maneira -

C:\JAVA>javac Java8Tester.java

Agora execute o Java8Tester da seguinte maneira -

C:\JAVA>java Java8Tester

Deve produzir a seguinte saída -

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

Java 8 - JavaScript Nashorn

Com o Java 8, Nashorn, é introduzido um mecanismo javascript muito aprimorado, para substituir o Rhino existente. O Nashorn fornece 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 mecanismo Nashorn, o JAVA 8 apresenta uma nova ferramenta de linha de comando, jjs, para executar códigos javascript no console.

Interpretando o arquivo js

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

sample.js

print('Hello World!');

Abra o console e use o seguinte comando.

C:\JAVA>jjs sample.js

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()
>>

Argumentos de aprovação

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 o compilador javac da seguinte maneira -

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 a partir de JavaScript

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

Crie e salve sample.js na pasta c: \> 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

Deve produzir a seguinte saída -

78952000000000000003.20

Java 8 - Nova API de Data / Hora

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

  • Não é seguro para threads - java.util.Date não é seguro para threads, portanto, os desenvolvedores precisam lidar com problemas de simultaneidade enquanto usam data. A nova API de data e hora é imutável e não possui métodos de configuração.

  • Design inadequado - 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 essas operações.

  • Tratamento difícil de fuso horário - os desenvolvedores tiveram que escrever muito código para lidar com problemas de fuso horário. A nova API foi desenvolvida tendo em mente o design específico do domínio.

O 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 manipulação de fuso horário.

  • Zoneada - 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 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 o compilador javac da seguinte maneira -

C:\JAVA>javac Java8Tester.java

Agora execute o Java8Tester da seguinte maneira -

C:\JAVA>java Java8Tester

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 de data e hora com zona

A API de data e hora da zona deve ser usada quando o fuso horário for 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 o compilador javac da seguinte maneira -

C:\JAVA>javac Java8Tester.java

Agora execute o Java8Tester da seguinte maneira -

C:\JAVA>java Java8Tester

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 no 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 o compilador javac da seguinte maneira -

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 horário.

  • Período - trata da quantidade de tempo com base na data.

  • Duração - trata da quantidade de tempo com base no 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 o compilador javac da seguinte maneira -

C:\JAVA>javac Java8Tester.java

Agora execute o Java8Tester da seguinte maneira -

C:\JAVA>java Java8Tester

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 executar a matemática da data. 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 o compilador javac da seguinte maneira -

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 Data e Calendário originais, que podem ser usados para convertê-los na nova API de Data e Hora. 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 o compilador javac da seguinte maneira -

C:\JAVA>javac Java8Tester.java

Agora execute o Java8Tester da seguinte maneira -

C:\JAVA>java Java8Tester

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]

Java 8 - Base64

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

  • Simples - A saída é mapeada para um conjunto de caracteres em A-Za-z0-9 + /. O codificador não adiciona nenhum avanço de linha na saída e o decodificador rejeita qualquer caractere que não seja 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 compatível com MIME. A saída é representada em linhas com no máximo 76 caracteres cada e usa um retorno de carro '\ r' seguido de um avanço de linha '\ n' como separador de linhas. Nenhum separador de linha está presente no final da saída codificada.

Classes aninhadas

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

classe estática Base64.Decoder

Esta classe implementa um decodificador para decodificar dados de bytes usando o esquema de codificação Base64, conforme especificado nas RFC 4648 e RFC 2045.

2

classe estática Base64.Encoder

Esta classe implementa um codificador para codificar dados de bytes usando o esquema de codificação Base64, conforme especificado nas RFC 4648 e 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 base64 do tipo Basic.

2

static Base64.Encoder getEncoder ()

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

3

static Base64.Decoder getMimeDecoder ()

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

4

static Base64.Encoder getMimeEncoder ()

Retorna um Base64.Encoder que codifica usando o esquema de codificação 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 base64 do tipo MIME com comprimento de linha especificado e separadores de linha.

6

static Base64.Decoder getUrlDecoder ()

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

7

static Base64.Encoder getUrlEncoder ()

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

Métodos herdados

Essa classe herda métodos da seguinte classe -

  • java.lang.Object

Exemplo Base64

Crie o seguinte programa Java usando qualquer editor de sua escolha em 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 o compilador javac da seguinte maneira -

C:\JAVA>javac Java8Tester.java

Agora execute o Java8Tester da seguinte maneira -

C:\JAVA>java Java8Tester

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