So vermeiden Sie eine Nullzeigerausnahme in Java

Niemand mag eine NullPointerException! Gibt es eine Möglichkeit, sie zu vermeiden? Vielleicht. .

In diesem Artikel werden die folgenden Technologien besprochen

1. Optionaler Typ (neu eingeführt in Java 8)
2. Optional Klasse in Java 8

Was ist das?

1. Ein neu eingeführter Typ in Java 8

2. Er wird als Wrapper für ein Objekt eines bestimmten Typs oder für Szenarien verwendet, in denen kein Objekt (null) vorhanden ist.

Einfach Kurz gesagt, es ist eine bessere Alternative für den Umgang mit Nullwerten (Warnung: Es ist auf den ersten Blick möglicherweise nicht so offensichtlich)

Grundlegende Verwendung

Es ist ein Typ (eine Klasse) – also , wie können Sie eine Instanz dieses Typs erstellen?

Verwenden Sie einfach die drei statischen Methoden:

Einfach und klar – erstellen Sie eine Instanz mit diesem optionalen Wrapper. Denken Sie daran: Wenn dieser Wert null ist, wird NPE ausgelöst!

public static Optional<String> stringOptional(String input) {
    return Optional.of(input);
}

Ich persönlich denke, dass es besser ist. Auf diese Weise besteht kein NPE-Risiko – wenn die Eingabe null ist, wird ein leeres Optional

public static Optional<String> stringNullableOptional(String input) {
if (!new Random().nextBoolean()) {
input = null;
}
return Optional.ofNullable(input);
}

zurückgegeben, wenn Sie wirklich einen „leeren“ Wert zurückgeben möchten. Ein „leerer“ Wert bedeutet nicht null.

public static Optional<String> emptyOptional() {
return Optional.empty();
}

Okay, wie kann man dann Optional konsumieren/verwenden?

Der einfache Weg besteht darin, zu überprüfen, ob der optionale Wrapper tatsächlich einen Wert hat (mit der Methode isPresent) – Sie werden sich fragen, welchen Vorteil es im Vergleich zur Verwendung von if(myObj != null) hat. Keine Sorge, ich werde das klar erklären.

public static void consumingOptional() {
Optional<String> wrapped = Optional.of("aString");
if (wrapped.isPresent()) {
System.out.println("Got string - " + wrapped.get());
}
else {
System.out.println("Gotcha !");
}
}

Sie können die orElse-Methode verwenden, sodass Sie, wenn der gekapselte Wert tatsächlich ein Nullwert ist, einen Standardwert zurückgeben können – die Vorteile liegen auf der Hand. Beim Extrahieren des realen Werts können Sie die offensichtlich redundante Methode des Aufrufs der ifPresent-Methode vermeiden.

public static void consumingNullableOptional() {
String input = null;
if (new Random().nextBoolean()) {
input = "iCanBeNull";
}
Optional<String> wrapped = Optional.ofNullable(input);
System.out.println(wrapped.orElse("default"));
}

Ich bin etwas verwirrt darüber. Warum gibt es zwei unterschiedliche Methoden für den gleichen Zweck? orElse und orElseGet können offensichtlich überladen werden (mit demselben Namen, aber unterschiedlichen Parametern).

public static void consumingEmptyOptional() {
String input = null;
if (new Random().nextBoolean()) {
input = "iCanBeNull";
}
Optional<String> wrapped = Optional.ofNullable(input);
System.out.println(wrapped.orElseGet(
() -> {
return "defaultBySupplier";
}
 
));
}

Wie auch immer, der offensichtliche Unterschied zwischen diesen beiden Methoden sind ihre Parameter – Sie können Lambda-Ausdrücke anstelle von Instanzen von Supplier verwenden, um dies zu erreichen (eine funktionale Schnittstelle)

Warum ist die Verwendung von Optional besser? als die übliche Nullprüfung?

1. Der größte Vorteil der Verwendung von Optional besteht darin, dass Sie Ihre Absicht klarer ausdrücken können – die Rückgabe eines Nullwerts führt dazu, dass Verbraucher verwirrt werden (wenn NPE auftritt), ob dies absichtlich zurückgegeben wird, daher müssen Sie dies überprüfen Javadoc zur weiteren Positionierung. Die Verwendung von Optional ist recht einfach.

