home Herstellungstechnologie Produktionsanlagen
Industrielle Fertigung
Industrielles Internet der Dinge | Industrielle Materialien | Gerätewartung und Reparatur | Industrielle Programmierung |
home  MfgRobots >> Industrielle Fertigung >  >> Industrial programming >> Java

Java 8 – Kurzanleitung

Java 8 - Übersicht

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

Neue Funktionen

Betrachten Sie das folgende Code-Snippet.

Live-Demo
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() Methode verwendet die Sortierfunktion mit einem Lambda-Ausdruck als Parameter, um die Sortierkriterien zu erhalten.

Java 8 - Einrichtung der Umgebung

Einrichtung der lokalen Umgebung

Wenn Sie Ihre eigene Umgebung für die Programmiersprache Java einrichten möchten, führt Sie dieser Abschnitt durch den gesamten Prozess. Bitte befolgen Sie die nachstehenden Schritte, um Ihre Java-Umgebung einzurichten.

Java SE kann kostenlos unter folgendem Link heruntergeladen werden −

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

Sie laden eine auf Ihrem Betriebssystem basierende Version herunter.

Befolgen Sie die Anweisungen zum Herunterladen von Java und führen Sie die .exe aus um Java auf Ihrem Rechner zu installieren. Sobald Sie Java auf Ihrem Rechner installiert haben, müssen Sie Umgebungsvariablen so setzen, dass sie auf die richtigen Installationsverzeichnisse zeigen.

Pfad für Windows 2000/XP einrichten

Angenommen, Sie haben Java im Verzeichnis c:\Program Files\java\jdk −

installiert

Pfad für Windows 95/98/ME einrichten

Angenommen, Sie haben Java im Verzeichnis c:\Program Files\java\jdk −

installiert

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

Die Umgebungsvariable PATH sollte so gesetzt werden, dass sie auf den Ort zeigt, an dem die Java-Binärdateien installiert wurden. Sehen Sie in Ihrer Shell-Dokumentation nach, wenn Sie dabei Probleme haben.

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

Um Java-Programme zu schreiben, benötigen Sie einen Texteditor. Es gibt sogar noch ausgefeiltere IDEs auf dem Markt. Aber jetzt können Sie eine der folgenden Überlegungen anstellen −

Java 8 - Lambda-Ausdrücke

Lambda-Ausdrücke werden in Java 8 eingeführt und gelten als das größte Feature von Java 8. Lambda-Ausdrücke erleichtern die funktionale Programmierung und vereinfachen die Entwicklung erheblich.

Syntax

Ein Lambda-Ausdruck ist durch die folgende Syntax gekennzeichnet.

parameter -> expression body

Im Folgenden sind die wichtigen Merkmale eines Lambda-Ausdrucks aufgeführt.

Beispiel für Lambda-Ausdrücke

Erstellen Sie das folgende Java-Programm mit einem beliebigen Editor Ihrer Wahl in beispielsweise C:\> JAVA.

Java8Tester.java

Live-Demo
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 berücksichtigt werden müssen.

Geltungsbereich

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

Umfangsbeispiel

Erstellen Sie das folgende Java-Programm mit einem beliebigen Editor Ihrer Wahl in beispielsweise C:\> JAVA.

Java8Tester.java

Live-Demo
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

Java 8 - Methodenreferenzen

Methodenreferenzen helfen, auf Methoden anhand ihrer Namen zu verweisen. Eine Methodenreferenz wird mit dem Symbol „::“ beschrieben. Eine Methodenreferenz kann verwendet werden, um auf die folgenden Arten von Methoden zu verweisen −

Methodenreferenzbeispiel

Erstellen Sie das folgende Java-Programm mit einem beliebigen Editor Ihrer Wahl in beispielsweise 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 Methode System.out::println 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

Java 8 - Funktionale Schnittstellen

