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.