Neste laboratório, você aprenderá como verificar se um array em Java possui um comprimento específico. Começaremos entendendo como determinar o tamanho de um array usando a propriedade length integrada.
Em seguida, você aprenderá como comparar o comprimento do array com um valor esperado para verificar se ele corresponde a um tamanho desejado. Por fim, exploraremos como lidar com arrays nulos ao verificar seu comprimento para evitar possíveis erros.
Nesta etapa, aprenderemos como determinar o tamanho de um array em Java usando a propriedade length. Entender o tamanho de um array é fundamental para iterar por seus elementos ou realizar operações que dependem do número de elementos que ele contém.
Em Java, arrays possuem uma propriedade integrada chamada length que armazena o número de elementos que o array pode conter. Essa propriedade é uma variável final, o que significa que seu valor não pode ser alterado após a criação do array.
Vamos criar um programa Java simples para demonstrar como usar a propriedade length.
Abra o arquivo HelloJava.java no editor WebIDE, caso ainda não esteja aberto.
Substitua todo o conteúdo do arquivo pelo seguinte código:
public class HelloJava {
public static void main(String[] args) {
// Declare and initialize an integer array
int[] numbers = {10, 20, 30, 40, 50};
// Get the length of the array using the length property
int arraySize = numbers.length;
// Print the size of the array
System.out.println("The size of the array is: " + arraySize);
}
}Vamos analisar as novas partes deste código:
int[] numbers = {10, 20, 30, 40, 50};: Esta linha declara um array de inteiros chamado numbers e o inicializa com cinco valores inteiros.int arraySize = numbers.length;: É aqui que usamos a propriedade length. numbers.length acessa o tamanho do array numbers e armazenamos esse valor em uma variável inteira chamada arraySize.System.out.println("The size of the array is: " + arraySize);: Esta linha imprime o valor armazenado na variável arraySize no console.Salve o arquivo (Ctrl+S ou Cmd+S).
Agora, vamos compilar nosso programa modificado. No Terminal, certifique-se de estar no diretório ~/project executando cd ~/project. Em seguida, execute:
javac HelloJava.javaSe a compilação for bem-sucedida, você não verá nenhuma saída.
Finalmente, vamos executar nosso programa:
java HelloJavaVocê deve ver a seguinte saída:
The size of the array is: 5Esta saída confirma que a propriedade length retornou corretamente o número de elementos em nosso array numbers.
Entender como obter o tamanho de um array é crucial para muitas tarefas de programação, como percorrer todos os elementos ou alocar memória para novos arrays.
Nesta etapa, vamos construir sobre nossa compreensão da propriedade length comparando o tamanho real de um array com um tamanho esperado. Esta é uma tarefa comum em programação, especialmente ao validar a entrada ou garantir a integridade dos dados.
Podemos usar instruções condicionais (como instruções if) para verificar se o comprimento do array corresponde a um valor específico.
Vamos modificar nosso programa HelloJava.java para comparar o comprimento do array com um valor esperado.
Abra o arquivo HelloJava.java no editor WebIDE.
Substitua o código atual pelo seguinte:
public class HelloJava {
public static void main(String[] args) {
int[] numbers = {10, 20, 30, 40, 50};
int expectedSize = 5; // We expect the array to have 5 elements
int arraySize = numbers.length;
System.out.println("The size of the array is: " + arraySize);
System.out.println("The expected size is: " + expectedSize);
// Compare the actual size with the expected size
if (arraySize == expectedSize) {
System.out.println("The array size matches the expected size.");
} else {
System.out.println("The array size does NOT match the expected size.");
}
}
}Aqui está o que é novo:
int expectedSize = 5;: Declaramos uma variável inteira expectedSize e a definimos como 5, que é o tamanho que esperamos que nosso array numbers tenha.System.out.println("The expected size is: " + expectedSize);: Imprimimos o tamanho esperado para clareza.if (arraySize == expectedSize): Esta é uma instrução if que verifica se o valor de arraySize é igual ao valor de expectedSize. O operador == é usado para comparação.System.out.println("The array size matches the expected size.");: Esta linha é executada se a condição na instrução if for verdadeira (os tamanhos correspondem).else: Esta palavra-chave introduz o bloco de código a ser executado se a condição na instrução if for falsa.System.out.println("The array size does NOT match the expected size.");: Esta linha é executada se a condição na instrução if for falsa (os tamanhos não correspondem).Salve o arquivo (Ctrl+S ou Cmd+S).
Compile o programa modificado no Terminal:
javac HelloJava.javaExecute o programa compilado:
java HelloJavaVocê deve ver uma saída semelhante a esta:
The size of the array is: 5
The expected size is: 5
The array size matches the expected size.Esta saída mostra que nosso programa comparou corretamente o tamanho real do array (5) com o tamanho esperado (5) e imprimiu a mensagem apropriada.
Você pode tentar alterar o valor de expectedSize ou adicionar/remover elementos do array numbers para ver como a saída muda. Este exercício ajuda você a entender como a lógica condicional funciona com as propriedades do array.
Nesta etapa final, exploraremos o que acontece quando você tenta acessar a propriedade length de um array que não foi inicializado, ou é null. Entender como lidar com valores null é crucial para evitar erros em seus programas.
Em Java, uma variável que é declarada, mas não recebe uma referência de objeto, tem um valor padrão de null. Se você tentar acessar uma propriedade ou método de um objeto null, o Java lançará uma NullPointerException. Este é um erro comum de tempo de execução que você encontrará na programação Java.
Vamos modificar nosso programa para ver o que acontece quando tentamos acessar o length de um array null e como lidar com isso de forma elegante.
Abra o arquivo HelloJava.java no editor WebIDE.
Substitua o código atual pelo seguinte:
public class HelloJava {
public static void main(String[] args) {
int[] numbers = null; // Declare an array but set it to null
// Attempt to access the length property (this will cause an error)
// int arraySize = numbers.length; // Commenting this out to prevent error
// How to safely check for null before accessing length
if (numbers != null) {
int arraySize = numbers.length;
System.out.println("The size of the array is: " + arraySize);
} else {
System.out.println("The array is null. Cannot get its length.");
}
}
}Aqui está uma análise das mudanças:
int[] numbers = null;: Declaramos o array numbers, mas definimos explicitamente seu valor como null. Isso significa que a variável numbers atualmente não se refere a um objeto de array real na memória.// int arraySize = numbers.length;: Comentamos a linha que tenta acessar numbers.length diretamente. Se executássemos este código sem a verificação if, resultaria em uma NullPointerException.if (numbers != null): Esta é a parte crucial para lidar com null. Usamos uma instrução if para verificar se a variável numbers não é null. O operador != significa "não igual a".int arraySize = numbers.length; System.out.println("The size of the array is: " + arraySize);: Este bloco de código é executado somente se numbers não for null. Dentro deste bloco, é seguro acessar numbers.length.else: Este bloco é executado se a condição if for falsa, significando que numbers é null.System.out.println("The array is null. Cannot get its length.");: Esta mensagem é impressa quando o array é null, informando ao usuário que o comprimento não pode ser determinado.Salve o arquivo (Ctrl+S ou Cmd+S).
Compile o programa modificado no Terminal:
javac HelloJava.javaExecute o programa compilado:
java HelloJavaVocê deve ver a seguinte saída:
The array is null. Cannot get its length.Esta saída demonstra que nosso programa identificou corretamente que o array era null e lidou com a situação sem lançar uma NullPointerException.
Lidar com valores null é uma habilidade muito importante na programação Java. Sempre verifique se uma referência de objeto é null antes de tentar acessar suas propriedades ou métodos para evitar erros de tempo de execução.
Neste laboratório, aprendemos como determinar o tamanho de um array em Java usando a propriedade length integrada. Esta propriedade fornece uma maneira simples de acessar o número de elementos que um array pode conter. Demonstramos isso criando um array de inteiros, acessando seu length e imprimindo o resultado.
As etapas subsequentes provavelmente se basearão neste conceito fundamental para comparar o tamanho do array com um comprimento esperado e lidar com possíveis cenários de array nulo, solidificando ainda mais nossa compreensão da manipulação de arrays em Java.