Funktionale Schnittstellen müssen eine einzige Funktionalität aufweisen. Beispielsweise wird eine Comparable-Schnittstelle mit einer einzigen Methode „compareTo“ zu Vergleichszwecken verwendet. Java 8 hat viele funktionale Schnittstellen definiert, die umfassend in Lambda-Ausdrücken verwendet werden können. Es folgt die Liste der funktionalen Schnittstellen, die im java.util.Function-Paket definiert sind.


Sr.No. Schnittstelle &Beschreibung
1

BiConsumer

Stellt eine Operation dar, die zwei Eingabeargumente akzeptiert und kein Ergebnis zurückgibt.
2

BiFunction

Stellt eine Funktion dar, die zwei Argumente akzeptiert und ein Ergebnis erzeugt.
3

BinaryOperator

Stellt eine Operation mit zwei Operanden desselben Typs dar, die ein Ergebnis desselben Typs wie die Operanden erzeugt.
4

BiPredicate

Repräsentiert ein Prädikat (boolesche Funktion) aus zwei Argumenten.
5

BooleanSupplier

Stellt einen Anbieter von Ergebnissen mit booleschen Werten dar.
6

Verbraucher

Stellt eine Operation dar, die ein einzelnes Eingabeargument akzeptiert und kein Ergebnis zurückgibt.
7

DoubleBinaryOperator

Stellt eine Operation mit zwei doppelwertigen Operanden dar und erzeugt ein doppelwertiges Ergebnis.
8

DoubleConsumer

Stellt eine Operation dar, die ein einzelnes zweiwertiges Argument akzeptiert und kein Ergebnis zurückgibt.
9

DoubleFunction

Stellt eine Funktion dar, die ein zweiwertiges Argument akzeptiert und ein Ergebnis erzeugt.
10

DoublePredicate

Stellt ein Prädikat (boolesche Funktion) eines zweiwertigen Arguments dar.
11

DoubleSupplier

Stellt einen Anbieter von zweiwertigen Ergebnissen dar.
12

DoubleToIntFunction

Stellt eine Funktion dar, die ein zweiwertiges Argument akzeptiert und ein ganzzahliges Ergebnis erzeugt.
13

DoubleToLongFunction

Stellt eine Funktion dar, die ein zweiwertiges Argument akzeptiert und ein langwertiges Ergebnis erzeugt.
14

DoubleUnaryOperator

Stellt eine Operation an einem einzelnen zweiwertigen Operanden dar, die ein zweiwertiges Ergebnis erzeugt.
15

Funktion

Stellt eine Funktion dar, die ein Argument akzeptiert und ein Ergebnis erzeugt.
16

IntBinaryOperator

Stellt eine Operation mit zwei ganzzahligen Operanden dar und erzeugt ein ganzzahliges Ergebnis.
17

IntConsumer

Stellt eine Operation dar, die ein einzelnes ganzzahliges Argument akzeptiert und kein Ergebnis zurückgibt.
18

IntFunction

Stellt eine Funktion dar, die ein ganzzahliges Argument akzeptiert und ein Ergebnis erzeugt.
19

IntPredicate

Stellt ein Prädikat (boolesche Funktion) eines ganzzahligen Arguments dar.
20

IntLieferant

Stellt einen Anbieter von int-Wert-Ergebnissen dar.
21

IntToDoubleFunction

Stellt eine Funktion dar, die ein ganzzahliges Argument akzeptiert und ein zweiwertiges Ergebnis erzeugt.
22

IntToLongFunction

Stellt eine Funktion dar, die ein ganzzahliges Argument akzeptiert und ein langwertiges Ergebnis erzeugt.
23

IntUnaryOperator

Stellt eine Operation mit einem einzelnen ganzzahligen Operanden dar, der ein ganzzahliges Ergebnis erzeugt.
24

LongBinaryOperator

Stellt eine Operation mit zwei langwertigen Operanden dar und erzeugt ein langwertiges Ergebnis.
25

LongConsumer

Stellt eine Operation dar, die ein einzelnes Argument mit langem Wert akzeptiert und kein Ergebnis zurückgibt.
26

LongFunction

Stellt eine Funktion dar, die ein langwertiges Argument akzeptiert und ein Ergebnis erzeugt.
27

LongPredicate

