Java 8 - Kurzanleitung

JAVA 8 ist eine wichtige Feature-Version der JAVA-Programmiersprachenentwicklung. Die erste Version wurde am 18. März 2014 veröffentlicht. Mit der Java 8-Version bot Java Unterstützung für funktionale Programmierung, neue JavaScript-Engine, neue APIs für die Manipulation von Datum und Uhrzeit, neue Streaming-API usw.

Neue Eigenschaften

• Lambda expression - Fügt Java funktionale Verarbeitungsfunktionen hinzu.

• Method references- Verweisen von Funktionen anhand ihrer Namen, anstatt sie direkt aufzurufen. Funktionen als Parameter verwenden.

• Default method - Schnittstelle für die Implementierung der Standardmethode.

• New tools - Neue Compiler-Tools und Dienstprogramme wie 'jdeps' werden hinzugefügt, um Abhängigkeiten herauszufinden.

• Stream API - Neue Stream-API zur Erleichterung der Pipeline-Verarbeitung.

• Date Time API - Verbesserte Datums- / Uhrzeit-API.

• Optional - Betonung der Best Practices für den richtigen Umgang mit Nullwerten.

• Nashorn, JavaScript Engine - Eine Java-basierte Engine zum Ausführen von JavaScript-Code.

Betrachten Sie das folgende Code-Snippet.

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));
   }
}

Führen Sie das Programm aus, um das folgende Ergebnis zu erhalten.

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

Hier das sortUsingJava8() Die Methode verwendet die Sortierfunktion mit einem Lambda-Ausdruck als Parameter, um die Sortierkriterien abzurufen.

Einrichtung der lokalen Umgebung

Wenn Sie eine eigene Umgebung für die Programmiersprache Java einrichten möchten, führt Sie dieser Abschnitt durch den gesamten Prozess. Führen Sie die folgenden Schritte aus, um Ihre Java-Umgebung einzurichten.

Java SE kann kostenlos über den folgenden Link heruntergeladen werden:

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

Sie laden eine Version herunter, die auf Ihrem Betriebssystem basiert.

Befolgen Sie die Anweisungen, um Java herunterzuladen, und führen Sie die aus .exeum Java auf Ihrem Computer zu installieren. Sobald Sie Java auf Ihrem Computer installiert haben, müssen Sie Umgebungsvariablen so einstellen, dass sie auf korrekte Installationsverzeichnisse verweisen.

Einrichten des Pfads für Windows 2000 / XP

Angenommen, Sie haben Java im Verzeichnis c: \ Programme \ java \ jdk installiert -

• Klicken Sie mit der rechten Maustaste auf "Arbeitsplatz" und wählen Sie "Eigenschaften".

• Klicken Sie auf der Registerkarte "Erweitert" auf die Schaltfläche "Umgebungsvariablen".

• Ändern Sie nun die Variable 'Path' so, dass sie auch den Pfad zur ausführbaren Java-Datei enthält. Wenn der Pfad derzeit auf "C: \ WINDOWS \ SYSTEM32" festgelegt ist, ändern Sie Ihren Pfad in "C: \ WINDOWS \ SYSTEM32; c: \ Programme \ java \ jdk \ bin".

Einrichten des Pfads für Windows 95/98 / ME

Angenommen, Sie haben Java im Verzeichnis c: \ Programme \ java \ jdk installiert -

• Bearbeiten Sie die Datei 'C: \ autoexec.bat' und fügen Sie am Ende die folgende Zeile hinzu:

  SET PATH =% PATH%; C: \ Programme \ java \ jdk \ bin

Einrichten des Pfads für Linux, UNIX, Solaris, FreeBSD

Die Umgebungsvariable PATH sollte so eingestellt sein, dass sie darauf verweist, wo die Java-Binärdateien installiert wurden. Informationen hierzu finden Sie in Ihrer Shell-Dokumentation.

Wenn Sie beispielsweise bash als Shell verwenden, fügen Sie am Ende Ihrer '.bashrc: export PATH = / path / to / java: $ PATH' die folgende Zeile hinzu.

Beliebte Java-Editoren

Zum Schreiben von Java-Programmen benötigen Sie einen Texteditor. Es gibt noch ausgefeiltere IDEs auf dem Markt. Im Moment können Sie jedoch eine der folgenden Möglichkeiten in Betracht ziehen:

• Notepad - Auf einem Windows-Computer können Sie einen einfachen Texteditor wie Notepad (empfohlen für dieses Tutorial) oder TextPad verwenden.

• Netbeans- Es ist eine Java-IDE, die Open Source und kostenlos ist. Es kann von heruntergeladen werdenhttps://netbeans.org/index.html.

• Eclipse - Es ist auch eine Java-IDE, die von der Open-Source-Community von Eclipse entwickelt wurde und von heruntergeladen werden kann https://www.eclipse.org/.

Lambda-Ausdrücke werden in Java 8 eingeführt und als das größte Merkmal von Java 8 angepriesen. Der Lambda-Ausdruck erleichtert die funktionale Programmierung und vereinfacht die Entwicklung erheblich.