2. Mit Optional können Sie NPE vollständig vermeiden – wie oben erwähnt, kann uns die Verwendung von Optional.ofNullable, orElse und orElseGet von NPE fernhalten.

Ein weiterer Retter!

Schauen Sie sich dieses Code-Snippet an

Welches könnte leer sein?

package com.abhirockzz.wordpress.npesaviors;
 
import java.util.Map;
import java.util.Objects;
 
public class UsingObjects {
 
String getVal(Map<String, String> aMap, String key) {
return aMap.containsKey(key) ? aMap.get(key) : null;
}
 
public static void main(String[] args) {
UsingObjects obj = new UsingObjects();
obj.getVal(null, "dummy");
}
}

1.Map-Objekt

2.Der für die Suche verwendete Schlüssel

3.Die Instanz des Methodenaufrufs

Wenn ein NPE ausgelöst wird, wie können wir dann feststellen, um welches es sich handelt? ist? null?

requireNonNull-Methode

package com.abhirockzz.wordpress.npesaviors;
 
import java.util.Map;
import java.util.Objects;
 
public class UsingObjects {
String getValSafe(Map<String, String> aMap, String key) {
Map<String, String> safeMap = Objects.requireNonNull(aMap,
"Map is null");
String safeKey = Objects.requireNonNull(key, "Key is null");
 
return safeMap.containsKey(safeKey) ? safeMap.get(safeKey) : null;
}
 
public static void main(String[] args) {
UsingObjects obj = new UsingObjects();
obj.getValSafe(null, "dummy");
}
}

1. Wenn das Objekt nicht null ist, gibt es sich selbst zurück

2 Wenn der Wert null ist, wird die zurückgegebene NPE die angegebene Nachricht haben

Warum ist es besser als if(myObj!=null)?

Die Stack-Trace-Informationen, die Sie sehen, zeigen deutlich den Methodenaufruf von Objects.requireNonNull. In Kombination mit Ihrem eigenen Fehlerprotokoll können Sie so das Problem schneller lokalisieren. . . Zumindest ist es meiner Meinung nach schneller.

Sie können auch Ihren eigenen Validator anpassen, beispielsweise einen einfachen Validator implementieren, um sicherzustellen, dass keine Nullwerte vorhanden sind.

Lassen Sie nicht zu, dass NPE an der falschen Stelle zur Belastung wird. Wir verfügen über viele Tools, um NPEs besser zu bekämpfen und sie sogar vollständig zu beseitigen!

import java.util.Collections;
import java.util.List;
import java.util.Objects;
import java.util.function.Predicate;
 
public class RandomGist {
 
    public static <T> T requireNonEmpty(T object, Predicate<T> predicate, String msgToCaller){
        Objects.requireNonNull(object);
        Objects.requireNonNull(predicate);
        if (predicate.test(object)){
            throw new IllegalArgumentException(msgToCaller);
        }
        return object;
    }
 
    public static void main(String[] args) {
        
    //Usage 1: an empty string (intentional)
 
    String s = "";
    System.out.println(requireNonEmpty(Objects.requireNonNull(s), (s1) -> s1.isEmpty() , "My String is Empty!"));
 
    //Usage 2: an empty List (intentional)
    List list =  Collections.emptyList();
    System.out.println(requireNonEmpty(Objects.requireNonNull(list), (l) -> l.isEmpty(), "List is Empty!").size());
 
    //Usage 3: an empty User (intentional)
    User user = new User("");
    System.out.println(requireNonEmpty(Objects.requireNonNull(user), (u) -> u.getName().isEmpty(), "User is Empty!"));
}
 
    private static class User {
        private String name;
 
        public User(String name){
            this.name = name;
        }
 
        public String getName(){
            return name;
        }
    }
}

Weitere verwandte Artikel zu Methoden zur Vermeidung von Nullzeigerausnahmen in Java finden Sie auf der chinesischen PHP-Website!