Stellt ein Prädikat (boolesche Funktion) eines Arguments mit langem Wert dar.
28

LongSupplier

Stellt einen Lieferanten von langgeschätzten Ergebnissen dar.
29

LongToDoubleFunction

Stellt eine Funktion dar, die ein langwertiges Argument akzeptiert und ein zweiwertiges Ergebnis erzeugt.
30

LongToIntFunction

Stellt eine Funktion dar, die ein langwertiges Argument akzeptiert und ein ganzzahliges Ergebnis erzeugt.
31

LongUnaryOperator

Stellt eine Operation an einem einzelnen langwertigen Operanden dar, die ein langwertiges Ergebnis erzeugt.
32

ObjDoubleConsumer

Stellt eine Operation dar, die ein objektwertiges und ein doppelwertiges Argument akzeptiert und kein Ergebnis zurückgibt.
33

ObjIntConsumer

Stellt eine Operation dar, die ein objektwertiges und ein ganzzahliges Argument akzeptiert und kein Ergebnis zurückgibt.
34

ObjLongConsumer

Stellt eine Operation dar, die ein objektwertiges und ein langwertiges Argument akzeptiert und kein Ergebnis zurückgibt.
35

Prädikat

Stellt ein Prädikat (boolesche Funktion) eines Arguments dar.
36

Lieferant

Stellt einen Ergebnislieferanten dar.
37

ToDoubleBiFunction

Stellt eine Funktion dar, die zwei Argumente akzeptiert und ein zweiwertiges Ergebnis erzeugt.
38

ToDoubleFunction

Stellt eine Funktion dar, die ein zweiwertiges Ergebnis erzeugt.
39

ToIntBiFunction

Stellt eine Funktion dar, die zwei Argumente akzeptiert und ein ganzzahliges Ergebnis erzeugt.
40

ToIntFunction

Stellt eine Funktion dar, die ein ganzzahliges Ergebnis erzeugt.
41

ToLongBiFunction

Stellt eine Funktion dar, die zwei Argumente akzeptiert und ein langwertiges Ergebnis erzeugt.
42

ToLongFunction

Stellt eine Funktion dar, die ein Ergebnis mit langen Werten erzeugt.
43

UnaryOperator

Stellt eine Operation an einem einzelnen Operanden dar, die ein Ergebnis desselben Typs wie sein Operand erzeugt.

Beispiel einer funktionalen Schnittstelle

Die Predicate -Schnittstelle ist eine funktionale Schnittstelle mit einer Methode test(Object), 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 beliebigen Editor Ihrer Wahl in beispielsweise C:\> JAVA.

Java8Tester.java

Live-Demo
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 - Standardmethoden

Java 8 führt ein neues Konzept der 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.

„List“- oder „Collection“-Schnittstellen haben beispielsweise keine „forEach“-Methodendeklaration. Daher wird das Hinzufügen einer solchen Methode einfach die Implementierungen des Sammlungsframeworks unterbrechen. 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, nicht dieselbe 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 aufgelöst 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 haben.