Syntax

Ein Lambda-Ausdruck ist durch die folgende Syntax gekennzeichnet.

parameter -> expression body

Es folgen die wichtigen Merkmale eines Lambda-Ausdrucks.

• Optional type declaration- Der Typ eines Parameters muss nicht deklariert werden. Der Compiler kann aus dem Wert des Parameters dasselbe ableiten.

• Optional parenthesis around parameter- Es ist nicht erforderlich, einen einzelnen Parameter in Klammern zu deklarieren. Für mehrere Parameter sind Klammern erforderlich.

• Optional curly braces - Es ist nicht erforderlich, geschweifte Klammern im Ausdruckskörper zu verwenden, wenn der Körper eine einzelne Anweisung enthält.

• Optional return keyword- Der Compiler gibt den Wert automatisch zurück, wenn der Body einen einzelnen Ausdruck hat, um den Wert zurückzugeben. Geschweifte Klammern sind erforderlich, um anzuzeigen, dass der Ausdruck einen Wert zurückgibt.

Beispiel für Lambda-Ausdrücke

Erstellen Sie das folgende Java-Programm mit einem Editor Ihrer Wahl, z. B. in 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);
   }
}

Überprüfen Sie das Ergebnis

Kompilieren Sie die Klasse mit javac Compiler wie folgt -

C:\JAVA>javac Java8Tester.java

Führen Sie nun den Java8Tester wie folgt aus:

C:\JAVA>java Java8Tester

Es sollte die folgende Ausgabe erzeugen -

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

Im Folgenden sind die wichtigen Punkte aufgeführt, die im obigen Beispiel zu berücksichtigen sind.

• Lambda-Ausdrücke werden hauptsächlich verwendet, um die Inline-Implementierung einer funktionalen Schnittstelle zu definieren, dh einer Schnittstelle mit nur einer einzigen Methode. Im obigen Beispiel haben wir verschiedene Arten von Lambda-Ausdrücken verwendet, um die Operationsmethode der MathOperation-Schnittstelle zu definieren. Dann haben wir die Implementierung von sayMessage of GreetingService definiert.

• Der Lambda-Ausdruck macht anonyme Klassen überflüssig und bietet Java eine sehr einfache und dennoch leistungsstarke funktionale Programmierfunktion.

Umfang

Mit dem Lambda-Ausdruck können Sie auf jede endgültige Variable oder effektiv endgültige Variable verweisen (die nur einmal zugewiesen wird). Der Lambda-Ausdruck löst einen Kompilierungsfehler aus, wenn einer Variablen beim zweiten Mal ein Wert zugewiesen wird.

Anwendungsbereichsbeispiel

Erstellen Sie das folgende Java-Programm mit einem Editor Ihrer Wahl, z. B. in 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);
   }
}

Überprüfen Sie das Ergebnis

Kompilieren Sie die Klasse mit javac Compiler wie folgt -

C:\JAVA>javac Java8Tester.java

Führen Sie nun den Java8Tester wie folgt aus:

C:\JAVA>java Java8Tester

Es sollte die folgende Ausgabe erzeugen -

Hello! Mahesh

Methodenreferenzen helfen dabei, Methoden anhand ihrer Namen anzuzeigen. Eine Methodenreferenz wird mit dem Symbol "::" beschrieben. Eine Methodenreferenz kann verwendet werden, um die folgenden Arten von Methoden aufzuzeigen:

• Statische Methoden
• Instanzmethoden
• Konstruktoren mit neuem Operator (TreeSet :: new)

Methodenreferenzbeispiel

Erstellen Sie das folgende Java-Programm mit einem Editor Ihrer Wahl, z. B. in 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);
   }
}

Hier haben wir die System.out :: println-Methode als statische Methodenreferenz übergeben.

Überprüfen Sie das Ergebnis

Kompilieren Sie die Klasse mit javac Compiler wie folgt -

C:\JAVA>javac Java8Tester.java

Führen Sie nun den Java8Tester wie folgt aus:

C:\JAVA>java Java8Tester

Es sollte die folgende Ausgabe erzeugen -

Mahesh
Suresh
Ramesh
Naresh
Kalpesh

Funktionale Schnittstellen weisen eine einzige Funktionalität auf. Zum Vergleich wird beispielsweise eine vergleichbare Schnittstelle mit einer einzelnen Methode 'compareTo' verwendet. Java 8 hat viele funktionale Schnittstellen definiert, die häufig in Lambda-Ausdrücken verwendet werden. Im Folgenden finden Sie eine Liste der im Paket java.util.Function definierten Funktionsschnittstellen.

Im Folgenden finden Sie eine Liste der Schnittstellen in Java8.

