Neste laboratório, você aprenderá como verificar se um array em Java está vazio. Abordaremos a técnica fundamental de verificar o comprimento do array e também como lidar com casos em que o próprio array pode ser nulo (null). Você praticará esses conceitos com diferentes tipos de array para solidificar sua compreensão.
Nesta etapa, aprenderemos como verificar se um array em Java está vazio, verificando seu comprimento. Esta é uma operação fundamental ao trabalhar com arrays para evitar erros.
Primeiro, vamos criar um novo arquivo Java chamado ArrayLengthCheck.java no seu diretório ~/project. Você pode fazer isso usando o Explorador de Arquivos WebIDE à esquerda. Clique com o botão direito na área ~/project, selecione "Novo Arquivo" e digite ArrayLengthCheck.java.
Agora, abra o arquivo ArrayLengthCheck.java no editor e adicione o seguinte código:
public class ArrayLengthCheck {
public static void main(String[] args) {
// Declare and initialize an empty integer array
int[] emptyArray = {};
// Declare and initialize an integer array with elements
int[] populatedArray = {1, 2, 3, 4, 5};
// Check the length of the empty array
if (emptyArray.length == 0) {
System.out.println("emptyArray is empty.");
} else {
System.out.println("emptyArray is not empty. Length: " + emptyArray.length);
}
// Check the length of the populated array
if (populatedArray.length == 0) {
System.out.println("populatedArray is empty.");
} else {
System.out.println("populatedArray is not empty. Length: " + populatedArray.length);
}
}
}Vamos entender os novos conceitos aqui:
int[] emptyArray = {};: Isso declara um array de inteiros chamado emptyArray e o inicializa como um array vazio.int[] populatedArray = {1, 2, 3, 4, 5};: Isso declara um array de inteiros chamado populatedArray e o inicializa com cinco elementos inteiros.array.length: Esta é uma propriedade de um array em Java que fornece o número de elementos no array.if (condition) { ... } else { ... }: Esta é uma instrução if-else, uma estrutura fundamental de controle de fluxo em programação. Ela permite que seu programa tome decisões. Se a condition dentro dos parênteses for verdadeira, o código dentro do bloco if é executado. Caso contrário, o código dentro do bloco else é executado.Neste código, estamos usando a propriedade .length para verificar se o comprimento de cada array é igual a 0. Se for, imprimimos uma mensagem indicando que o array está vazio. Caso contrário, imprimimos uma mensagem indicando que não está vazio e também imprimimos seu comprimento.
Salve o arquivo (Ctrl+S ou Cmd+S).
Agora, abra o Terminal na parte inferior do WebIDE. Certifique-se de estar no diretório ~/project. Caso contrário, use o comando cd ~/project.
Compile o programa Java usando o comando javac:
javac ArrayLengthCheck.javaSe a compilação for bem-sucedida, você não verá nenhuma saída. Um arquivo ArrayLengthCheck.class será criado no diretório ~/project.
Agora, execute o programa compilado usando o comando java:
java ArrayLengthCheckVocê deve ver a seguinte saída:
emptyArray is empty.
populatedArray is not empty. Length: 5Esta saída confirma que nosso programa identificou corretamente o array vazio e o array preenchido com base em seus comprimentos. Verificar o comprimento de um array antes de tentar acessar seus elementos é uma etapa crucial para evitar erros como ArrayIndexOutOfBoundsException, que ocorre quando você tenta acessar um elemento em um índice que não existe no array.
Na etapa anterior, aprendemos como verificar se um array está vazio, verificando seu comprimento. No entanto, há outro cenário importante a ser considerado: e se o próprio array for null?
Em Java, uma variável pode conter uma referência a um objeto, ou pode conter o valor especial null, o que significa que ela não se refere a nenhum objeto. Se você tentar acessar a propriedade .length de uma variável de array que é null, seu programa travará com uma NullPointerException. Este é um erro muito comum em Java, por isso é importante saber como lidar com ele.
Vamos modificar nosso programa anterior para demonstrar e lidar com arrays null.
Abra o arquivo ArrayLengthCheck.java no editor WebIDE.
Substitua o código existente pelo seguinte:
public class ArrayLengthCheck {
public static void main(String[] args) {
// Declare an integer array but do not initialize it (it will be null)
int[] nullArray = null;
// Declare and initialize an empty integer array
int[] emptyArray = {};
// Declare and initialize an integer array with elements
int[] populatedArray = {1, 2, 3, 4, 5};
// Function to check if an array is null or empty
checkArrayStatus(nullArray, "nullArray");
checkArrayStatus(emptyArray, "emptyArray");
checkArrayStatus(populatedArray, "populatedArray");
}
// A helper method to check and print the status of an array
public static void checkArrayStatus(int[] arr, String arrayName) {
System.out.println("Checking " + arrayName + "...");
if (arr == null) {
System.out.println(arrayName + " is null.");
} else if (arr.length == 0) {
System.out.println(arrayName + " is empty.");
} else {
System.out.println(arrayName + " is not empty. Length: " + arr.length);
}
System.out.println(); // Print a blank line for better readability
}
}Vamos analisar as mudanças:
int[] nullArray = null;: Declaramos uma variável de array de inteiros nullArray e definimos explicitamente seu valor como null.public static void checkArrayStatus(int[] arr, String arrayName): Criamos um novo método chamado checkArrayStatus. Este método recebe um array de inteiros (arr) e uma string (arrayName) como entrada. Isso nos ajuda a reutilizar a lógica para verificar o status do array.if (arr == null): Esta é a parte crucial para lidar com arrays null. Primeiro, verificamos se a variável do array arr é null usando o operador de igualdade ==. Se for null, imprimimos uma mensagem e paramos de verificar outras condições para este array.else if (arr.length == 0): Esta verificação é executada somente se o array não for null. Se o array não for null, verificamos se seu comprimento é 0 para ver se está vazio.main agora chama checkArrayStatus para cada um de nossos arrays (nullArray, emptyArray e populatedArray).Salve o arquivo (Ctrl+S ou Cmd+S).
Abra o Terminal no diretório ~/project.
Compile o programa Java modificado:
javac ArrayLengthCheck.javaSe a compilação for bem-sucedida, execute o programa:
java ArrayLengthCheckVocê deve ver a seguinte saída:
Checking nullArray...
nullArray is null.
Checking emptyArray...
emptyArray is empty.
Checking populatedArray...
populatedArray is not empty. Length: 5Esta saída mostra que nosso programa identificou corretamente o array null, o array vazio e o array preenchido. Ao verificar se é null antes de verificar o comprimento, evitamos a NullPointerException que ocorreria se tentássemos acessar .length em um array null. Esta é uma prática recomendada fundamental na programação Java.
Nas etapas anteriores, trabalhamos com um array de inteiros (int[]). É importante entender que os conceitos de verificação de null e verificação da propriedade .length se aplicam a arrays de qualquer tipo de dado em Java, sejam tipos primitivos como int, double ou boolean, ou tipos de objeto como String ou classes personalizadas.
Vamos modificar nosso programa mais uma vez para demonstrar a verificação do status de arrays de diferentes tipos.
Abra o arquivo ArrayLengthCheck.java no editor WebIDE.
Substitua o código existente pelo seguinte:
public class ArrayLengthCheck {
public static void main(String[] args) {
// Declare a null String array
String[] nullStringArray = null;
// Declare an empty double array
double[] emptyDoubleArray = {};
// Declare a boolean array with elements
boolean[] populatedBooleanArray = {true, false, true};
// Declare a String array with elements
String[] populatedStringArray = {"apple", "banana", "cherry"};
// Use the helper method to check different array types
checkArrayStatus(nullStringArray, "nullStringArray");
checkArrayStatus(emptyDoubleArray, "emptyDoubleArray");
checkArrayStatus(populatedBooleanArray, "populatedBooleanArray");
checkArrayStatus(populatedStringArray, "populatedStringArray");
}
// A generic helper method to check and print the status of an array
// We use Object[] because it can represent an array of any object type
// For primitive types, the check still works on the array reference itself
public static void checkArrayStatus(Object arr, String arrayName) {
System.out.println("Checking " + arrayName + "...");
if (arr == null) {
System.out.println(arrayName + " is null.");
} else if (arr instanceof Object[]) {
// For object arrays, we can cast and check length
Object[] objectArray = (Object[]) arr;
if (objectArray.length == 0) {
System.out.println(arrayName + " is empty.");
} else {
System.out.println(arrayName + " is not empty. Length: " + objectArray.length);
}
} else if (arr.getClass().isArray()) {
// For primitive arrays, we can't cast to Object[], but can still check length
// using reflection or simply rely on the null check and the fact that
// primitive arrays also have a .length property accessible directly
// (though accessing it here would require more complex reflection)
// For simplicity in this example, we'll just indicate it's a non-null, non-empty primitive array
// A more robust check would involve reflection or overloaded methods for each primitive type
try {
int length = java.lang.reflect.Array.getLength(arr);
if (length == 0) {
System.out.println(arrayName + " is empty.");
} else {
System.out.println(arrayName + " is not empty. Length: " + length);
}
} catch (IllegalArgumentException e) {
System.out.println("Could not determine length for " + arrayName);
}
} else {
System.out.println(arrayName + " is not an array.");
}
System.out.println(); // Print a blank line for better readability
}
}Vamos analisar as mudanças:
String[], double[] e boolean[].checkArrayStatus agora recebe Object arr como um parâmetro. Isso permite que ele aceite arrays de qualquer tipo, pois todos os arrays em Java são objetos.checkArrayStatus, primeiro verificamos se arr é null.null, usamos instanceof Object[] para verificar se é um array de objetos. Se for, o convertemos para Object[] e verificamos seu .length.arr.getClass().isArray() para ver se o objeto é um array (isso é verdade tanto para arrays de objetos quanto para arrays primitivos)..length diretamente dentro deste método genérico é complicado sem reflexão. O código fornecido usa java.lang.reflect.Array.getLength(arr) como uma maneira mais geral de obter o comprimento de qualquer tipo de array.Salve o arquivo (Ctrl+S ou Cmd+S).
Abra o Terminal no diretório ~/project.
Compile o programa Java modificado:
javac ArrayLengthCheck.javaSe a compilação for bem-sucedida, execute o programa:
java ArrayLengthCheckVocê deve ver uma saída semelhante a esta:
Checking nullStringArray...
nullStringArray is null.
Checking emptyDoubleArray...
emptyDoubleArray is empty.
Checking populatedBooleanArray...
populatedBooleanArray is not empty. Length: 3
Checking populatedStringArray...
populatedStringArray is not empty. Length: 4Isso demonstra que os princípios de verificação de null e verificação do comprimento se aplicam consistentemente em diferentes tipos de array em Java. Embora o método genérico checkArrayStatus usando Object e reflexão seja mais complexo, a ideia central de verificar null primeiro e depois .length permanece a mesma para tipos de array específicos (como int[], String[], etc.).
Neste laboratório, aprendemos como verificar se um array em Java está vazio, examinando sua propriedade length. Criamos um arquivo Java ArrayLengthCheck.java e escrevemos código para declarar arrays de inteiros, tanto vazios quanto preenchidos. Ao usar uma instrução if-else e comparar o comprimento do array com zero, determinamos com sucesso se cada array estava vazio ou não, imprimindo os resultados no console. Essa técnica fundamental é crucial para prevenir erros ao trabalhar com arrays.