public interface vehicle {

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

Beispiel für Standardmethode

Erstellen Sie das folgende Java-Programm mit einem beliebigen Editor Ihrer Wahl in beispielsweise C:\> JAVA.

Java8Tester.java

Live-Demo
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!

Java 8 - Streams

Stream ist eine neue abstrakte Schicht, die in Java 8 eingeführt wurde. Mit Stream können Sie Daten ähnlich wie bei SQL-Anweisungen deklarativ 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 bezahlten Mitarbeiters zurück, ohne Berechnungen auf Seiten des Entwicklers durchzuführen. Bei Verwendung des Sammlungs-Frameworks in Java muss ein Entwickler Schleifen verwenden und wiederholte Prüfungen durchführen. Ein weiteres Anliegen ist die Effizienz; Da Mehrkernprozessoren ohne weiteres verfügbar sind, muss ein Java-Entwickler eine parallele Codeverarbeitung schreiben, die ziemlich fehleranfällig sein kann.

Um solche Probleme zu lösen, wurde mit Java 8 das Stream-Konzept eingeführt, das es dem Entwickler ermöglicht, Daten deklarativ zu verarbeiten und die Multicore-Architektur zu nutzen, ohne dafür speziellen Code schreiben zu müssen.

Was ist Stream?

Stream stellt eine Sequenz von Objekten aus einer Quelle dar, die Aggregatoperationen unterstützt. Im Folgenden sind die Merkmale eines Streams aufgeführt:−

Streams generieren

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

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 durchlaufen. Das folgende Codesegment zeigt, wie 10 Zufallszahlen mit forEach ausgegeben werden.

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

Karte

Die „map“-Methode wird verwendet, um jedes Element seinem entsprechenden Ergebnis zuzuordnen. Das folgende Codesegment druckt mithilfe von map.

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

filtern

Die „Filter“-Methode wird verwendet, um Elemente basierend auf einem Kriterium zu eliminieren. Das folgende Codesegment gibt mithilfe von filter.

eine Anzahl leerer Zeichenfolgen aus 
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 man 10 Zufallszahlen mit limit.

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

sortiert

Die Sortiermethode wird verwendet, um den Stream zu sortieren. Das folgende Codesegment zeigt, wie 10 Zufallszahlen in sortierter Reihenfolge ausgegeben werden.

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

Parallele Verarbeitung

parallelStream ist die Alternative von stream für parallele Verarbeitung. Sehen Sie sich das folgende Codesegment an, das mithilfe von parallelStream eine Anzahl leerer Zeichenfolgen ausgibt.

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 umzuschalten.

Sammler

Kollektoren werden verwendet, um das Ergebnis der Verarbeitung der Elemente eines Streams zu kombinieren. Kollektoren können verwendet werden, um eine Liste oder einen String 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 beliebigen Editor Ihrer Wahl in beispielsweise C:\> JAVA.

Java8Tester.java

Live-Demo
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 erzeugen −

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 – Optionale Klasse

Optional ist ein Containerobjekt, das verwendet wird, um Nicht-Null-Objekte zu enthalten. Optionales Objekt wird verwendet, um null mit fehlendem Wert darzustellen. Diese Klasse verfügt über verschiedene Hilfsmethoden, um Code zu erleichtern, Werte als „verfügbar“ oder „nicht verfügbar“ zu behandeln, anstatt Nullwerte zu prüfen. Es wurde in Java 8 eingeführt und ähnelt dem, was Optional in Guava ist.

Klassenerklärung

Es folgt die Deklaration für java.util.Optional Klasse −

public final class Optional<T> extends Object

Klassenmethode

Sr.No. Methode &Beschreibung
1

statisch Optional leer()

Gibt eine leere optionale Instanz zurück.
2

boolean equals(Object obj)

Gibt an, ob ein anderes Objekt "gleich" diesem Optional ist.
3

Optional filter(Prädikat Prädikat)

Wenn ein Wert vorhanden ist und der Wert mit einem gegebenen Prädikat übereinstimmt, wird ein Optional zurückgegeben, das den Wert beschreibt, andernfalls wird ein leeres Optional zurückgegeben.
4

Optional flatMap(Function> mapper)

Wenn ein Wert vorhanden ist, wendet es die bereitgestellte Zuordnungsfunktion für optionale Werte darauf an, gibt dieses Ergebnis zurück, andernfalls gibt es ein leeres Optional zurück.
5

T get()

Wenn ein Wert in diesem Optional vorhanden ist, wird der Wert zurückgegeben, andernfalls wird NoSuchElementException ausgelöst.
6

int hashCode()

Gibt den Hashcodewert des aktuellen Werts zurück, falls vorhanden, oder 0 (Null), wenn kein Wert vorhanden ist.
7

void ifPresent(Consumerconsumer)

Wenn ein Wert vorhanden ist, ruft es den angegebenen Verbraucher mit dem Wert auf, ansonsten tut es nichts.
8

boolean isPresent()

Gibt true zurück, wenn ein Wert vorhanden ist, andernfalls false.
9

Optional map(Funktion mapper)

Wenn ein Wert vorhanden ist, wendet die bereitgestellte Zuordnungsfunktion darauf an, und wenn das Ergebnis nicht null ist, gibt es ein Optional zurück, das das Ergebnis beschreibt.
10

statisches Optional von (T-Wert)

Gibt ein Optional mit dem angegebenen vorhandenen Nicht-Null-Wert zurück.
11

statisches Optional vonNullable(T-Wert)

Gibt ein Optional zurück, das den angegebenen Wert beschreibt, falls nicht null, ansonsten ein leeres Optional.
12

T orElse(T andere)

Gibt den Wert zurück, falls vorhanden, ansonsten other.
13

T orElseGet(Lieferantanderes)

Gibt den Wert zurück, falls vorhanden, ruft andernfalls other auf und gibt das Ergebnis dieses Aufrufs zurück.
14

T orElseThrow(Supplier exceptionSupplier)

Gibt den enthaltenen Wert zurück, falls vorhanden, löst andernfalls eine Ausnahme aus, die vom bereitgestellten Lieferanten erstellt wird.
15

String zuString()

Gibt eine nicht-leere Zeichenfolgendarstellung dieser Option zurück, die zum Debuggen geeignet ist.

Diese Klasse erbt Methoden von der folgenden Klasse −

Optionales Beispiel

Erstellen Sie das folgende Java-Programm mit einem beliebigen Editor Ihrer Wahl in beispielsweise C:\> JAVA.

Java8Tester.java

Live-Demo
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

Java 8 - Nashorn-JavaScript

Mit Java 8, Nashorn, wird eine stark verbesserte Javascript-Engine eingeführt, um das vorhandene Rhino zu ersetzen. Nashorn bietet eine 2- bis 10-mal bessere Leistung, da es den Code direkt im Speicher kompiliert und den Bytecode an JVM übergibt. Nashorn verwendet die in Java 7 eingeführte Invoke Dynamics-Funktion, um die Leistung zu verbessern.

jjs

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

JS-Datei interpretieren

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

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>

Aufruf von JavaScript aus Java

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

Beispiel

Erstellen Sie das folgende Java-Programm mit einem beliebigen Editor Ihrer Wahl in beispielsweise C:\> JAVA.

Java8Tester.java

Live-Demo
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 erzeugen −

Mahesh
12

Aufruf von Java aus JavaScript

Das folgende Beispiel erläutert, wie Java-Klassen in Java-Script importiert und verwendet werden.

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

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

Java 8 – Neue Datums-/Uhrzeit-API

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

Java 8 führt eine neue Datum-Zeit-API unter dem Paket java.time ein. Im Folgenden sind einige der wichtigen Klassen aufgeführt, die im java.time-Paket eingeführt wurden.

Lokale Datum-Uhrzeit-API

Die Klassen LocalDate/LocalTime und LocalDateTime vereinfachen die Entwicklung, wenn keine Zeitzonen erforderlich sind. Sehen wir sie uns in Aktion an.

Erstellen Sie das folgende Java-Programm mit einem beliebigen Editor Ihrer Wahl in beispielsweise C:\> JAVA.

Java8Tester.java

Live-Demo
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

Zonierte Datum-Uhrzeit-API

Wenn die Zeitzone berücksichtigt werden soll, muss die gezonte Datum-Uhrzeit-API verwendet werden. Lassen Sie uns sie in Aktion sehen.

Erstellen Sie das folgende Java-Programm mit einem beliebigen Editor Ihrer Wahl in beispielsweise C:\> JAVA.

Java8Tester.java

Live-Demo
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-Einheiten-Aufzählung

java.time.temporal.ChronoUnit enum wurde in Java 8 hinzugefügt, um die Ganzzahlwerte zu ersetzen, die in der alten API verwendet wurden, um Tag, Monat usw. darzustellen. Sehen wir sie uns in Aktion an.

Erstellen Sie das folgende Java-Programm mit einem beliebigen Editor Ihrer Wahl in beispielsweise C:\> JAVA.

Java8Tester.java

Live-Demo
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 erzeugen −

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 spezialisierte Klassen eingeführt, um mit den Zeitunterschieden umzugehen.

Lassen Sie uns sie in Aktion sehen.

Erstellen Sie das folgende Java-Programm mit einem beliebigen Editor Ihrer Wahl in beispielsweise C:\> JAVA.

Java8Tester.java

Live-Demo
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 Justierer

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

Erstellen Sie das folgende Java-Programm mit einem beliebigen Editor Ihrer Wahl in beispielsweise C:\> JAVA.

Java8Tester.java

Live-Demo
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 erzeugen −

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

Abwärtskompatibilität

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

Erstellen Sie das folgende Java-Programm mit einem beliebigen Editor Ihrer Wahl in beispielsweise C:\> JAVA.

Java8Tester.java

Live-Demo
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]