Sr.Nr.	Schnittstelle & Beschreibung
1	BiConsumer<T,U> Stellt eine Operation dar, die zwei Eingabeargumente akzeptiert und kein Ergebnis zurückgibt.
2	BiFunction<T,U,R> Stellt eine Funktion dar, die zwei Argumente akzeptiert und ein Ergebnis erzeugt.
3	BinaryOperator<T> Stellt eine Operation für zwei Operanden desselben Typs dar und erzeugt ein Ergebnis desselben Typs wie die Operanden.
4	BiPredicate<T,U> Stellt ein Prädikat (Boolesche Funktion) von zwei Argumenten dar.
5	BooleanSupplier Repräsentiert einen Lieferanten von Booleschen Ergebnissen.
6	Consumer<T> Stellt eine Operation dar, die ein einzelnes Eingabeargument akzeptiert und kein Ergebnis zurückgibt.
7	DoubleBinaryOperator Stellt eine Operation für zwei doppelwertige Operanden dar und erzeugt ein doppeltwertiges Ergebnis.
8	DoubleConsumer Stellt eine Operation dar, die ein einzelnes doppelwertiges Argument akzeptiert und kein Ergebnis zurückgibt.
9	DoubleFunction<R> Stellt eine Funktion dar, die ein doppeltwertiges Argument akzeptiert und ein Ergebnis erzeugt.
10	DoublePredicate Stellt ein Prädikat (Boolesche Funktion) eines doppeltwertigen Arguments dar.
11	DoubleSupplier Repräsentiert einen Lieferanten mit doppelt bewerteten Ergebnissen.
12	DoubleToIntFunction Stellt eine Funktion dar, die ein doppeltwertiges Argument akzeptiert und ein intwertiges Ergebnis erzeugt.
13	DoubleToLongFunction Stellt eine Funktion dar, die ein doppeltwertiges Argument akzeptiert und ein langwertiges Ergebnis erzeugt.
14	DoubleUnaryOperator Stellt eine Operation für einen einzelnen doppelwertigen Operanden dar, der ein doppeltwertiges Ergebnis erzeugt.
15	Function<T,R> Stellt eine Funktion dar, die ein Argument akzeptiert und ein Ergebnis erzeugt.
16	IntBinaryOperator Stellt eine Operation für zwei Operanden mit int-Werten dar und erzeugt ein Ergebnis mit int-Werten.
17	IntConsumer Stellt eine Operation dar, die ein einzelnes Argument mit int-Wert akzeptiert und kein Ergebnis zurückgibt.
18	IntFunction<R> Stellt eine Funktion dar, die ein Argument mit int-Wert akzeptiert und ein Ergebnis erzeugt.
19	IntPredicate Repräsentiert ein Prädikat (Boolesche Funktion) eines int-wertigen Arguments.
20	IntSupplier Repräsentiert einen Lieferanten von int-bewerteten Ergebnissen.
21	IntToDoubleFunction Stellt eine Funktion dar, die ein Argument mit int-Wert akzeptiert und ein doppeltwertiges Ergebnis erzeugt.
22	IntToLongFunction Stellt eine Funktion dar, die ein Argument mit int-Wert akzeptiert und ein Ergebnis mit langem Wert erzeugt.
23	IntUnaryOperator Stellt eine Operation für einen einzelnen Operanden mit int-Wert dar, die ein Ergebnis mit int-Wert erzeugt.
24	LongBinaryOperator Stellt eine Operation für zwei langwertige Operanden dar und erzeugt ein langwertiges Ergebnis.
25	LongConsumer Stellt eine Operation dar, die ein einzelnes langwertiges Argument akzeptiert und kein Ergebnis zurückgibt.
26	LongFunction<R> Stellt eine Funktion dar, die ein langwertiges Argument akzeptiert und ein Ergebnis erzeugt.
27	LongPredicate Stellt ein Prädikat (Boolesche Funktion) eines langwertigen Arguments dar.
28	LongSupplier Repräsentiert einen Lieferanten von langjährigen Ergebnissen.
29	LongToDoubleFunction Stellt eine Funktion dar, die ein langwertiges Argument akzeptiert und ein doppeltwertiges Ergebnis erzeugt.
30	LongToIntFunction Stellt eine Funktion dar, die ein langwertiges Argument akzeptiert und ein intwertiges Ergebnis erzeugt.
31	LongUnaryOperator Stellt eine Operation für einen einzelnen langwertigen Operanden dar, der ein langwertiges Ergebnis erzeugt.
32	ObjDoubleConsumer<T> Stellt eine Operation dar, die ein Objektwert- und ein Doppelwertargument akzeptiert und kein Ergebnis zurückgibt.
33	ObjIntConsumer<T> Stellt eine Operation dar, die ein Objektwert- und ein Int-Wert-Argument akzeptiert und kein Ergebnis zurückgibt.
34	ObjLongConsumer<T> Stellt eine Operation dar, die ein objektwertiges und ein langwertiges Argument akzeptiert und kein Ergebnis zurückgibt.
35	Predicate<T> Stellt ein Prädikat (Boolesche Funktion) eines Arguments dar.
36	Supplier<T> Repräsentiert einen Lieferanten von Ergebnissen.
37	ToDoubleBiFunction<T,U> Stellt eine Funktion dar, die zwei Argumente akzeptiert und ein doppeltwertiges Ergebnis erzeugt.
38	ToDoubleFunction<T> Stellt eine Funktion dar, die ein doppeltwertiges Ergebnis erzeugt.
39	ToIntBiFunction<T,U> Stellt eine Funktion dar, die zwei Argumente akzeptiert und ein int-wertiges Ergebnis erzeugt.
40	ToIntFunction<T> Stellt eine Funktion dar, die ein int-wertiges Ergebnis erzeugt.
41	ToLongBiFunction<T,U> Stellt eine Funktion dar, die zwei Argumente akzeptiert und ein langwertiges Ergebnis liefert.
42	ToLongFunction<T> Stellt eine Funktion dar, die ein langwertiges Ergebnis erzeugt.
43	UnaryOperator<T> Stellt eine Operation für einen einzelnen Operanden dar, die ein Ergebnis des gleichen Typs wie sein Operand erzeugt.

