Java8 startet jetzt ~ Optional ~

Teil 1: Java 8 ~ für jeden und Lambda-Ausdruck ~ Teil 2: Java 8 ~ Stream API ~ wird jetzt gestartet Die dritte: Java8 startet jetzt API mit Datum und Uhrzeit

Optional ist eine Klasse, die Dinge behandelt, die Werte ungleich Null haben können oder nicht. Optional <String> ist ein Typ, der möglicherweise eine Zeichenfolge enthält oder nicht

Optional generieren

Hat keinen Wert

Optional emptyCase = Optional.empty();

Leere Optionale Optionale Option

Muss einen Wert haben

Optional presentCase = Optional.of("example");

Optional mit Wert generieren Wenn Sie null als Argument übergeben, erhalten Sie eine NullPointerException

Kann oder kann nicht Wert haben

Optional nullableNullCase = Optiona.ofNullable(null);
Optional nullableNotNullCase = Optiona.ofNullable("example");

Erzeugt eine leere Optionale Option, wenn das Argument null ist. Andernfalls wird eine Optionale Option mit dem Wert des Arguments erstellt

Verwendung von Optional

Bestimmen Sie, ob es einen Wert gibt

isPresent Gibt true zurück, wenn es einen Wert hat, andernfalls false

Optional presentCase = Optional.of("example");
presentCase.isPresent();  // true

Optional emptyCase = Optional.empty();
emptyCase.isPresent();  // false

ifPresent Wenn es einen Wert hat, führt es das Argument Consumer mit dem Wert als Argument aus, andernfalls tut es nichts.

Optional presentCase = Optional.of("example");
presentCase.ifPresent(s -> {System.out.println(s)});  //Zur Standardausgabe"example"Und Ausgabe

Optional emptyCase = Optional.empty();
emptyCase.ifPresent(s -> {System.out.println(s)});  //nichts tun

Holen Sie sich den Wert

get Wenn es einen Wert hat, gibt es diesen Wert zurück, andernfalls wird eine "NoSuchElementException" ausgelöst

Optional presentCase = Optional.of("example");
presentCase.get();                    // example

Optional emptyCase = Optional.empty();
emptyCase.get();                      //NoSuchElementException tritt auf

Verwenden Sie diese Option, wenn Sie einen Wert erwarten Wenn Sie keinen Wert haben und den Standardwert verwenden möchten, sollten Sie das folgende oder Else verwenden

orElse Wenn es einen Wert hat, gibt es diesen Wert zurück, andernfalls gibt es den durch das Argument angegebenen Wert zurück.

Optional presentCase = Optional.of("example");
presentCase.orElse("default");                    // example

Optional emptyCase = Optional.empty();
emptyCase.orElse("default");                      // default

orElseGet Wenn es einen Wert hat, gibt es diesen Wert zurück, andernfalls gibt es das Ergebnis des durch das Argument angegebenen Lieferanten zurück.

Optional presentCase = Optional.of("example");
presentCase.orElseGet(() -> {"default"});          // example

Optional emptyCase = Optional.empty();
emptyCase.orElseGet(() -> {"default"});           // default

Der Unterschied zu "orElse" besteht darin, ob Sie den Standardwert direkt übergeben oder in einem Lambda-Ausdruck ausdrücken.

orElseThrow Wenn es einen Wert hat, gibt es diesen Wert zurück, andernfalls wird eine Ausnahme mit dem durch das Argument angegebenen Lieferanten ausgelöst.

Verwenden Sie den Wert

map Wenn es einen Wert hat, wendet es die Argumentzuordnungsfunktion auf diesen Wert an und gibt eine Option zurück, die das Ergebnis beschreibt, wenn das Ergebnis nicht null ist. Andernfalls wird eine leere Option zurückgegeben

Optional<String> presentCase = Optional.of("example,1,exp");
Optional<String[]> result = presentCase.map(name -> name.split(",")); // [example, 1, exp]

Optional<String> emptyCase = Optional.empty();
Optional<String[]> result = emptyCase .map(name -> name.split(",")); //Leer Optional

filter Funktioniert wie ein Stream-API-Filter Gibt das ursprüngliche Optional zurück, wenn die Lambda-Ausdrucksbedingung des Arguments erfüllt ist, andernfalls wird ein leeres Optional zurückgegeben

Optional<String> presentCase =Optional.of("example");
Optional<String> match = presentCase.filter(exp -> exp.length() == 7); // "example"

Optional<String> notMatch = presentCase.filter(exp -> exp.length() != 7); //Leer Optional