Boolean.valueOf () produit parfois NullPointerException

J'ai ce code:

package tests;

import java.util.Hashtable;

public class Tests {

    public static void main(String[] args) {

        Hashtable<String, Boolean> modifiedItems = new Hashtable<String, Boolean>();

        System.out.println("TEST 1");
        System.out.println(modifiedItems.get("item1")); // Prints null
        System.out.println("TEST 2");
        System.out.println(modifiedItems.get("item1") == null); // Prints true
        System.out.println("TEST 3");
        System.out.println(Boolean.valueOf(null)); // Prints false
        System.out.println("TEST 4");
        System.out.println(Boolean.valueOf(modifiedItems.get("item1"))); // Produces NullPointerException
        System.out.println("FINISHED!"); // Never executed
    }
}

Mon problème est que je ne comprends pas pourquoi le test 3 fonctionne correctement (il imprime falseet ne produit pas NullPointerException) pendant que le test 4 lance un fichier NullPointerException. Comme vous pouvez le voir dans les tests 1 et 2 , nullet modifiedItems.get("item1")sont égaux à et null.

Le comportement est le même dans Java 7 et 8.

Vous devez regarder attentivement quelle surcharge est invoquée:

• Boolean.valueOf(null)appelle Boolean.valueOf(String). Cela ne jette pas unNPE même s'il est fourni avec un paramètre nul.
• Boolean.valueOf(modifiedItems.get("item1"))appelle Boolean.valueOf(boolean), car modifiedItemsles valeurs de sont de type Boolean, ce qui nécessite une conversion de déballage. Depuis modifiedItems.get("item1")est null, il est le unboxing de cette valeur - pas Boolean.valueOf(...)- ce qui jette le NPE.

Les règles pour déterminer quelle surcharge est invoquée sont assez épineuses , mais elles vont à peu près comme ceci:

• Dans un premier passage, une correspondance de méthode est recherchée sans autoriser le boxing / unboxing (ni les méthodes d'arité variable).

  • Parce que nullest une valeur acceptable pour a Stringmais pas boolean, Boolean.valueOf(null)correspond à Boolean.valueOf(String)dans cette passe;
  • Booleanest pas acceptable pour les deux Boolean.valueOf(String)ou Boolean.valueOf(boolean), si aucune méthode est adaptée dans ce col pour Boolean.valueOf(modifiedItems.get("item1")).

• Dans un second passage, une correspondance de méthode est recherchée, permettant le boxing / unboxing (mais toujours pas les méthodes d'arité variable).

  • A Booleanpeut être déballé boolean, donc Boolean.valueOf(boolean)correspond Boolean.valueOf(modifiedItems.get("item1"))à cette passe; mais une conversion de déballage doit être insérée par le compilateur pour l'invoquer:Boolean.valueOf(modifiedItems.get("item1").booleanValue())

• (Il y a une troisième passe permettant les méthodes d'arité variable, mais ce n'est pas pertinent ici, car les deux premières passes correspondent à ces cas)

Puisque modifiedItems.getrenvoie a Boolean(qui ne peut pas être converti en a String), la signature qui serait utilisée est Boolean.valueOf(boolean), où le Booleanest envoyé à une primitive boolean. Une fois nullretourné là-bas, l'envoi échoue avec un NullPointerException.

Signature de méthode

La méthode Boolean.valueOf(...)a deux signatures:

1. public static Boolean valueOf(boolean b)
2. public static Boolean valueOf(String s)

Votre modifiedItemsvaleur est Boolean. Vous ne pouvez pas lancer BooleanversString cas, la première signature sera donc choisie

Unboxing booléen

Dans votre déclaration

Boolean.valueOf(modifiedItems.get("item1"))

qui peut être lu comme

Boolean.valueOf(modifiedItems.get("item1").booleanValue())   

Cependant, modifiedItems.get("item1")retourne nulldonc vous aurez essentiellement

null.booleanValue()

ce qui conduit évidemment à un NullPointerException

Comme Andy l'a déjà très bien décrit la raison de NullPointerException:

ce qui est dû au déballage booléen:

Boolean.valueOf(modifiedItems.get("item1"))

se convertir en:

Boolean.valueOf(modifiedItems.get("item1").booleanValue())

au moment de l'exécution, puis il jette NullPointerExceptionsi modifiedItems.get("item1")est nul.

Maintenant, je voudrais ajouter un point de plus ici que le déballage des classes suivantes à leurs primitives respectives peut également produire une NullPointerExceptionexception si leurs objets retournés correspondants sont nuls.

1. octet - octet
2. char - Caractère
3. float - Float
4. int - Entier
5. long - Long
6. court - court
7. double double

Voici le code:

    Hashtable<String, Boolean> modifiedItems1 = new Hashtable<String, Boolean>();
    System.out.println(Boolean.valueOf(modifiedItems1.get("item1")));//Exception in thread "main" java.lang.NullPointerException

    Hashtable<String, Byte> modifiedItems2 = new Hashtable<String, Byte>();
    System.out.println(Byte.valueOf(modifiedItems2.get("item1")));//Exception in thread "main" java.lang.NullPointerException

    Hashtable<String, Character> modifiedItems3 = new Hashtable<String, Character>();
    System.out.println(Character.valueOf(modifiedItems3.get("item1")));//Exception in thread "main" java.lang.NullPointerException

    Hashtable<String, Float> modifiedItems4 = new Hashtable<String, Float>();
    System.out.println(Float.valueOf(modifiedItems4.get("item1")));//Exception in thread "main" java.lang.NullPointerException

    Hashtable<String, Integer> modifiedItems5 = new Hashtable<String, Integer>();
    System.out.println(Integer.valueOf(modifiedItems5.get("item1")));//Exception in thread "main" java.lang.NullPointerException

    Hashtable<String, Long> modifiedItems6 = new Hashtable<String, Long>();
    System.out.println(Long.valueOf(modifiedItems6.get("item1")));//Exception in thread "main" java.lang.NullPointerException

    Hashtable<String, Short> modifiedItems7 = new Hashtable<String, Short>();
    System.out.println(Short.valueOf(modifiedItems7.get("item1")));//Exception in thread "main" java.lang.NullPointerException

    Hashtable<String, Double> modifiedItems8 = new Hashtable<String, Double>();
    System.out.println(Double.valueOf(modifiedItems8.get("item1")));//Exception in thread "main" java.lang.NullPointerException

Une façon de le comprendre est que lorsque Boolean.valueOf(null)est invoqué, java est précisément dit d'évaluer null.

Cependant, quand Boolean.valueOf(modifiedItems.get("item1")) est invoqué, java est invité à obtenir une valeur du HashTable de type d'objet Boolean, mais il ne trouve pas le type Boolean à la place, il trouve une impasse (null) même s'il attendait Boolean. L'exception NullPointerException est levée parce que les créateurs de cette partie de java ont décidé que cette situation est une instance de quelque chose dans le programme qui tourne mal et qui nécessite l'attention du programmeur. (Quelque chose d'inattendu s'est produit.)

Dans ce cas, c'est plus la différence entre déclarer délibérément que vous vouliez que le null soit là, et java trouver une référence manquante à un objet (null) où un objet était destiné à être trouvé.

Pour plus d'informations sur NullPointerException, consultez cette réponse: https://stackoverflow.com/a/25721181/4425643