Beispiel für eine funktionale Schnittstelle

Die Prädikat-Schnittstelle <T> ist eine funktionale Schnittstelle mit einem Methodentest (Objekt), um einen Booleschen Wert zurückzugeben. Diese Schnittstelle zeigt an, dass ein Objekt auf wahr oder falsch getestet wird.

Erstellen Sie das folgende Java-Programm mit einem Editor Ihrer Wahl, z. B. in 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 + " ");
         }
      }
   }
}

Hier haben wir die Predicate-Schnittstelle übergeben, die eine einzelne Eingabe akzeptiert und Boolean zurückgibt.

Überprüfen Sie das Ergebnis

Kompilieren Sie die Klasse mit javac Compiler wie folgt -

C:\JAVA>javac Java8Tester.java

Führen Sie nun den Java8Tester wie folgt aus:

C:\JAVA>java Java8Tester

Es sollte die folgende Ausgabe erzeugen -

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 führt ein neues Konzept für die Implementierung von Standardmethoden in Schnittstellen ein. Diese Funktion wurde aus Gründen der Abwärtskompatibilität hinzugefügt, sodass alte Schnittstellen verwendet werden können, um die Lambda-Ausdrucksfunktion von Java 8 zu nutzen.

Beispielsweise haben die Schnittstellen 'List' oder 'Collection' keine Methodendeklaration 'forEach'. Wenn Sie eine solche Methode hinzufügen, werden die Implementierungen des Sammlungsframeworks einfach unterbrochen. Java 8 führt die Standardmethode ein, sodass die List / Collection-Schnittstelle eine Standardimplementierung der forEach-Methode haben kann und die Klasse, die diese Schnittstellen implementiert, diese nicht implementieren muss.

Syntax

public interface vehicle {

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

Mehrere Standardeinstellungen

Bei Standardfunktionen in Schnittstellen besteht die Möglichkeit, dass eine Klasse zwei Schnittstellen mit denselben Standardmethoden implementiert. Der folgende Code erklärt, wie diese Mehrdeutigkeit behoben werden kann.

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!");
   }
}

Die erste Lösung besteht darin, eine eigene Methode zu erstellen, die die Standardimplementierung überschreibt.

