Come posso verificare se un array è nullo / vuoto?

Ho un intarray che non ha elementi e sto cercando di verificare se è vuoto.

Ad esempio, perché la condizione dell'istruzione if nel codice sottostante non è mai vera?

int[] k = new int[3];

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

C'è una differenza chiave tra un nullarray e un array vuoto. Questo è un test per null.

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

"Vuoto" qui non ha significato ufficiale. Sto scegliendo di definire vuoto con 0 elementi:

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

Una definizione alternativa di "vuoto" è se tutti gli elementi sono null:

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

o

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

ArrayUtils.isNotEmpty(testArrayName)dal pacchetto org.apache.commons.lang3garantisce che l'array non sia nullo o vuoto

Guarda la sua lunghezza:

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

Sebbene sia più sicuro controllare contemporaneamente null:

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

Su org.apache.commons.lang è presente anche un metodo per controllare l'array per null o vuoto:

import org.apache.commons.lang.ArrayUtils;

ArrayUtils.isEmpty(array);

Vengo dallo sfondo .net. Tuttavia, java / c # sono più / meno uguali.

Se crei un'istanza di un tipo non primitivo (array nel tuo caso), non sarà nullo.
ad es. int[] numbers = new int[3];
In questo caso, lo spazio è allocato e ogni elemento ha un valore predefinito di 0.

Lo sarà null, quando non newlo fai .
per esempio

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

Un array int viene inizializzato con zero, quindi non contiene mai null. Solo le matrici di Object conterranno inizialmente null.

Il punto qui molto semplicemente è che la variabile k non è nulla perché punta alla matrice. Non importa che l'array stesso sia vuoto. Il test null nel tuo post valuterà vero se la variabile k non puntava a nulla.

Ho provato come di seguito. Spero che sia d'aiuto.

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 intarray senza elementi non è necessariamente null. Lo sarà solo nullse non è stato ancora assegnato. Vedi questo tutorial per ulteriori informazioni sugli array Java.

Puoi testare la lunghezza dell'array:

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;
}

Questo è il più vicino possibile al controllo se un array int è vuoto. Sebbene ciò non funzionerà quando gli ints nell'array sono effettivamente zero. Funzionerà per {1,2,3} e restituirà comunque false se {2,0} ma {0} restituirà true

In Java 8+ si ottiene questo risultato con l'aiuto del metodo allMatch di flussi.

Per primitivo:

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

Per oggetto:

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

Credo che quello che vuoi sia

int[] k = new int[3];

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

L'hai rinnovato, quindi non sarebbe mai stato nulla.

È inoltre possibile verificare se vi sono elementi nell'array scoprendone la lunghezza, quindi inserirlo nell'istruzione if-else per verificare se è nullo.

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