Arrays in Java tutorial: Declare and initialize Java arrays

What are arrays in Java?#

A variable is a location in our program with a name and value. This value could be any data type, like int. An array is another variable type or a container object with a fixed number of values that are all of a single type. In other words, a collection of similar data types. When an array is created, that size of the array (or length) is also fixed.

Simplified: Think of a Java array as a box with many compartments, and inside each compartment is one value

INDICES => index 0->index 1->index 2->index 3->...index n

ELEMENTS => element 1->element 2->element 3->element 4->....element n+1

Each compartment has a numerical index that we use to access a value. An array index always begins with 0. So, say we have 10 compartments in an array container box. There will be 10 indices, but they start from 0 and end at 9, because the index 0 points to the first element 1.

What’s unique about arrays in Java?#

Arrays in every language will differ slightly. Here are the unique qualities of arrays in Java that differ from other languages you may use, like C or C++.

• Arrays are dynamically allocated
• Arrays are objects in Java
• A Java array variable is declared like other variables
• The variables are ordered, with the index beginning at 0
• The superclass of the array type is Object
• The size of an array is specified with an int value

Types of arrays in Java#

In Java, there are a few different types of arrays that we can work with.

A one-dimensional array is a normal array that you will use most often. This type of array contains sequential elements that are of the same type, such as a list of integers.

Note: ArrayList is included in the java.util package.

Declaring an array in Java#

Now that we know the types of arrays we can use, let’s learn how to declare a new array in Java. Here is the basic syntax for array declaration.

dataType[] arrayName;

• dataType: this can be any Java object or primitive data type (such as int, byte, char, boolean, etc.)
• arrayName: this is an identifier so you can access the array

Let’s create a simple array in Java to understand the syntax. First, declare the variable type using square brackets [].

String[] dogs;

Now we have a variable that holds an array of strings. We can insert values using an array literal. We place our values in a list separated by commas that are held within curly brackets {}.

String[] dogs = {"Pitbull", "Poodle", "Lab", "Pug"};

Creating an array of integers will look like this:

int[] myNum = {5, 10, 15, 20};

As we learned, arrays have a fixed amount of elements. We have to define the number of elements that our array will hold to allocate memory. Here’s the basic syntax for memory allocation.

// declaring an array 
double[] data; 

// allocating memory 
data = new Double[5];

Above, the array can store 5 elements, meaning the length of the array is 5. For another example, say we want to store the names of 50 people. We create an array of the string type. The array below can only store up to 50 elements.

String[] array = new String[50];

There are other ways to declare an array in Java. Here are the three options:

• int[] myNumberCollection = new int[5];
• int[] myNumberCollection; myNumberCollection = new int[5];
• int[] myNumberCollection = {1, 2, 56, 57, 23};

In the first two cases, we add elements to the array container manually. In the third case, we added the elements when we declared the array.

// initializing the first element

    myNumberCollection[0] = 1;

// initializing the second element

    myNumberCollection[1] = 2;

Note: The official Java documentation recommends using the following format to declare an array:

public static void main(String[] args){}.

Initializing an array in Java#

In Java, we can declare and initialize arrays at the same time.

• Initialization occurs when data is assigned to a variable.
• Declaration occurs when the variable is created.

So, when you first create a variable, you are declaring it but not necessarily initializing it yet.

Here’s an example of how to declare and initialize values in Java:

//declare and initialize an array

int[] age = {25, 50, 23, 21};

Above, we declared an array using int[] age and initialized it by assigning the values {25, 50, 23, 21}.

Note: You don’t need to declare the size of the array because the Java compiler automatically counts the size for you.

We can also initialize arrays using the index number, as shown below:

// declare an array 

int[] age = new int[5]; 

// initialize array 

age[0] = 25; 

age[1] = 50; 

...

Accessing and changing elements of an array#

We access the elements of an array by referencing its index number. Remember, the index begins with 0 and ends at the total array length, minus one. You can access all elements of an array using a for loop. Loops are used in programming to perform repetitive tasks that require conditions.

Syntax for accessing elements of an array:

// access array elements
array[index]

We can also change the value of an element through its index number. Using our example above, say we want to change Pitbull to Terrier.