public class car implements vehicle, fourWheeler {

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

Die zweite Lösung besteht darin, die Standardmethode der angegebenen Schnittstelle mit super aufzurufen.

public class car implements vehicle, fourWheeler {

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

Statische Standardmethoden

Eine Schnittstelle kann ab Java 8 auch statische Hilfsmethoden enthalten.

public interface vehicle {

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

Beispiel für eine Standardmethode

Erstellen Sie das folgende Java-Programm mit einem Editor Ihrer Wahl, z. B. in 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!");
   }
}

Überprüfen Sie das Ergebnis

Kompilieren Sie die Klasse mit javac Compiler wie folgt -

C:\JAVA>javac Java8Tester.java

Führen Sie nun den Java8Tester wie folgt aus:

C:\JAVA>java Java8Tester

Es sollte die folgende Ausgabe erzeugen -

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

Stream ist eine neue abstrakte Ebene, die in Java 8 eingeführt wurde. Mit stream können Sie Daten auf deklarative Weise ähnlich wie SQL-Anweisungen verarbeiten. Betrachten Sie beispielsweise die folgende SQL-Anweisung.

SELECT max(salary), employee_id, employee_name FROM Employee

Der obige SQL-Ausdruck gibt automatisch die Details des maximal angestellten Mitarbeiters zurück, ohne dass der Entwickler eine Berechnung durchführt. Bei Verwendung des Sammlungsframeworks in Java muss ein Entwickler Schleifen verwenden und wiederholte Überprüfungen durchführen. Ein weiteres Problem ist die Effizienz. Da Multi-Core-Prozessoren problemlos verfügbar sind, muss ein Java-Entwickler eine parallele Codeverarbeitung schreiben, die sehr fehleranfällig sein kann.

Um solche Probleme zu beheben, führte Java 8 das Konzept des Streams ein, mit dem der Entwickler Daten deklarativ verarbeiten und die Multicore-Architektur nutzen kann, ohne dafür einen bestimmten Code schreiben zu müssen.

Was ist Stream?

Stream repräsentiert eine Folge von Objekten aus einer Quelle, die Aggregatoperationen unterstützt. Im Folgenden sind die Merkmale eines Streams aufgeführt:

• Sequence of elements- Ein Stream stellt nacheinander eine Reihe von Elementen eines bestimmten Typs bereit. Ein Stream erhält / berechnet Elemente nach Bedarf. Es speichert niemals die Elemente.

• Source - Stream verwendet Sammlungen, Arrays oder E / A-Ressourcen als Eingabequelle.

• Aggregate operations - Stream unterstützt aggregierte Vorgänge wie Filtern, Zuordnen, Begrenzen, Reduzieren, Suchen, Übereinstimmen usw.

• Pipelining- Die meisten Stream-Vorgänge geben den Stream selbst zurück, damit das Ergebnis weitergeleitet werden kann. Diese Operationen werden als Zwischenoperationen bezeichnet. Ihre Funktion besteht darin, Eingaben zu übernehmen, sie zu verarbeiten und Ausgaben an das Ziel zurückzugeben. Die Methode collect () ist eine Terminaloperation, die normalerweise am Ende der Pipelining-Operation vorhanden ist, um das Ende des Streams zu markieren.

• Automatic iterations - Stream-Operationen führen die Iterationen intern über die bereitgestellten Quellelemente aus, im Gegensatz zu Sammlungen, bei denen eine explizite Iteration erforderlich ist.

Streams generieren

Mit Java 8 verfügt die Collection-Schnittstelle über zwei Methoden zum Generieren eines Streams.

• stream() - Gibt einen sequentiellen Stream zurück, der die Sammlung als Quelle betrachtet.

• parallelStream() - Gibt einen parallelen Stream zurück, der die Sammlung als Quelle betrachtet.

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

für jeden

Stream hat eine neue Methode 'forEach' bereitgestellt, um jedes Element des Streams zu iterieren. Das folgende Codesegment zeigt, wie 10 Zufallszahlen mit forEach gedruckt werden.

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

Karte

Die 'map'-Methode wird verwendet, um jedes Element dem entsprechenden Ergebnis zuzuordnen. Das folgende Codesegment druckt eindeutige Zahlenquadrate mithilfe der Karte.

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

Filter

Die 'Filter'-Methode wird verwendet, um Elemente basierend auf einem Kriterium zu entfernen. Das folgende Codesegment druckt eine Anzahl leerer Zeichenfolgen mithilfe des Filters.

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

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

Grenze

Die 'Limit'-Methode wird verwendet, um die Größe des Streams zu reduzieren. Das folgende Codesegment zeigt, wie 10 Zufallszahlen mit limit gedruckt werden.

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

sortiert

Die 'sortierte' Methode wird verwendet, um den Stream zu sortieren. Das folgende Codesegment zeigt, wie 10 Zufallszahlen in sortierter Reihenfolge gedruckt werden.

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

Parallelverarbeitung

parallelStream ist die Alternative des Streams für die parallele Verarbeitung. Schauen Sie sich das folgende Codesegment an, das mit parallelStream eine Anzahl leerer Zeichenfolgen druckt.

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

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

Es ist sehr einfach, zwischen sequentiellen und parallelen Streams zu wechseln.

Sammler

Kollektoren werden verwendet, um das Ergebnis der Verarbeitung für die Elemente eines Streams zu kombinieren. Collectors können verwendet werden, um eine Liste oder eine Zeichenfolge zurückzugeben.

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

Statistiken

Mit Java 8 werden Statistiksammler eingeführt, um alle Statistiken zu berechnen, wenn die Stream-Verarbeitung durchgeführt wird.

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

Stream-Beispiel

Erstellen Sie das folgende Java-Programm mit einem Editor Ihrer Wahl, z. B. in 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();
   }
}

Überprüfen Sie das Ergebnis

Kompilieren Sie die Klasse mit javac Compiler wie folgt -

C:\JAVA>javac Java8Tester.java

Führen Sie nun den Java8Tester wie folgt aus:

C:\JAVA>java Java8Tester

Es sollte das folgende Ergebnis liefern -

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

Optional ist ein Containerobjekt, das Nicht-Null-Objekte enthält. Das optionale Objekt wird verwendet, um Null mit fehlendem Wert darzustellen. Diese Klasse verfügt über verschiedene Dienstprogrammmethoden, mit denen Code Werte als "verfügbar" oder "nicht verfügbar" behandeln kann, anstatt Nullwerte zu überprüfen. Es wird in Java 8 eingeführt und ähnelt dem, was Optional in Guava ist.

Klassenerklärung

Es folgt die Erklärung für java.util.Optional<T> Klasse -

public final class Optional<T> extends Object

Klassenmethode

