Comment puis-je vérifier si un tableau est nul / vide?

J’ai un tableau int qui n’a pas d’éléments et j’essaie de vérifier s’il est vide.

Par exemple, pourquoi l’instruction if dans le code ci-dessous n’est-elle jamais vraie?

 int[] k = new int[3]; if(k==null) { System.out.println(k.length); } 

Il y a une différence essentielle entre un tableau null et un tableau vide. Ceci est un test pour null .

 int arr[] = null; if (arr == null) { System.out.println("array is null"); } 

“Vide” n’a ici aucune signification officielle. Je choisis de définir vide comme ayant 0 éléments:

 arr = new int[0]; if (arr.length == 0) { System.out.println("array is empty"); } 

Une autre définition de “empty” est si tous les éléments sont null :

 Object arr[] = new Object[10]; boolean empty = true; for (int i=0; i 

ou

 Object arr[] = new Object[10]; boolean empty = true; for (Object ob : arr) { if (ob != null) { empty = false; break; } } 

ArrayUtils.isNotEmpty(testArrayName) du package org.apache.commons.lang3 garantit que le tableau n’est pas nul ou vide

Regardez sa longueur:

 int[] i = ...; if (i.length == 0) { } // no elements in the array 

Bien qu’il soit plus sûr de vérifier la valeur null en même temps:

 if (i == null || i.length == 0) { } 

Je viens de .net background. Cependant, java / c # sont plus ou moins identiques.

Si vous instanciez un type non primitif (tableau dans votre cas), il ne sera pas nul.
par exemple int[] numbers = new int[3];
Dans ce cas, l’espace est alloué et chacun des éléments a une valeur par défaut de 0.

Ce sera null , quand vous ne le renouvellerez pas.
par exemple

 int[] numbers = null; // changed as per @Joachim's suggestion. if (numbers == null) { System.out.println("yes, it is null. Please new it up"); } 

Un tableau int est initialisé avec zéro pour ne pas contenir de null. Seuls les tableaux de Object contiendront initialement null.

Le point ici est que la variable k n’est pas nulle car elle pointe vers le tableau. Peu importe que le tableau soit vide. Le test de null dans votre article ne serait évalué à true que si la variable k ne indiquait rien.

J’ai testé comme ci-dessous. J’espère que cela aide.

 Integer[] integers1 = new Integer[10]; System.out.println(integers1.length); //it has length 10 but it is empty. It is not null array for (Integer integer : integers1) { System.out.println(integer); //prints all 0s } //But if I manually add 0 to any index, now even though array has all 0s elements //still it is not empty // integers1[2] = 0; for (Integer integer : integers1) { System.out.println(integer); //Still it prints all 0s but it is not empty //but that manually added 0 is different } //Even we manually add 0, still we need to treat it as null. This is semantic logic. Integer[] integers2 = new Integer[20]; integers2 = null; //array is nullified // integers2[3] = null; //If I had int[] -- because it is priitive -- then I can't write this line. if (integers2 == null) { System.out.println("null Array"); } 

Un tableau int sans éléments n’est pas nécessairement null . Il ne sera null s’il n’a pas encore été alloué. Voir ce tutoriel pour plus d’informations sur les baies Java.

Vous pouvez tester la longueur du tableau:

 void foo(int[] data) { if(data.length == 0) return; } 

Vous pouvez également vérifier s’il y a des éléments dans le tableau en trouvant sa longueur, puis le placer dans l’instruction if-else pour vérifier s’il est nul.

 int[] k = new int[3]; if(k.length == 0) { //do something } 
  public boolean empty() { boolean isEmpty = true; int i = 0; for (int j = 0; j < array.length; j++) { if (array[j] != 0) { i++; } } if (i != 0) { isEmpty = false; } return isEmpty; } 

C'est aussi proche que j'ai pu vérifier si un tableau int est vide. Bien que cela ne fonctionnera pas lorsque les ints du tableau sont réellement nuls. Cela fonctionnera pour {1,2,3}, et il retournera toujours faux si {2,0} mais {0} retournera vrai

Je crois que ce que vous voulez est

 int[] k = new int[3]; if (k != null) { // Note, != and not == as above System.out.println(k.length); } 

Vous l’avez changé pour ne jamais être nul.