Java 8 - Base64

Mit Java 8 hat Base64 endlich seine Fälligkeit bekommen. Java 8 verfügt jetzt über einen integrierten Encoder und Decoder für die Base64-Codierung. In Java 8 können wir drei Typen der Base64-Codierung verwenden.

Verschachtelte Klassen

Sr.No. Verschachtelte Klasse &Beschreibung
1

statische Klasse Base64.Decoder

Diese Klasse implementiert einen Decoder zum Decodieren von Bytedaten unter Verwendung des Base64-Codierungsschemas, wie in RFC 4648 und RFC 2045 angegeben.
2

statische Klasse Base64.Encoder

Diese Klasse implementiert einen Encoder zum Codieren von Bytedaten unter Verwendung des Base64-Codierungsschemas, wie in RFC 4648 und RFC 2045 angegeben.

Methoden

Sr.No. Name und Beschreibung der Methode
1

Statischer Base64.Decoder getDecoder()

Gibt einen Base64.Decoder zurück, der mit dem base64-Codierungsschema des Basic-Typs decodiert.
2

Statischer Base64.Encoder getEncoder()

Gibt einen Base64.Encoder zurück, der mit dem base64-Codierungsschema des Basic-Typs codiert.
3

Statischer Base64.Decoder getMimeDecoder()