Sr.Nr.	Methode & Beschreibung
1	static <T> Optional<T> empty() Gibt eine leere optionale Instanz zurück.
2	boolean equals(Object obj) Gibt an, ob ein anderes Objekt dieser Option "entspricht".
3	Optional<T> filter(Predicate<? super <T> predicate) Wenn ein Wert vorhanden ist und der Wert mit einem bestimmten Prädikat übereinstimmt, wird ein Optional zurückgegeben, das den Wert beschreibt, andernfalls wird ein leeres Optional zurückgegeben.
4	<U> Optional<U> flatMap(Function<? super T,Optional<U>> mapper) Wenn ein Wert vorhanden ist, wendet er die bereitgestellte optionale Lagerzuordnungsfunktion auf ihn an, gibt dieses Ergebnis zurück, andernfalls wird ein leeres optionales zurückgegeben.
5	T get() Wenn in dieser Option ein Wert vorhanden ist, wird der Wert zurückgegeben, andernfalls wird eine NoSuchElementException ausgelöst.
6	int hashCode() Gibt den Hashcode-Wert des aktuellen Werts zurück, falls vorhanden, oder 0 (Null), wenn kein Wert vorhanden ist.
7	void ifPresent(Consumer<? super T> consumer) Wenn ein Wert vorhanden ist, ruft er den angegebenen Verbraucher mit dem Wert auf, andernfalls wird nichts unternommen.
8	boolean isPresent() Gibt true zurück, wenn ein Wert vorhanden ist, andernfalls false.
9	<U>Optional<U> map(Function<? super T,? extends U> mapper) Wenn ein Wert vorhanden ist, wird die bereitgestellte Zuordnungsfunktion auf ihn angewendet. Wenn das Ergebnis nicht null ist, wird eine Option zurückgegeben, die das Ergebnis beschreibt.
10	static <T> Optional<T> of(T value) Gibt ein Optional mit dem angegebenen aktuellen Wert ungleich Null zurück.
11	static <T> Optional<T> ofNullable(T value) Gibt eine Option zurück, die den angegebenen Wert beschreibt, wenn sie nicht null ist. Andernfalls wird eine leere Option zurückgegeben.
12	T orElse(T other) Gibt den Wert zurück, falls vorhanden, andernfalls wird ein anderer zurückgegeben.
13	T orElseGet(Supplier<? extends T> other) Gibt den Wert zurück, falls vorhanden, ruft andernfalls other auf und gibt das Ergebnis dieses Aufrufs zurück.
14	<X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) Gibt den enthaltenen Wert zurück, falls vorhanden, andernfalls wird eine Ausnahme ausgelöst, die vom angegebenen Lieferanten erstellt werden soll.
15	String toString() Gibt eine nicht leere Zeichenfolgendarstellung dieser Option zurück, die zum Debuggen geeignet ist.

Diese Klasse erbt Methoden von der folgenden Klasse:

• java.lang.Object

Optionales Beispiel

Erstellen Sie das folgende Java-Programm mit einem Editor Ihrer Wahl, z. B. in 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;
   }
}

Überprüfen Sie das Ergebnis

Kompilieren Sie die Klasse mit javac Compiler wie folgt -

C:\JAVA>javac Java8Tester.java

Führen Sie nun den Java8Tester wie folgt aus:

C:\JAVA>java Java8Tester

Es sollte die folgende Ausgabe erzeugen -

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

Mit Java 8, Nashorn, wird eine stark verbesserte Javascript-Engine eingeführt, die das vorhandene Rhino ersetzt. Nashorn bietet eine zwei- bis zehnmal bessere Leistung, da es den Code direkt im Speicher kompiliert und den Bytecode an JVM weitergibt. Nashorn verwendet die in Java 7 eingeführte Funktion zum Aufrufen der Dynamik, um die Leistung zu verbessern.

jjs

Für die Nashorn-Engine führt JAVA 8 ein neues Befehlszeilentool ein: jjs, um Javascript-Codes an der Konsole auszuführen.

Js-Datei interpretieren

Erstellen und speichern Sie die Datei sample.js im Ordner c: \> JAVA.

sample.js

print('Hello World!');

Öffnen Sie die Konsole und verwenden Sie den folgenden Befehl.

C:\JAVA>jjs sample.js

Es wird die folgende Ausgabe erzeugt:

Hello World!

jjs im interaktiven Modus

Öffnen Sie die Konsole und verwenden Sie den folgenden Befehl.

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

Argumente übergeben

Öffnen Sie die Konsole und verwenden Sie den folgenden Befehl.

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

JavaScript von Java aus aufrufen

Mit ScriptEngineManager kann JavaScript-Code in Java aufgerufen und interpretiert werden.

Beispiel

Erstellen Sie das folgende Java-Programm mit einem Editor Ihrer Wahl, z. B. in 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());
   }
}

Überprüfen Sie das Ergebnis

Kompilieren Sie die Klasse mit javac Compiler wie folgt -

C:\JAVA>javac Java8Tester.java

Führen Sie nun den Java8Tester wie folgt aus:

C:\JAVA>java Java8Tester

