"Java ist immer noch nicht tot - und die Leute fangen an, das herauszufinden."
In diesem Tutorial wird einfacher kommentierter Code verwendet, um neue Funktionen zu beschreiben, und Sie sehen keinen Blockbuster -Text.
1. Die Standardmethode der Schnittstelle
Java 8 ermöglicht es uns, der Schnittstelle eine nichtabstrakte Methode zu fördern. Verwenden Sie einfach das Standard-Schlüsselwort.
Die Codekopie lautet wie folgt:
Schnittstellenformel {
doppelt berechnen (int a);
Standard doppelt sqrt (int a) {
return math.sqrt (a);
}
}
Zusätzlich zu einer berechneten Methode definiert die Formelschnittstelle auch die SQRT -Methode.
Die Codekopie lautet wie folgt:
Formel formel = new formel () {
@Override
public double berechnen (int a) {
return sqrt (a * 100);
}
};
Formel.Calculate (100);
Formel.SQRT (16);
Die Formel im Artikel wird als Instanz einer anonymen Klasse implementiert. Im nächsten Abschnitt werden wir einen einfacheren Ansatz zur Implementierung einer einzelnen Methodenschnittstelle sehen.
Anmerkung des Übersetzers: In Java gibt es nur ein einzelnes Vererbung. In anderen Sprachen wird die Methode einer Klasse gleichzeitig als Mixin bezeichnet. Dieses neue Java 8 -Special ist aus der Perspektive der Compiler -Implementierung näher an Scalas Merkmal. Es gibt auch ein Konzept, das in C#als Erweiterungsmethode bezeichnet wird und die vorhandene Typen erweitert werden kann, was sich semantisch von diesem in Java 8 unterscheidet.
2. Lambda -Ausdrücke
Lassen Sie uns zunächst einen Blick darauf werfen, wie Saiten in der alten Version von Java angeordnet sind:
Die Codekopie lautet wie folgt:
Liste <String> names = arrays.aslist ("Peter", "Anna", "Mike", "Xenia");
Collectionss.sort (Namen, neuer Komparator <string> () {
@Override
public int compare (Zeichenfolge A, Zeichenfolge b) {
return b.comPareto (a);
}
});
Übergeben Sie einfach ein Listenobjekt und einen Komparator an die statische Methodensammlung. SORT, um es in der angegebenen Reihenfolge zu ordnen. Es wird normalerweise getan, um ein anonymes Komparatorobjekt zu erstellen und an die Sortiermethode weiterzugeben.
In Java 8 müssen Sie diese traditionelle Methode nicht anonymer Objekte verwenden.
Die Codekopie lautet wie folgt:
Collectionss.sort (Namen, (Zeichenfolge A, Zeichenfolge B) -> {
return b.comPareto (a);
});
Sehen Sie, der Code wird segmentierter und lesbarer, kann aber tatsächlich kürzer geschrieben werden:
Die Codekopie lautet wie folgt:
Collectionss.sort (Namen, (Zeichenfolge A, String B) -> b.comPareto (a));
Für den Funktionskörper mit nur einer Codezeile können Sie die Klammern {} entfernen und Schlüsselwörter zurückgeben, sie können sie jedoch kürzer schreiben:
Die Codekopie lautet wie folgt:
Collections.sort (Namen, (a, b) -> b.comPareto (a));
Der Java -Compiler kann automatisch Parametertypen ableiten, sodass Sie den Typ nicht erneut schreiben müssen. Lassen Sie uns als nächstes sehen, was bequemere Lambda -Ausdrücke tun können:
A. Funktionale Schnittstelle
Wie werden Lambda -Ausdrücke in Javas Typsystem dargestellt? Jeder Lambda -Ausdruck entspricht einem Typ, normalerweise einem Schnittstellentyp. "Funktionale Schnittstelle" bezieht sich auf eine Schnittstelle, die nur eine abstrakte Methode enthält, und jeder Lambda -Expression dieses Typs wird mit dieser abstrakten Methode übereinstimmen. Da die Standardmethode keine abstrakte Methode ist, können Sie Ihrer funktionalen Schnittstelle auch Standardmethoden hinzufügen.
Wir können Lambda -Ausdrücke als Schnittstellentyp behandeln, die nur eine abstrakte Methode enthält, um sicherzustellen, dass Ihre Schnittstelle diese Anforderung erfüllen muss. In Annotation wird der Compiler festgestellt, dass die Schnittstelle, mit der Sie gekennzeichnet sind, durch diese Annotation einen Fehler erfolgt, wenn mehr als eine abstrakte Methode vorliegt.
Beispiele sind wie folgt:
Die Codekopie lautet wie folgt:
@FunctionalInterface
Schnittstellenkonverter <f, t> {
T konvertieren (f von);
}
Converter <String, Integer> Converter = (von) -> Integer.Valueof (von);
Integer konvertiert = konverter.convert ("123");
System.out.println (konvertiert);
Es ist zu beachten, dass der obige Code auch korrekt ist, wenn @FunctionalInterface nicht angegeben ist.
Die Note des Übersetzers meldet Lambda-Ausdrücke auf eine einzelne Methode. Funktion.
4. Methode und Konstruktorreferenz
Der Code im vorherigen Abschnitt kann auch durch statische Methodenreferenzen dargestellt werden:
Die Codekopie lautet wie folgt:
Converter <String, Integer> Converter = Integer :: ValueOf;
Integer konvertiert = konverter.convert ("123");
System.out.println (konvertiert);
Mit Java 8 können Sie das :: Keyword verwenden, um eine Methode oder eine Konstruktorreferenz zu übergeben.
Die Codekopie lautet wie folgt:
Converter = etwas :: starten;
String konvertiert = konverter.convert ("java");
System.out.println (konvertiert);
Schauen wir uns an, wie Konstruktoren mit dem :: Keyword verwiesen werden.
Die Codekopie lautet wie folgt:
Klassenperson {
String FirstName;
String LastName;
Person () {}
Person (String FirstName, String LastName) {
this.firstname = FirstName;
this.lastName = LastName;
}
}
Als nächstes geben wir eine Objektfabrik -Schnittstelle an, um Personenobjekte zu erstellen:
Die Codekopie lautet wie folgt:
Schnittstelle Personfactory <p erweitert Person> {
P create (String FirstName, String Nachname);
}
Hier verwenden wir Konstruktorreferenzen, um sie zu verbinden, anstatt eine vollständige Fabrik zu implementieren:
Die Codekopie lautet wie folgt:
PersonFactory <Person> personFactory = Person :: New;
Person Person = PersonFactory.create ("Peter", "Parker");
Wir müssen nur Person verwenden :: Neu, um einen Verweis auf den Konstruktor der Personklasse zu erhalten.
5. Lambda Scope
Der Weg, um auf äußere Bereiche in Lambda -Ausdrücken zuzugreifen, ähnelt der in älteren Versionen anonymer Objekte. Sie können direkt auf externe lokale Variablen zugreifen, die endgültig markiert sind, oder Felder und statische Variablen der Instanz.
6. Zugriff auf lokale Variablen zugreifen
Wir können in Lambda -Ausdrücken direkt auf externe lokale Variablen zugreifen:
Die Codekopie lautet wie folgt:
endgültig int num = 1;
Converter <Integer, String> StringConverter =
(von) -> String.Valueof (aus + num);
StringConverter.Convert (2);
Aber im Gegensatz zu anonymen Objekten kann die Variable Num hier als endgültig deklariert werden, ohne sie als endgültig zu erklären, und der Code ist auch korrekt:
Die Codekopie lautet wie folgt:
int num = 1;
Converter <Integer, String> StringConverter =
(von) -> String.Valueof (aus + num);
StringConverter.Convert (2);
Num hier darf jedoch nicht durch den nachfolgenden Code geändert werden (dh implizit endgültige Semantik), beispielsweise kann Folgendes nicht kompiliert werden:
Die Codekopie lautet wie folgt:
int num = 1;
Converter <Integer, String> StringConverter =
(von) -> String.Valueof (aus + num);
Num = 3;
Der Versuch, die NUM in Lambda -Ausdrücken zu ändern, ist ebenfalls nicht zulässig.
7. Zugriffsobjekte und statische Variablen zugreifen
Im Gegensatz zu lokalen Variablen können die Felder und statischen Variablen innerhalb des Lambda gelesen und geschrieben werden. Dieses Verhalten stimmt mit anonymen Objekten überein:
Kopieren Sie den Code wie folgt: Klasse Lambda4 {
statische Int OuterstaticNum;
int outernum;
void testScopes () {
Converter <Integer, String> StringConverter1 = (von) -> {
outernum = 23;
return String.Valueof (von);
};
Converter <Integer, String> StringConverter2 = (von) -> {
outerstaticnum = 72;
return String.Valueof (von);
};
}
}
8. Die Standardmethode zum Zugriff auf die Schnittstelle
Denken Sie an das Formel -Beispiel im ersten Abschnitt.
Die Standardmethode kann im Lambda -Ausdruck nicht zugegriffen werden, und der folgende Code wird nicht kompiliert:
Die Codekopie lautet wie folgt:
Formel formel = (a) -> sqrt (a * 100);
Integrierte funktionale Schnittstellen
Die JDK 1.8-API enthält viele integrierte funktionale Schnittstellen, wie z. B. Komparator- oder Runnable-Schnittstellen, die üblicherweise in alter Java verwendet werden, und diese Schnittstellen haben @FunctionalInterface-Annotation auf Lambdas hinzugefügt.
Die Java 8 -API bietet auch viele neue funktionale Schnittstellen, um bequemer zu werden.
Prädikatschnittstelle
Die Prädikatschnittstelle hat nur einen Parameter, der den Booleschen Typ zurückgibt. Diese Schnittstelle enthält eine Reihe von Standardmethoden, um das Prädikat in andere komplexe Logiken zu kombinieren (z. B. gegen oder, oder nicht):
Die Codekopie lautet wie folgt:
Prädikat <string> predicate = (s) -> sength ()> 0;
Predict.test ("foo");
Predict.negate (). Test ("foo");
Prädikat <boolean> nonnull = Objekte :: nonnull;
Prädikat <boolean> isnull = Objekte :: isnull;
Prädikat <string> isEmpty = string :: isEmpty;
Prädikat <string> isnotEmpty = isEmpty.negate ();
Funktionsschnittstelle
Die Funktionsschnittstelle hat einen Parameter und gibt ein Ergebnis zurück und enthält einige Standardmethoden (komponieren und dhen), die mit anderen Funktionen kombiniert werden können:
Die Codekopie lautet wie folgt:
Funktion <String, Integer> toIteger = Integer :: ValueOf;
Funktion <String, String> BackToString = tointEger.andThen (string :: valueOf);
BackToString.Apply ("123");
Lieferantenschnittstelle
Die Lieferantenschnittstelle gibt einen Wert eines beliebigen Typs zurück.
Die Codekopie lautet wie folgt:
Lieferant <person> personsupplier = Person :: neu;
personsupplier.get ();
Verbraucherschnittstelle
Die Verbraucherschnittstelle repräsentiert den Vorgang, der auf einem einzelnen Parameter ausgeführt wird.
Die Codekopie lautet wie folgt:
Consumer <Person> Begrüßer = (p) -> System.out.println ("Hallo", + p.firstname);
Begrüßer.Accept (neue Person ("Luke", "Skywalker");
Komparatorschnittstelle
Comparator ist eine klassische Schnittstelle in Old Java, und Java 8 hat eine Vielzahl von Standardmethoden hinzugefügt:
Die Codekopie lautet wie folgt:
Comparator <Person> vergleicher = (p1, p2) -> p1.firstname.comPareto (p2.firstname);
Person p1 = neue Person ("John", "doe");
Person p2 = neue Person ("Alice", "Wunderland");
Comparator.comPare (P1, P2);
Comparator.ceversed (). Compare (p1, p2);
Optionale Schnittstelle
Optional ist keine Funktion, sondern eine Schnittstelle.
Optional ist definiert als ein einfacher Behälter, dessen Wert null sein kann oder nicht. Vor Java 8 sollte eine Funktion im Allgemeinen ein nicht leeres Objekt zurückgeben, aber gelegentlich kann sie in Java 8 zurückkehren.
Die Codekopie lautet wie folgt:
Optional <string> optional = optional.of ("bam");
optional.isspresent ();
optional.get ();
optional.orelse ("Fallback");
optional.ifpresent ((s) -> system.out.println (S. charat (0)));
Stream -Schnittstelle
java.util.stream repräsentiert eine Abfolge von Operationen, die auf eine Reihe von Elementen gleichzeitig angewendet werden können. Stream -Operationen sind in zwei Arten unterteilt: Zwischenvorgänge oder endgültige Operationen. Die Erstellung von Stream erfordert die Angabe einer Datenquelle, wie z. Streamoperationen können seriell oder parallel ausgeführt werden.
Sehen wir uns zunächst an, wie Stream verwendet wird.
Die Codekopie lautet wie folgt:
Liste <String> stringCollection = new ArrayList <> ();
StringCollection.add ("ddd2");
StringCollection.Add ("aaa2");
StringCollection.add ("BBB1");
StringCollection.add ("AAA1");
StringCollection.add ("BBB3");
StringCollection.Add ("CCC");
StringCollection.Add ("BBB2");
StringCollection.add ("ddd1");
Java 8 erweitert die Sammlungsklasse und kann einen Stream über die Sammlung erstellen. In den folgenden Abschnitten werden die häufig verwendeten Stream -Operationen im Detail erläutert:
Filterfilter
Die Filterung wird durch eine Prädikat -Schnittstelle gefiltert und nur Elemente, die die Kriterien erfüllen, werden aufbewahrt. Für den Ereig muss eine Funktion nacheinander ausführen. Foreach ist eine endgültige Operation, daher können wir andere Stream -Operationen nach Foreach nicht ausführen.
Die Codekopie lautet wie folgt:
StringCollection
.Strom()
.Filter ((s) -> s.Startswith ("a"))
.foreach (System.out :: println);
// "aaa2", "aaa1"
Sortierart
Sortierung ist eine Zwischenoperation, und der zurückgegebene Stream nach der Sortierung wird zurückgegeben. Wenn Sie keinen benutzerdefinierten Komparator angeben, wird die Standardsortierung verwendet.
Die Codekopie lautet wie folgt:
StringCollection
.Strom()
.Sortiert ()
.Filter ((s) -> s.Startswith ("a"))
.foreach (System.out :: println);
// "aaa1", "aaa2"
Es sollte beachtet werden, dass die Sortierung nur einen angeordneten Stream erstellt und die ursprüngliche Datenquelle nicht beeinflusst.
Die Codekopie lautet wie folgt:
System.out.println (StringCollection);
// DDD2, AAA2, BBB1, AAA1, BBB3, CCC, BBB2, DDD1
Kartenzuordnung
Die Intermediate -Operation -Karte wandelt Elemente nach der angegebenen Funktionsschnittstelle in zusätzliche Objekte um. Sie können auch MAP verwenden, um Objekte in andere Typen zu konvertieren.
Die Codekopie lautet wie folgt:
StringCollection
.Strom()
.Map (String :: Touppercase)
.Sortiert ((a, b) -> b.comPareto (a))
.foreach (System.out :: println);
// "ddd2", "ddd1", "ccc", "bbb3", "bbb2", "aaa2", "aaa1"
Übereinstimmen
Stream bietet eine Vielzahl von übereinstimmenden Vorgängen, um zu erkennen, ob ein bestimmtes Prädikat mit dem gesamten Stream übereinstimmt. Alle übereinstimmenden Operationen sind endgültige Operationen und geben einen Wert des Booleschen Typs zurück.
Die Codekopie lautet wie folgt:
boolean Anystartswitha =
StringCollection
.Strom()
.Anymatch ((s) -> s.Startswith ("a"));
System.out.println (AnyStartSwitha);
boolean Allstartswitha =
StringCollection
.Strom()
.AllMatch ((s) -> s.Startswith ("a"));
System.out.println (AllstartSwitha);
boolean nonstartswithz =
StringCollection
.Strom()
.nonematch ((s) -> s.Startswith ("z"));
System.out.println (nonestartswithz);
Zählen
Das Zählen ist eine endgültige Operation, die die Anzahl der Elemente im Stream zurückgibt, und der Rückgabewerttyp ist lang.
Die Codekopie lautet wie folgt:
Lange Startswithb =
StringCollection
.Strom()
.Filter ((s) -> s.Startswith ("B"))
.zählen();
System.out.println (StartsWithb);
Vorschriften reduzieren
Dies ist eine endgültige Operation, mit der mehrere Elemente im Stream als ein Element durch die angegebene Funktion definiert werden können, und das Ergebnis der Berechtigung wird durch die optionale Schnittstelle dargestellt:
Die Codekopie lautet wie folgt:
Optional <string> reduziert =
StringCollection
.Strom()
.Sortiert ()
.Reduce ((S1, S2) -> S1 + "#" + S2);
record.ifpresent (System.out :: println);
// "AAA1#AAA2#BB1#BB2#BB3#CCC#DDD1#DDD2"
Parallelströme
Wie bereits erwähnt, hat Stream zwei Typen: seriell und parallel.
Das folgende Beispiel zeigt, wie die Leistung durch parallele Stream verbessert werden kann:
Zuerst erstellen wir eine große Tabelle ohne doppelte Elemente:
Die Codekopie lautet wie folgt:
int max = 1000000;
List <String> values = new ArrayList <> (max);
für (int i = 0; i <max; i ++) {
UUid uUid = uUid.randomuuid ();
values.add (uUid.toString ());
}
Dann berechnen wir, wie lange es dauert, diesen Stream zu sortieren.
Serienart:
Die Codekopie lautet wie folgt:
long t0 = system.nanotime ();
long count = values.stream (). sortiert (). count ();
System.out.println (count);
long t1 = system.nanotime ();
Long Millis = TimeUnit.Nanoseconds.tomillis (T1 - T0);
System.out.println (String.Format ("Sequentielle Sortierung übernommen: %d ms", Millis));
// Seriennauer: 899 ms
Parallele Sortierung:
Die Codekopie lautet wie folgt:
long t0 = system.nanotime ();
long count = values.ParallelStream (). sortiert (). count ();
System.out.println (count);
long t1 = system.nanotime ();
Long Millis = TimeUnit.Nanoseconds.tomillis (T1 - T0);
System.out.println (String.Format ("Parallel -Sortierung: %d ms", Millis));
// Parallele Sortierung braucht Zeit: 472 ms
Die beiden oben genannten Codes sind fast gleich, aber die parallele Version ist bis zu 50%.
Karte
Wie bereits erwähnt, unterstützt der Kartentyp keinen Stream, aber MAP bietet einige neue und nützliche Methoden, um einige tägliche Aufgaben zu erledigen.
Die Codekopie lautet wie folgt:
Karte <Integer, String> map = new HashMap <> ();
für (int i = 0; i <10; i ++) {
map.putiFabSent (i, "val" + i);
}
map.foreach ((id, val) -> system.out.println (val));
Der obige Code ist leicht zu verstehen.
Das folgende Beispiel zeigt andere nützliche Funktionen auf der Karte:
Die Codekopie lautet wie folgt:
map.computeifPresent (3, (num, val) -> val + num);
map.get (3); // Val33
map.computeifPresent (9, (num, val) -> null);
map.containsKey (9);
map.computeifabSent (23, num -> "val" + num);
MAP.ContainsKey (23);
map.computeifabSent (3, num -> "bam");
map.get (3); // Val33
Zeigen Sie als Nächstes an, wie Sie ein Element in der Karte löschen, die allen Schlüssel entspricht:
Die Codekopie lautet wie folgt:
map.remove (3, "val3");
map.get (3); // Val33
map.remove (3, "val33");
map.get (3); // null
Eine weitere nützliche Methode:
Die Codekopie lautet wie folgt:
map.getOrdefault (42, "nicht gefunden");
Es ist auch einfach, die Elemente der Karte zusammenzuführen:
Die Codekopie lautet wie folgt:
MAP.Merge (9, "Val9", (Wert, newValue) -> value.concat (newValue));
map.get (9); // Val9
map.merge (9, "concat", (value, newValue) -> value.concat (newValue));
map.get (9); // Val9Concat
Zusammenführen ist ein Einfügen, wenn der Schlüsselname nicht vorhanden ist, andernfalls fusionieren Sie den Wert, der dem ursprünglichen Schlüssel entspricht, und stellt ihn in die Karte wieder ein.
9. Datum API
Java 8 enthält eine brandneue Reihe von Zeit- und Datums -APIs unter dem Paket Java.Time. Die neue Datums-API ähnelt der Open-Source-Joda-Zeit-Bibliothek, jedoch nicht genau das gleiche Beispiel.
Uhruhr
Die Clock -Klasse bietet eine Methode, um auf das aktuelle Datum und die Uhrzeit zuzugreifen. Ein spezifischer Zeitpunkt kann auch durch die Instant -Klasse dargestellt werden, mit der auch alte java.util.date -Objekte erstellt werden können.
Die Codekopie lautet wie folgt:
Clock clock = clock.SystemDefaultZone ();
long Millis = Uhr.Millis ();
Instant Instant = Clock.instant ();
Datum LegacyDate = Date.from (Instant);
Zeitzone Zeitzone
In der neuen API wird die Zeitzone durch ZoneId dargestellt. Die Zeitzone kann leicht unter Verwendung der statischen Methode von erhalten werden. Die Zeitzone definiert den Zeitunterschied zur UTS -Zeit, was bei der Konvertierung zwischen dem Instant -Zeitpunkt -Objekt und dem lokalen Datumsobjekt äußerst wichtig ist.
Die Codekopie lautet wie folgt:
System.out.println (zoneId.getAVailableZoneids ());
// druckt alle verfügbaren Zeitzone -IDs
ZoneId Zone1 = zoneId.of ("Europa/Berlin");
ZoneId Zone2 = zoneId.of ("Brasilien/East");
System.out.println (Zone1.getRULES ());
System.out.println (Zone2.getRULES ());
// Zonerules [CurrentStandardOffset =+01: 00]
// Zonerules [CurrentStandardOffset = -03: 00]
Lokale Zeit Ortszeit
Lokalzeit definiert eine Zeit ohne Zeitzoneninformationen wie 22 Uhr oder 17:30:15 Uhr. Das folgende Beispiel erstellt zwei lokale Zeiten mit der Zeitzone, die vom vorherigen Code erstellt wurde. Die Zeit wird dann verglichen und der Zeitunterschied zwischen den zweimals in Stunden und Minuten berechnet:
Die Codekopie lautet wie folgt:
LocalTime NOW1 = LocalTime.Now (Zone1);
LocalTime NOW2 = LocalTime.Now (Zone2);
System.out.println (jetzt1.ISBEFORE (NOW2));
lange Stunden zwischen = chronounit.hours.between (now1, now2);
lange Minuten zwischen = chronounit.minutes.between (now1, now2);
System.out.println (stundenweiter);
System.out.println (MINICEBETWICK);
LocalTime bietet eine Vielzahl von Fabrikmethoden, um die Objekterstellung zu vereinfachen, einschließlich der Analysezeiten.
Die Codekopie lautet wie folgt:
LocalTime Late = LocalTime.of (23, 59, 59);
System.out.println (spät);
DATETIMEFORMATUMATUMER Deutschformatter =
DateTimeFormatter
.oflocalized time (formatstyle.short)
. -Withlocale (Locale.german);
LocalTime Leettime = LocalTime.Parse ("13:37", Deutschformatter);
System.out.println (Leettime);
Lokaldatum lokales Datum
LocalDate stellt ein genaues Datum dar, wie z. B. 2014-03-11. Der Wert dieses Objekts ist unveränderlich und im Grunde genommen der der lokalen Zeit. Das folgende Beispiel zeigt, wie Sie ein Datumsobjekt hinzufügen/Mond/Jahr hinzufügen. Beachten Sie auch, dass diese Objekte unveränderlich sind und die Operation eine neue Instanz zurückgibt.
Die Codekopie lautet wie folgt:
LocalDate heute = localDate.now ();
LocalDate morgen = heute.plus (1, chronounit.days);
Localdate gestern = morgen.minusdays (2);
LocalDate Independeday = localDate.of (2014, Monat.Juli, 4);
TagofWeek Dayofweek = Independeday.getayofweek ();
System.out.println (Tagofweek);
Das Parsen eines LocalDate -Typs aus einer Zeichenfolge ist so einfach wie die Parsen lokaler Zeit:
Die Codekopie lautet wie folgt:
DATETIMEFORMATUMATUMER Deutschformatter =
DateTimeFormatter
.oflocalizedDate (Formatstyle.Medium)
. -Withlocale (Locale.german);
LocalDate Xmas = localDate.Parse ("24.12.2014", Deutschformatter);
System.out.println (Weihnachten);
LOCALDATETIME LOCAL DATETIME
LocalDatetime repräsentiert sowohl Zeit als auch Datum, was der Verschmelzung des Inhalts der ersten beiden Abschnitte in ein Objekt entspricht. LocalDatetime, wie Lokalzeit und LocalDate, sind beide unveränderlich. LocalDateTime bietet einige Methoden, um auf bestimmte Felder zuzugreifen.
Die Codekopie lautet wie folgt:
LocalDatetime Sylvester = localDatetime.of (2014, Monat, 31., 23, 59, 59);
TagofWeek Dayofweek = Sylvester.Getayofweek ();
System.out.println (Tagofweek);
Monat Monat = Sylvester.getMonth ();
System.out.println (Monat);
Long MinuteOfday = Sylvester.getLong (Chronofield.minute_of_day);
System.out.println (MinuteOfday);
Fügen Sie einfach die Zeitzoneninformationen hinzu und sie können in ein sofortiges Objekt für Zeitpunkte umgewandelt werden.
Die Codekopie lautet wie folgt:
Instant Instant = Sylvester
.ATzone (zoneId.SystemDefault ())
toinstant ();
Datum LegacyDate = Date.from (Instant);
System.out.println (LegacyDate);
Das Formatieren von Lokaldaten ist gleichzeitig die Formatierung von Zeit und Datum.
Die Codekopie lautet wie folgt:
DateTimeFormatter Formatierer =
DateTimeFormatter
.ofPattern ("Mmm DD, YJJJ - HH: MM");
LocalDatetime Parseed = localDateTime.Parse ("03. November 2014 - 07:13", Formatierer);
String string = formatter.format (analysiert);
System.out.println (String);
Im Gegensatz zu java.text.numberformat ist die neue Version von DateTimeFormatter unveränderlich, sodass es thread-sicher ist.
Detaillierte Informationen zu Zeit- und Datumsformat: http://download.java.net/jdk8/docs/api/java/time/format/datetimeFormatter.html
10. Annotationsnotizen
Mehrere Anmerkungen werden in Java 8 unterstützt. Schauen wir uns zunächst ein Beispiel an, um zu verstehen, was es bedeutet.
Definieren Sie zunächst eine packagierte Annotation für Hinweise, um eine bestimmte Reihe von Hinweise Anmerkungen zu platzieren:
Die Codekopie lautet wie folgt:
@Interface Hinweise {
Hinweis [] value ();
}
@Repeatable (tipps.class)
@Interface Tipp {
String value ();
}
Java 8 ermöglicht es uns, Annotationen desselben Typs mehrmals zu verwenden. Beschriften Sie einfach die Annotation @repeatable.
Beispiel 1: Verwenden Sie die Wrapper -Klasse als Container, um mehrere Anmerkungen zu speichern (alte Methode)
Die Codekopie lautet wie folgt:
@Hints ({ @Hint ("Hint1"), @Hint ("Hint2")})
Klasse Person {}
Beispiel 2: Verwenden mehrerer Anmerkungen (neue Methode)
Die Codekopie lautet wie folgt:
@Hint ("Hint1")
@Hint ("Hint2")
Klasse Person {}
Im zweiten Beispiel definiert der Java -Compiler implizit die @Hints Annotation für Sie.
Die Codekopie lautet wie folgt:
Hint Hint = Person.class.getAnnotation (Hint.Class);
System.out.println (Hinweis);
Hinweise Hinweise 1 = person.class.getannotation (fils.class);
System.out.println (Hints1.Value (). Länge);
Hinweis [] Hinweis2 = Person.class.getAnnotationsByPe (Hint.Class);
System.out.println (Hints2.Length);
Auch wenn wir @Hints Annotation in der Person -Klasse nicht definieren, können wir @Hints Annotation durch GetAnnotation (Tipps.Class) erhalten, um GetAnnotationsByType zu verwenden, um alle @Hint -Anmerkungen direkt zu erhalten.
Darüber hinaus wurden zwei neue Ziele Java 8 -Anmerkungen hinzugefügt:
Die Codekopie lautet wie folgt:
@Target ({elementtype.type_parameter, elementtype.type_use})
@Interface Myannotation {}
Hier geht es um die neuen Funktionen von Java 8, und es gibt definitiv mehr Funktionen, die darauf warten, entdeckt zu werden. Es gibt viele nützliche Dinge in JDK 1.8, wie Arrays.Parallelsort, Stampedlock und CompleteableFuture.