Gibt einen Base64.Decoder zurück, der mithilfe des base64-Decodierungsschemas des MIME-Typs decodiert.
4

Statischer Base64.Encoder getMimeEncoder()

Gibt einen Base64.Encoder zurück, der mit dem base64-Codierungsschema des MIME-Typs codiert.
5

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

Gibt einen Base64.Encoder zurück, der mit dem Base64-Codierungsschema des MIME-Typs mit angegebener Zeilenlänge und Zeilentrennzeichen codiert.
6

Statischer Base64.Decoder getUrlDecoder()

Gibt einen Base64.Decoder zurück, der unter Verwendung des URL- und Dateinamen-sicheren base64-Codierungsschemas decodiert.
7

Statischer Base64.Encoder getUrlEncoder()

Gibt einen Base64.Encoder zurück, der mit dem URL- und Dateinamen-sicheren base64-Codierungsschema codiert.

Übernommene Methoden

Diese Klasse erbt Methoden von der folgenden Klasse −

Base64-Beispiel

Erstellen Sie das folgende Java-Programm mit einem beliebigen Editor Ihrer Wahl in beispielsweise C:/> JAVA.

Java8Tester.java

Live-Demo
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

Java

  • C Sprache
  • VHDL
  • Verilog
  • MATLAB
  • Python
  • Java
    1. Java-Vektor
    2. Fräsen – Eine Kurzanleitung
    3. Kurzanleitung zur PM-Entwicklung und -Ausführung
    4. Eine Kurzanleitung zur Versicherung bei Lieferkettenunterbrechungen
    5. Eine Kurzanleitung zur Vierkantrohrbiegemaschine
    6. Eine Kurzanleitung zur Kaltpressmaschine
    7. Eine Kurzanleitung zum Planetengetriebe
    8. Eine Kurzanleitung zum Jet Mill Drill
    9. Eine Kurzanleitung zur Servopressmaschine
    10. Eine Kurzanleitung zu Pneumatikzylindern