Es sollte das folgende Ergebnis liefern -

Mahesh
12

Java über JavaScript aufrufen

Im folgenden Beispiel wird erläutert, wie Sie Java-Klassen in Java-Skripten importieren und verwenden.

Erstellen und speichern sample.js im Ordner 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);

Öffnen Sie die Konsole und verwenden Sie den folgenden Befehl.

C:\JAVA>jjs sample.js

Es sollte die folgende Ausgabe erzeugen -

78952000000000000003.20

Mit Java 8 wird eine neue Datums- / Uhrzeit-API eingeführt, um die folgenden Nachteile der alten Datums- / Uhrzeit-API abzudecken.

• Not thread safe- java.util.Date ist nicht threadsicher, daher müssen Entwickler bei der Verwendung von date Probleme mit der Parallelität lösen. Die neue Datums- / Uhrzeit-API ist unveränderlich und verfügt nicht über Setter-Methoden.

• Poor design- Das Standarddatum beginnt bei 1900, der Monat beginnt bei 1 und der Tag beginnt bei 0, also keine Einheitlichkeit. Die alte API hatte weniger direkte Methoden für Datumsoperationen. Die neue API bietet zahlreiche Dienstprogrammmethoden für solche Vorgänge.

• Difficult time zone handling- Entwickler mussten viel Code schreiben, um Zeitzonenprobleme zu lösen. Die neue API wurde unter Berücksichtigung des domänenspezifischen Designs entwickelt.

Java 8 führt eine neue Datums- / Uhrzeit-API unter dem Paket java.time ein. Im Folgenden finden Sie einige wichtige Klassen, die im Paket java.time eingeführt wurden.

• Local - Vereinfachte Datums- / Uhrzeit-API ohne Komplexität der Zeitzonenbehandlung.

• Zoned - Spezielle Datums- / Uhrzeit-API für verschiedene Zeitzonen.

Lokale Datums- / Uhrzeit-API

Die Klassen LocalDate / LocalTime und LocalDateTime vereinfachen die Entwicklung, wenn keine Zeitzonen erforderlich sind. Lassen Sie uns sie in Aktion sehen.

Erstellen Sie das folgende Java-Programm mit einem Editor Ihrer Wahl, z. B. in 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);
   }
}

Überprüfen Sie das Ergebnis

Kompilieren Sie die Klasse mit javac Compiler wie folgt -

C:\JAVA>javac Java8Tester.java

Führen Sie nun den Java8Tester wie folgt aus:

C:\JAVA>java Java8Tester

Es sollte die folgende Ausgabe erzeugen -

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

Zoned Date-Time API

Die zonierte Datums- / Uhrzeit-API ist zu verwenden, wenn die Zeitzone berücksichtigt werden soll. Lassen Sie uns sie in Aktion sehen.

Erstellen Sie das folgende Java-Programm mit einem Editor Ihrer Wahl, z. B. in 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);
   }
}

Überprüfen Sie das Ergebnis

Kompilieren Sie die Klasse mit javac Compiler wie folgt -

C:\JAVA>javac Java8Tester.java

Führen Sie nun den Java8Tester wie folgt aus:

C:\JAVA>java Java8Tester

Es sollte die folgende Ausgabe erzeugen -

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

Chrono Units Enum

Die Aufzählung java.time.temporal.ChronoUnit wurde in Java 8 hinzugefügt, um die in der alten API verwendeten Ganzzahlwerte für Tag, Monat usw. zu ersetzen. Lassen Sie uns sie in Aktion sehen.

Erstellen Sie das folgende Java-Programm mit einem Editor Ihrer Wahl, z. B. in 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);
   }
}

Überprüfen Sie das Ergebnis

Kompilieren Sie die Klasse mit javac Compiler wie folgt -

C:\JAVA>javac Java8Tester.java

Führen Sie nun den Java8Tester wie folgt aus:

C:\JAVA>java Java8Tester

Es sollte das folgende Ergebnis liefern -

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

Zeitraum und Dauer

Mit Java 8 werden zwei spezielle Klassen eingeführt, um die Zeitunterschiede zu behandeln.

• Period - Es handelt sich um eine datumsbasierte Zeitdauer.

• Duration - Es befasst sich mit zeitbasierter Zeit.

Lassen Sie uns sie in Aktion sehen.

Erstellen Sie das folgende Java-Programm mit einem Editor Ihrer Wahl, z. B. in 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);
   }
}

Überprüfen Sie das Ergebnis

Kompilieren Sie die Klasse mit javac Compiler wie folgt -

C:\JAVA>javac Java8Tester.java

Führen Sie nun den Java8Tester wie folgt aus:

C:\JAVA>java Java8Tester

Es sollte die folgende Ausgabe erzeugen -

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

Zeitliche Einsteller

TemporalAdjuster wird verwendet, um die Datumsmathematik durchzuführen. Holen Sie sich zum Beispiel den "zweiten Samstag des Monats" oder "nächsten Dienstag". Lassen Sie uns sie in Aktion sehen.

