¿Cómo puedo verificar si una matriz es nula / vacía?

Tengo una intmatriz que no tiene elementos y estoy tratando de verificar si está vacía.

Por ejemplo, ¿por qué la condición de la declaración if en el siguiente código nunca es cierta?

int[] k = new int[3];

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

Hay una diferencia clave entre una nullmatriz y una matriz vacía. Esta es una prueba para null.

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

"Vacío" aquí no tiene un significado oficial. Estoy eligiendo definir vacío con 0 elementos:

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

Una definición alternativa de "vacío" es si todos los elementos son 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)del paquete org.apache.commons.lang3asegura que la matriz no sea nula o esté vacía

Mira su longitud:

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

Aunque es más seguro verificar si hay nulo al mismo tiempo:

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

El método para verificar la matriz para nulo o vacío también está presente en org.apache.commons.lang:

import org.apache.commons.lang.ArrayUtils;

ArrayUtils.isEmpty(array);

Soy de .net background. Sin embargo, java / c # son más / menos iguales.

Si crea una instancia de un tipo no primitivo (matriz en su caso), no será nulo.
Por ejemplo, int[] numbers = new int[3];
en este caso, el espacio se asigna y cada elemento tiene un valor predeterminado de 0.

Lo será null, cuando no lo hagas new.
p.ej

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

Una matriz int se inicializa con cero, por lo que en realidad nunca contendrá nulos. Solo las matrices de objetos contendrán nulo inicialmente.

El punto aquí es muy simple: la variable k no es nula porque apunta a la matriz. No importa que la matriz en sí esté vacía. La prueba nula en su publicación solo se evaluaría como verdadera si la variable k no apuntara a nada.

Probé como a continuación. Espero eso ayude.

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

Una intmatriz sin elementos no es necesariamente null. Solo será nullsi aún no se ha asignado. Consulte este tutorial para obtener más información sobre las matrices Java.

Puedes probar la longitud de la matriz:

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

Esto es lo más cerca que pude comprobar si una matriz int está vacía. Aunque esto no funcionará cuando las entradas en la matriz sean realmente cero. Funcionará para {1,2,3}, y aún devolverá falso si {2,0} pero {0} devolverá verdadero

En Java 8+ lo logras con la ayuda del método streams allMatch.

Para primitivo:

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

Para el objeto:

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

Creo que lo que quieres es

int[] k = new int[3];

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

Lo renovaste para que nunca fuera nulo.

También puede verificar si hay elementos en la matriz al averiguar su longitud, luego ponerlo en la instrucción if-else para verificar si es nulo.

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