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

J'ai un inttableau qui n'a aucun élément et j'essaie de vérifier s'il est vide.

Par exemple, pourquoi la condition de l'instruction if dans le code ci-dessous n'est jamais vraie?

int[] k = new int[3];

if (k == null) {
    System.out.println(k.length);
}

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

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

«Vide» ici n'a aucune signification officielle. Je choisis de définir vide comme ayant 0 élément:

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

Une autre définition de «vide» est si tous les éléments sont null:

Object arr[] = new Object[10];
boolean empty = true;
for (int i=0; i<arr.length; i++) {
  if (arr[i] != null) {
    empty = false;
    break;
  }
}

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.lang3garantit que Array 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) { }

La méthode pour vérifier que le tableau est nul ou vide est également présente sur org.apache.commons.lang:

import org.apache.commons.lang.ArrayUtils;

ArrayUtils.isEmpty(array);

Je viens de .net. Cependant, java / c # sont plus / 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 faites pas new.
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 donc il ne contiendra jamais de null. Seuls les tableaux d'Object contiendront initialement null.

Le point ici très simplement est que la variable k n'est pas nulle car elle pointe vers le tableau. Peu importe que le tableau lui-même soit vide. Le test nul dans votre message ne serait évalué à vrai que si la variable k ne pointait vers rien.

J'ai testé comme ci-dessous. J'espère que ça 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 inttableau sans éléments ne l'est pas nécessairement null. Ce ne sera que nulls'il n'a pas encore été attribué. Consultez ce didacticiel pour plus d'informations sur les tableaux Java.

Vous pouvez tester la longueur du tableau:

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

    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 près que j'ai pu vérifier si un tableau int est vide. Bien que cela ne fonctionnera pas lorsque les entiers du tableau sont en fait à zéro. Cela fonctionnera pendant {1,2,3}, et il retournera toujours false si {2,0} mais {0} retournera true

Dans Java 8+, vous y parvenez à l'aide de la méthode streams allMatch.

Pour primitif:

int[] k = new int[3];
Arrays.stream(k).allMatch(element -> element != 0)

Pour objet:

Objects[] k = new Objects[3];
Arrays.stream(k).allMatch(Objects::nonNull)

Je crois que ce que tu veux c'est

int[] k = new int[3];

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

Vous l'avez mis à jour pour qu'il ne soit jamais nul.

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

int[] k = new int[3];
if(k.length == 0)
{
//do something
}