Erstellen Sie das folgende Java-Programm mit einem Editor Ihrer Wahl, z. B. in 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);
   }
}

Überprüfen Sie das Ergebnis

Kompilieren Sie die Klasse mit javac Compiler wie folgt -

C:\JAVA>javac Java8Tester.java

Führen Sie nun den Java8Tester wie folgt aus:

C:\JAVA>java Java8Tester

Es sollte das folgende Ergebnis liefern -

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

Rückwärtskompatibilität

Den ursprünglichen Datums- und Kalenderobjekten wird eine toInstant () -Methode hinzugefügt, mit der sie in die neue Datums- / Uhrzeit-API konvertiert werden können. Verwenden Sie eine ofInstant-Methode (Insant, ZoneId), um ein LocalDateTime- oder ZonedDateTime-Objekt abzurufen. Lassen Sie uns sie in Aktion sehen.

Erstellen Sie das folgende Java-Programm mit einem Editor Ihrer Wahl, z. B. in 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);
   }
}

Überprüfen Sie das Ergebnis

Kompilieren Sie die Klasse mit javac Compiler wie folgt -

C:\JAVA>javac Java8Tester.java

Führen Sie nun den Java8Tester wie folgt aus:

C:\JAVA>java Java8Tester

Es sollte die folgende Ausgabe erzeugen -

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]

Mit Java 8 ist Base64 endlich fällig. Java 8 verfügt jetzt über einen integrierten Codierer und Decodierer für die Base64-Codierung. In Java 8 können drei Arten der Base64-Codierung verwendet werden.

• Simple- Die Ausgabe wird einer Reihe von Zeichen zugeordnet, die in A-Za-z0-9 + / liegen. Der Codierer fügt keinen Zeilenvorschub in die Ausgabe ein, und der Decodierer lehnt andere Zeichen als A-Za-z0-9 + / ab.

• URL- Die Ausgabe wird einer Reihe von Zeichen zugeordnet, die in A-Za-z0-9 + _ liegen. Die Ausgabe ist URL- und Dateinamensicher.

• MIME- Die Ausgabe ist dem MIME-freundlichen Format zugeordnet. Die Ausgabe wird in Zeilen mit jeweils maximal 76 Zeichen dargestellt und verwendet einen Zeilenumbruch '\ r' gefolgt von einem Zeilenvorschub '\ n' als Zeilentrennzeichen. Am Ende der codierten Ausgabe ist kein Zeilentrennzeichen vorhanden.

Verschachtelte Klassen

Sr.Nr.	Verschachtelte Klasse & Beschreibung
1	static class Base64.Decoder Diese Klasse implementiert einen Decoder zum Decodieren von Byte-Daten unter Verwendung des Base64-Codierungsschemas, wie in RFC 4648 und RFC 2045 angegeben.
2	static class Base64.Encoder Diese Klasse implementiert einen Codierer zum Codieren von Byte-Daten unter Verwendung des Base64-Codierungsschemas, wie in RFC 4648 und RFC 2045 angegeben.

Methoden

Sr.Nr.	Methodenname & Beschreibung
1	static Base64.Decoder getDecoder() Gibt einen Base64.Decoder zurück, der mit dem Base64-Codierungsschema vom Basistyp decodiert.
2	static Base64.Encoder getEncoder() Gibt einen Base64.Encoder zurück, der mit dem Base64-Codierungsschema vom Basistyp codiert.
3	static Base64.Decoder getMimeDecoder() Gibt einen Base64.Decoder zurück, der mit dem Base64-Decodierungsschema vom MIME-Typ decodiert.
4	static Base64.Encoder getMimeEncoder() Gibt einen Base64.Encoder zurück, der mit dem Base64-Codierungsschema vom Typ MIME codiert.
5	static Base64.Encoder getMimeEncoder(int lineLength, byte[] lineSeparator) Gibt einen Base64.Encoder zurück, der unter Verwendung des Base64-Codierungsschemas vom MIME-Typ mit angegebener Zeilenlänge und Zeilentrennzeichen codiert.
6	static Base64.Decoder getUrlDecoder() Gibt einen Base64.Decoder zurück, der mit dem Base64-Codierungsschema URL und Dateiname sicher codiert.
7	static Base64.Encoder getUrlEncoder() Gibt einen Base64.Encoder zurück, der mit dem Base64-Codierungsschema URL und Dateiname sicher codiert.

Vererbte Methoden

Diese Klasse erbt Methoden von der folgenden Klasse:

• java.lang.Object

Base64 Beispiel

Erstellen Sie das folgende Java-Programm mit einem beliebigen Editor Ihrer Wahl in 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());
      }
   }
}

Überprüfen Sie das Ergebnis

Kompilieren Sie die Klasse mit javac Compiler wie folgt -

C:\JAVA>javac Java8Tester.java

Führen Sie nun den Java8Tester wie folgt aus:

C:\JAVA>java Java8Tester

Es sollte die folgende Ausgabe erzeugen -

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