Java Array

In our previous articles we seen the variable declaration, initialization and, they are pretty good for initializing few variables. What if we want to store 100 employees salary? Is it worth to create 100 variables and assign those values, What happen if it is 150 employees. In order to handle these type of situation, Java Programming language introduced the concept of arrays. In this article we will show you, How to declare Java array, creating java array, initialization and accessing java array elements.

Java Array

In Java Array is a container objects that holds a collection of similar type of elements (type may be integer, float, long etc). It means, we can’t store multiple data type values. For example, an integer array will store all the integer elements, if you try to insert a float or char value then it will throw an error.

TIP: The length of an array is decided when we are creating an array. Once it is created, length is fixed

In Java Programming, We have 3 types of arrays

One Dimensional Array
Two Dimensional Array
Multi-Dimensional Array
- Three Dimensional Array
- Four Dimensional Array etc

Java array declaration or Syntax

Following code snippet will show you the most basic way of Java array declaration:

Data_Type[] Array_Name;

Data_type: It will decide the type of elements array will accept. For example, If we want to store integer values then, the Data Type will be declared as int, If we want to store Float values then, the Data Type will be float etc
Array_Name: This is the name you want to give it to array. For example students, age, marks, employees etc

Similarly you can declare the remaining type of arrays:

int [] anIntegerArray; // declaring an array of Integers
byte[] anByteArray; // declaring an array of Bytes
short[] anShortArray; // declaring an array of Shorts
long[] anLongArray; // declaring an array of Longs
float[] anFloatArray; // declaring an array of Floats
double[] anDoubleArray; // declaring an array of Doubles
boolean[] anBooleanArray; // declaring an array of Booleans
char[] anCharArray; // declaring an array of Chars
String[] anStringArray; // declaring an array of Strings

Java Create Array

In order to create an array we have to use the New operator as we shown below:

Data_Type[] Array_Name = new Array_Name[Array_Size];

If you observe the above code snippet,

Array_Size: Number of elements an array can hold or store. For example, Array_Size =10 then array will hold 10 values.

If you already initialized an array then

int [] anIntegerArray; // Java array declaration

// Crating an Java Array
anIntegerArray = new int[10];

For Example,

int[] Student_Marks = new int[10];

Here, we used int as the data type to declare an array. So, above array will accept only integers. If you try to add float values then it will through an error.
Student_Age is the array name
The size of an Array is 10 it means, Student_Marks array will only accept 10 integer values.
- If we try to store more than 10 then it will throw an error.
- We can store less than 10. For Example, If we store 3 integer values then remaining 2 values will be initialized to default value (Which is 0).

Java Array Initialization

There are multiple ways to initialize the array in Java Programming language

First Approach

Declaring and Creating an Array

int[] Student_Marks = new int[3];

Initializing Array elements in more traditional way

Student_Marks[0] = 15; // Initializing First array elements at position 0
Student_Marks[1] = 45; // Initializing First array elements at position 1
Student_Marks[2] = 65; // Initializing First array elements at position 2

Second Approach

In this approach, We will initialize the array at the declaration time only

int[] anIntegerArray = {15, 25, 35, 45, 55}

Here, We did not mention the array size but the compiler is intelligent enough to calculate the size by checking the number of elements.

Third Approach

Although this approach works without any error but, this is not the preferred way to initialize a java array

int Employees[ ] = {1, 2, 3, 4, 5}

Fourth Approach

Above 3 approaches are good to store small number of elements into an array, What if we want to store 50, 100 or more values. It will be a nightmare to add all of them using any of the above mentioned approaches. To resolve this, we can use the loop concept here:

int i, Employees[100];

for (i =0; i < 100 ; i++)
 {
   Employees[i] = i * 2;
 }

TIP: In order to store the elements in an array, We can use For loop, While Loop and Do While Loop

Fifth Approach

int[] anIntegerArray = new int[5];
anIntegerArray[0] = 10;
anIntegerArray[1] = 20;
anIntegerArray[2] = 30;

Here we declared an anIntegerArray array of size 5 but we only assigned 3 values to it. In this situation, the remaining values will be assigned to default values (0 in this case).

The above array will be:

//It means
anIntegerArray[0] = 10
anIntegerArray[1] = 20
anIntegerArray[2] = 30
anIntegerArray[3] = 0
anIntegerArray[4] = 0

Accessing Java Array Elements

In Java programming, We can use the index position to access the elements of an Array. Using index we can access or alter/change each and every individual element present in an array. Index value starts at 0 and end at n-1 where n is the size of an array (or Length of an array). For example, if an array stores 10 elements then index starts at 0 and ends at 9. To access or alter 1^st value use Array_Name[0] and to access or alter 10^th value, use Array_Name[10]. Lets see the example for better understanding:

JAVA CODE

// Accessing Java Array elements example 

package ArrayDefinitions;

public class ArrayTest {

	public static void main(String[] args) {
		int[] anIntegerArray = {15, 25, 35, 45, 55, 65};

		System.out.println(anIntegerArray[0]);
		System.out.println(anIntegerArray[1]);
		System.out.println(anIntegerArray[2]);
		System.out.println(anIntegerArray[3]);
		System.out.println(anIntegerArray[4]);
		System.out.println(anIntegerArray[5]);
	}
}

OUTPUT

Java Array example

In this Java program, We will declare an integer array of size 10 and then we will sum those 10 values and displays the output.

JAVA CODE

// Java Array example: Sum of the elements inside an Array 

package ArrayDefinitions;

public class JavaArray {

	public static void main(String[] args) {
		int i, Sum =0;
		int [] anIntegerArray = {10, 20, 30, 40, 50, 60, 70, 80, 90, 100};
		
		for(i = 0; i < anIntegerArray.length; i++) {
			Sum = Sum + anIntegerArray[i];
			
			System.out.format("Addition of %d to Sum = %d \n", anIntegerArray[i], Sum);
		}
		System.out.format("Sum of the elemts in anIntegerArray = %d \n", Sum);
	}
}

OUTPUT

ANALYSIS

In this Program, We declared 1 One Dimensional Arrays anIntegerArray[] with 10 elements and also declared i to iterate the Array elements,

int [] anIntegerArray = {10, 20, 30, 40, 50, 60, 70, 80, 90, 100};

Below For loop will help to iterate each and every cell present in the anIntegerArray[4] array. Condition inside the for loops (i < anIntegerArray.length) will ensure the compiler, not to exceed the array limit.

Sum = Sum + anIntegerArray[i]; statement is used to add each and individual array element present in the anIntegerArray to Sum variable.
System.out.format statement will display the Sum value after every iteration.

TIP: anIntegerArray.length is used to find the length of an array.

for(i = 0; i < anIntegerArray.length; i++) {
	Sum = Sum + anIntegerArray[i];
        
        System.out.format("Addition of %d to Sum = %d \n", anIntegerArray[i], Sum);

Let us see the Iteration,

First Iteration

The value of i will be 0 and the condition (i < 10) is True. So, it will start executing the statements inside the loop.

Sum = Sum + anIntegerArray[i]

Sum = Sum + anIntegerArray[0]

Sum = 0 + 10 = 10