Skip to main content

4.2 Working with Arrays

Version Check​

Before proceeding, ensure you are using Java 8. You can verify your version by running the following command in your terminal:

java -version

Introduction and Setup​

In Java, arrays are objects that store multiple values of the same type in a contiguous memory location. Arrays provide a convenient way to store and manipulate large datasets. This document will cover essential concepts of working with arrays in Java 8.

Understanding Arrays​

An array in Java is a data structure that holds a fixed number of values of a single type. Arrays can hold both primitive types (e.g., int, double) and objects (e.g., String, Integer).

Key Points:​

  • Arrays have a fixed size, determined at the time of creation.
  • The length of an array cannot be changed once it's created.
  • Arrays store elements in contiguous memory locations.

Declaring and Initializing Arrays​

In Java, you declare an array by specifying the type of the elements and using square brackets [].

int[] numbers;  // Declaration
numbers = new int[5];  // Initialization with a size of 5

You can also initialize the array with values:

int[] numbers = {1, 2, 3, 4, 5};  // Declaration and initialization

Accessing Array Elements​

You can access elements in an array using their index. In Java, array indices start from 0.

int firstNumber = numbers[0];  // Accessing the first element

Iterating over Arrays​

There are different ways to loop through arrays in Java:

  • Using a for loop:

    for (int i = 0; i < numbers.length; i++) {
        System.out.println(numbers[i]);
    }
    Note

    In Java, the index of an array starts at zero (0), so when iterating through an array, the condition should always be i < arrayVariable.length to avoid accessing out-of-bounds indices, which can lead to an ArrayIndexOutOfBoundsException.

  • Using an enhanced for loop:

    for (int number : numbers) {
        System.out.println(number);
    }

Arrays Are Objects​

In Java, arrays are objects, and they inherit from java.lang.Object. This means that arrays have methods and can be passed to methods just like objects.

Passing Arrays to Methods​

Arrays can be passed as arguments to methods. Any changes made to the array within the method affect the original array.

public void modifyArray(int[] arr) {
    arr[0] = 10;  // This change will affect the original array
}

Utility Methods for Working with Arrays​

Java provides a utility class java.util.Arrays that contains various methods to work with arrays.

  • Sorting an array:

    Arrays.sort(numbers);

  • Filling an array:

    Arrays.fill(numbers, 1);  // Fill the array with the value 1

  • Converting an array to a string:

    String arrayAsString = Arrays.toString(numbers);

Summary​

Arrays in Java are powerful and flexible data structures. They provide a way to store multiple values of the same type efficiently. Understanding how to declare, initialize, and work with arrays is essential for any Java developer. Java 8 also provides useful utility methods in the Arrays class for sorting, filling, and manipulating arrays.