Arrays in Java tutorial: Declare and initialize Java arrays
Tags: java, tutorial, programming, productivity
Published: 2022-12-23 20:27:19

Java remains one of the world's [most popular programming languages](https://www.educative.io/blog/programming-languages-guide?eid=5082902844932096) due to its platform independence. Many new developers [learn Java](https://www.educative.io/blog/best-programming-language-learn-2021?eid=5082902844932096) as their first language. Java is known for being **verbose**, and some developers struggle to get the basics down. 

Understanding **[data structures](https://www.educative.io/blog/data-structures-trees-java?eid=5082902844932096)** is a key component of Java programming, and arrays are the first step. To help your Java journey, in this tutorial, we will learn **how to implement and use arrays in Java**. A Java array is a group of similarly-typed variables that use a shared name. 

Today, we will learn what's unique about arrays in Java syntax and explore how to declare, initialize, and operate on array elements.

**Today, we will learn:**

* [What are arrays in Java?](#what)
* [Types of arrays in Java](#types)
* [Declaring an array in Java](#declare)
* [Initializing an array in Java](#initialize)
* [Accessing and changing elements of an array](#accessing)
* [Looping through array elements](#loop)
* [Common Java array operations](#operate)
* [What to learn next](#next)

<a name="what"></a>

## 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, the 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.

![Arrays in Java](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/b1fhy6hcyr82wk5w3py9.png)

The compartments in the box must remain ordered using **indexing**. Array elements are indexed, and each index should point to an element. It will look something like this:

```java
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.

![Arrays](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/v52kkr1qt3xi5i9n33nz.png)

### 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

<a name="types"></a>

## 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. 

```java
int[] myArray = {10, 20, 30, 40}
```

A **multidimensional array** is an array of arrays. A two-dimensional array is an array made up of multiple one-dimensional arrays. A three-dimensional array is an array made up of multiple two-dimensional arrays.

```java
// Two-dimensional array
int[][] a = new int[3][4];

// Three-dimensional array
String[][][] data = new String[3][4][2];
```

**An array of objects** is created just like an array of primitive data types.

```java
Student[] arr = new Student[4]; 

//This is a user-defined class
```

The **ArrayList** is a class that is a resizable array. While built-in arrays have a fixed size, `ArrayList` can **change their size dynamically**, so the elements of the array can be added and removed using methods, much like vectors in C++.

> **Note:** `ArrayList` is included in the `java.util` package. 

```java
import java.util.ArrayList; //import the ArrayList class

class MyClass {

    public static void main( String args[] ) {

    ArrayList<String> shapes = new ArrayList<String>(); // Create an ArrayList object with a string data type

    }

}
```

<a name="declare"></a>

## 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.

```java
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** `[]`.

```java
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** `{}`.

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

> Creating an array of integers will look like this:

```java
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. 

```java
// 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.

```java
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.


```java
// 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){}`**.

<a name="initialize"></a>

## 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:

```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:

```java
// declare an array 

int[] age = new int[5]; 

// initialize array 

age[0] = 25; 

age[1] = 50; 

...

```

<a name="accessing"></a>

## 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:

```java
// access array elements
array[index]
```

Let's continue using our `dogs` example from before. Below, we want to write a program that can find the first value of the array and then print the result.

```java
class Main {
 public static void main(String[] args) {
  
   // create an array
   String[] dogs = {"Pitbull", "Poodle", "Lab", "Pug"};

   // access first element 
   System.out.println("First Element: " + dogs[0]);

 }
}
```

```java
-->
First Element: Pitbull
```

> **Note:** In Java, you can use `System.out.println()` to print a value. 

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`.

```java
class Main {
 public static void main(String[] args) {
   
    String[] dogs = {"Pitbull", "Poodle", "Lab", "Pug"};
    
    System.out.println("Before update" + dogs[0]); // print old value

    dogs[0] = "Terrier"; // changing value

    System.out.println("After update" + dogs[0]); // print new value

    }
}
```

```java
-->
Before updatePitbull
After updateTerrier
```

<a name="loop"></a>

## Looping through array elements

We can also loop through each element of the array. In Java, there are multiple methods for looping over an array. You can use `for`, the enhanced `for` loop (aka for-each), `while`, or `do-while` loop. 

> A traditional `for` loop allows you to iterate until you reach the last element. Enhanced `for` loops allow you to iterate without dealing with counts.

Instead of printing each element, you can use a `for` loop to iterate through the array. The array will start iterating at the index `0` and traverse the length of the array. 

Let's look at an example of a `for` loop to see how it works in Java. Below, we use the Java `for` loop to iterate through each array element. We use the `.length` property to get the size of our array.

```java
class Main {
 public static void main(String[] args) {
  
   // create an array
   int[] age = {3, 2, 7, 8};

   // loop through the array with the for loop
   System.out.println("Using the for loop: ");
   for(int i = 0; i < age.length; i++) {
     System.out.println(age[i]);
   }
 }
}
```

```java
-->
Using the for loop: 3 2 7 8
```

> **Note**: `for` loops in Java are identical to those found written in C and JavaScript.

<a name="operate"></a>

## Common Java array operations 

Once we create and initialize our arrays, we need to learn how to **manipulate** and **use** them. There is [a lot we can do with arrays](https://www.educative.io/blog/5-java-techniques-strings-arrays?eid=5082902844932096) in Java. These kinds of operations are very common questions in coding interviews. Here are examples of some of the operations you can do on Java arrays.

### Get the first and last element

This is one of the most common tasks we can do with Java arrays due to its index-based organization. First, we declare and initialize an array of integers using `int`.

Then we use the index value `0` and the `.length` attribute to retrieve specific elements. 

```java
class Main {
 public static void main(String[] args) {
     int[] array = new int[] { 1, 2, 3, 4, 5, 6 };

     int firstItem = array[0];

int lastItem = array[array.length - 1];

 }
}
   
```

### Add a new item to an Array

Since Java can only allocate elements to an array up to a certain size (2,147,483,647 elements), we cannot add items that exceed this limit. Instead, we can declare a **larger array** and **copy the elements** of the smaller array into it. 

The `Arrays` class contains various methods for manipulating arrays, including the ability to replicate the values of an array.

```java
int[] newArray = Arrays.copyOf(array, array.length + 1);

newArray[newArray.length - 1] = newItem;
```

### Convert a list to an array

There are two variants of this method:

1.  `toArray()`: This method returns an array of type `Object[]` whose elements are all in the same sequence as they are in the list. Casting is used to specify each element’s type when performing some operations.

```java
import java.util.ArrayList;

public class ListToArray {

	public static void main(String[] args) {
		// A list of size 4 which is to be converted:
		ArrayList<Integer> list = new ArrayList<>();
		list.add(1);
		list.add(2);
		list.add(3);
		list.add(4);
		
		// ArrayList converted to Object[] array:
		Object[] objArr = list.toArray();
		for(Object obj: objArr){
      // Using casting before performing addition:
      System.out.println((Integer)obj + 1);
    }
  }
}

}
```

2.  `toArray(T[] arr)`: This variant takes an already defined array as its parameter. When the array’s size is greater than or equal to the size of the list, then the array is filled with the elements of the list. Since the type of the returned array is specified by the parameter’s type, casting is unnecessary. 

```java
import java.util.ArrayList;

public class ListToArray {

	public static void main(String[] args) {
    // A list of size 4 to be converted:
		ArrayList<Integer> list = new ArrayList<>();
		list.add(2);
		list.add(3);
		list.add(4);
		list.add(5);
		
    // Declaring an array of size 4:
		Integer[] arr = new Integer[4];
		
    // Passing the declared array as the parameter:
    list.toArray(arr);
		
    // Printing all elements of the array:
    System.out.println("Printing 'arr': ");
		for(Integer i: arr)
      System.out.println(i);

    // Declaring another array of insufficient size:
    Integer[] arr2 = new Integer[3];

    // Passing the array as the parameter:
    Integer[] arr3 = list.toArray(arr2);

    // Printing the passed array:
    System.out.println("\n'arr2' isn't filled because it is small in size: ");
    for(Integer i: arr2)
      System.out.println(i);
    
    // Printing the newly allocated array:
    System.out.println("\n'arr3' references the newly allocated array: ");
    for(Integer i: arr3)
      System.out.println(i);
	}
}
```

### Get a random value

We can use the object, `java.util.Random`, to access any value of the array at random. 


```java
int anyValue = array[new Random().nextInt(array.length)];
```

### Insert a value between two other values

Inserting an item in an array between two others is somewhat tricky. The class `ArrayUtils` was created to make this possible. Here, we specify the index where we want to insert the value. Our output should be a new array containing an updated number of elements.

```java
int[] largerArray = ArrayUtils.insert(2, array, 77);
```

### Check if an array is empty

We can use the `.length` attribute to check if an array is empty or not using a boolean. 

```java
boolean isEmpty = array == null || array.length == 0;
```
The `ArrayUtils` helper class also offers a null-safe method for this process, but this function depends on the length of the data structure.

```java
boolean isEmpty = ArrayUtils.isEmpty(array);
```

<a name="next"></a>

## What to learn next

Congrats! You should now have a good idea of how arrays work in Java. **There is still more to learn!** There are so many [array operations](https://www.educative.io/blog/javascript-array-methods-map-reduce?eid=5082902844932096) that we can perform, and many of these are asked during coding interviews. 

Take a look at this list to get an idea of what to learn next:

* Copy an array in Java
* Box and unbox an array 
* Shuffle elements of an array 
* Find the `min` and `max` in an array with Java
* Remove the first element of an array
* Find the sum and average of a Java array
* Invert an array in Java

Or, you can find out how to [learn Java from scratch!](https://www.educative.io/blog/learn-java-from-scratch?eid=5082902844932096)

The best way to learn Java is through hands-on practice. Check out Educative's definitive Java course **[A Complete Guide to Java Programming](https://www.educative.io/courses/complete-guide-to-java-programming?eid=5082902844932096)** to continue learning these operations and beyond. There are lots of interactive Java tutorials and lessons to help you nail the fundamentals of programming and more advanced topics like iterative constructs, useful algorithms, and data structures. 

This course will get you on the fast track to becoming a proficient and modern Java developer. You can even earn a certificate to add to your resume!

*Happy learning!*

### Continue reading about Java on Educative 
* [5 simple and effective Java techniques for strings and arrays](https://www.educative.io/blog/5-java-techniques-strings-arrays?eid=5082902844932096)
* [Crack the Top 40 Java Coding Interview Questions](https://www.educative.io/blog/top-java-coding-interview-questions?eid=5082902844932096)
* [How to use Stack and Queues in Java](https://www.educative.io/blog/data-structures-stack-queue-java-tutorial?eid=5082902844932096)

### Start a discussion
What is your favorite Java structure or algorithm? Was this article helpful? Let us know in the comments below!