Como posso verificar se uma matriz é nula / vazia?

Eu tenho uma intmatriz que não possui elementos e estou tentando verificar se está vazia.

Por exemplo, por que a condição da instrução if no código abaixo nunca é verdadeira?

int[] k = new int[3];

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

Há uma diferença fundamental entre uma nullmatriz e uma matriz vazia. Este é um teste para null.

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

"Vazio" aqui não tem significado oficial. Eu estou escolhendo definir vazio como tendo 0 elementos:

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

Uma definição alternativa de "vazio" é se todos os elementos forem 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)do pacote org.apache.commons.lang3garante que a matriz não seja nula ou vazia

Veja o seu comprimento:

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

Embora seja mais seguro verificar se há nulo ao mesmo tempo:

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

O método para verificar a matriz como nulo ou vazio também está presente em org.apache.commons.lang:

import org.apache.commons.lang.ArrayUtils;

ArrayUtils.isEmpty(array);

Eu sou do fundo .net. No entanto, java / c # são mais / menos iguais.

Se você instanciar um tipo não primitivo (matriz no seu caso), ele não será nulo.
Por exemplo, int[] numbers = new int[3];
neste caso, o espaço é alocado e cada elemento tem um valor padrão de 0.

Será null, quando você não fizer newisso.
por exemplo

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

Uma matriz int é inicializada com zero, portanto nunca conterá nulos. Somente matrizes de objetos conterão nulo inicialmente.

O ponto aqui de maneira muito simples é que a variável k não é nula porque aponta para a matriz. Não importa que a própria matriz esteja vazia. O teste nulo em sua postagem só seria avaliado como verdadeiro se a variável k não apontasse para nada.

Eu testei como abaixo. Espero que ajude.

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

Uma intmatriz sem elementos não é necessariamente null. Será apenas nullse ainda não tiver sido alocado. Consulte este tutorial para obter mais informações sobre matrizes Java.

Você pode testar o comprimento da 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;
}

Isso é o mais próximo que cheguei da verificação de se uma matriz int está vazia. Embora isso não funcione quando as entradas na matriz são realmente zero. Ele funcionará para {1,2,3} e ainda retornará false se {2,0}, mas {0} retornará true

No Java 8+, você consegue isso com a ajuda do método allMatch de fluxos.

Para primitivo:

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

Para objeto:

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

Eu acredito que o que você quer é

int[] k = new int[3];

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

Você o atualizou para que nunca fosse nulo.

Você também pode verificar se há algum elemento na matriz, descobrindo seu comprimento e colocá-lo na instrução if-else para verificar se é nulo.

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