How to Check If an Array Has a Specific Length in Java

Introduction

In this lab, you will learn how to check if an array in Java has a specific length. We will begin by understanding how to determine the size of an array using the built-in length property.

Following that, you will learn how to compare the array's length with an expected value to verify if it matches a desired size. Finally, we will explore how to handle null arrays when checking their length to avoid potential errors.

Skills Graph

Use length Property for Array Size

In this step, we will learn how to determine the size of an array in Java using the length property. Understanding the size of an array is fundamental for iterating through its elements or performing operations that depend on the number of elements it contains.

In Java, arrays have a built-in property called length that stores the number of elements the array can hold. This property is a final variable, meaning its value cannot be changed after the array is created.

Let's create a simple Java program to demonstrate how to use the length property.

1. Open the HelloJava.java file in the WebIDE editor if it's not already open.

2. Replace the entire contents of the file with the following code:

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

   Let's look at the new parts of this code:

   • int[] numbers = {10, 20, 30, 40, 50};: This line declares an integer array named numbers and initializes it with five integer values.
   • int arraySize = numbers.length;: This is where we use the length property. numbers.length accesses the size of the numbers array, and we store this value in an integer variable called arraySize.
   • System.out.println("The size of the array is: " + arraySize);: This line prints the value stored in the arraySize variable to the console.

3. Save the file (Ctrl+S or Cmd+S).

4. Now, let's compile our modified program. In the Terminal, make sure you are in the ~/project directory by running cd ~/project. Then, run:

   javac HelloJava.java

   If the compilation is successful, you will not see any output.

5. Finally, let's run our program:

   java HelloJava

   You should see the following output:

   The size of the array is: 5

   This output confirms that the length property correctly returned the number of elements in our numbers array.

Understanding how to get the size of an array is crucial for many programming tasks, such as looping through all elements or allocating memory for new arrays.

Compare with Expected Length

In this step, we will build upon our understanding of the length property by comparing the actual size of an array with an expected size. This is a common task in programming, especially when validating input or ensuring data integrity.

We can use conditional statements (like if statements) to check if the array's length matches a specific value.

Let's modify our HelloJava.java program to compare the array's length with an expected value.

1. Open the HelloJava.java file in the WebIDE editor.

2. Replace the current code with the following:

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

   Here's what's new:

   • int expectedSize = 5;: We declare an integer variable expectedSize and set it to 5, which is the size we expect our numbers array to be.
   • System.out.println("The expected size is: " + expectedSize);: We print the expected size for clarity.
   • if (arraySize == expectedSize): This is an if statement that checks if the value of arraySize is equal to the value of expectedSize. The == operator is used for comparison.
   • System.out.println("The array size matches the expected size.");: This line is executed if the condition in the if statement is true (the sizes match).
   • else: This keyword introduces the block of code to be executed if the condition in the if statement is false.
   • System.out.println("The array size does NOT match the expected size.");: This line is executed if the condition in the if statement is false (the sizes do not match).

3. Save the file (Ctrl+S or Cmd+S).

4. Compile the modified program in the Terminal:

   javac HelloJava.java

5. Run the compiled program:

   java HelloJava

   You should see output similar to this:

   The size of the array is: 5
   The expected size is: 5
   The array size matches the expected size.

   This output shows that our program correctly compared the actual array size (5) with the expected size (5) and printed the appropriate message.

You can try changing the expectedSize value or adding/removing elements from the numbers array to see how the output changes. This exercise helps you understand how conditional logic works with array properties.

Test with Null Arrays

In this final step, we will explore what happens when you try to access the length property of an array that has not been initialized, or is null. Understanding how to handle null values is crucial to prevent errors in your programs.

In Java, a variable that is declared but not assigned an object reference has a default value of null. If you try to access a property or method of a null object, Java will throw a NullPointerException. This is a common runtime error that you will encounter in Java programming.

Let's modify our program to see what happens when we try to access the length of a null array and how to handle it gracefully.

1. Open the HelloJava.java file in the WebIDE editor.

2. Replace the current code with the following:

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

   Here's a breakdown of the changes:

   • int[] numbers = null;: We declare the numbers array but explicitly set its value to null. This means the variable numbers does not currently refer to an actual array object in memory.
   • // int arraySize = numbers.length;: We have commented out the line that attempts to access numbers.length directly. If we were to run this code without the if check, it would result in a NullPointerException.
   • if (numbers != null): This is the crucial part for handling null. We use an if statement to check if the numbers variable is not null. The != operator means "not equal to".
   • int arraySize = numbers.length; System.out.println("The size of the array is: " + arraySize);: This block of code is only executed if numbers is not null. Inside this block, it is safe to access numbers.length.
   • else: This block is executed if the if condition is false, meaning numbers is null.
   • System.out.println("The array is null. Cannot get its length.");: This message is printed when the array is null, informing the user that the length cannot be determined.

3. Save the file (Ctrl+S or Cmd+S).

4. Compile the modified program in the Terminal:

   javac HelloJava.java

5. Run the compiled program:

   java HelloJava

   You should see the following output:

   The array is null. Cannot get its length.

   This output demonstrates that our program correctly identified that the array was null and handled the situation without throwing a NullPointerException.

Handling null values is a very important skill in Java programming. Always check if an object reference is null before attempting to access its properties or methods to avoid runtime errors.

Summary

In this lab, we learned how to determine the size of an array in Java using the built-in length property. This property provides a simple way to access the number of elements an array can hold. We demonstrated this by creating an integer array, accessing its length, and printing the result.

The subsequent steps will likely build upon this fundamental concept to compare the array's size with an expected length and handle potential null array scenarios, further solidifying our understanding of array manipulation in Java.