Array Programs in Java
Array Programs in Java: An array is a data structure that stores similar elements in a contiguous memory location. In Java, an array is an object that stores the same kind of elements. Arrays in Java are index-based, i.e., the first element is stored in the 0th index, the second element is stored in the 1st index, and the last element of the array is stored in the (n – 1)th index, where n is the size of the array. Java provides the attribute length to find the size of the array. The array programs in Java tells how to use array in Java programs. Note that Java arrays are the objects of a dynamically generated class. In Java, arrays implement Cloneable and Serializable interfaces. Java arrays also inherit the class Object. Arrays are not the primitive data type; however, they can be used to store primitive data types.
Creating an Array in Java
The following program demonstrates how to create an array and display its elements on the console.
FileName: ArrayCreation.java
public class ArrayCreation
{
public static void main(String args[])
{
int arr[]; // array declaration
arr = new int[5]; // allocating memory for 5 elements
// Assigning different integral values to the elements of the array
arr[0] = 1; // arr[0] means accessing the first element of the array
arr[1] = 2; // arr[1] means accessing the second element of the array and so on.
arr[2] = -3;
arr[3] = 4;
arr[4] = 5;
int size = arr.length; // calculating size of the array
System.out.println("Elements of the array are: ");
// displaying array elements on the console
for(int i = 0; i < size; i++)
{
System.out.println( arr[i] );
}
}
}
Output:
Elements of the array are: 1 2 -3 4 5
Explanation:
The statement :
int arr[];
means we are declaring an integer array whose name is arr. The square brackets ([]) indicate that we are dealing with the array. For character array, replace the keyword int with char. In a similar way, we can declare any type of array.
The statement
arr = new int[5];
allocates the memory for 5 integers in the heap memory. The reference of that allocated memory is stored in arr. Note that while allocating the memory, all the elements are also initialized to 0, i.e.,
arr[0] = arr[1] = arr[2] = arr[3] = arr[4] = 0;
This is because 0 is the default value of an integer in Java.
After that, the following are five statements override the default values present in the elements of the array.
arr[0] = 1; arr[1] = 2; arr[2] = -3; arr[3] = 4; arr[4] = 5;
During the memory allocation, JVM also assigns size of the array to the attribute length, which is 5 in our case. We have accessed the length attribute using the array object. The attribute length is of type int.
int size = arr.lengh;
arr.length contains the value 5, as we have allocated memory for 5 elements, which is assigned to the variable size.
The Java for-loop is used to iterate over each element of the array so that we can print it on the console.
Another Approach for Creating Arrays
We see that in 3 steps, we are doing declaration, allocation of memory and assigning values. These 3 steps can be squeezed into one statement.
Consider the following program.
FileName: ArrayCreation1.java
public class ArrayCreation1
{
public static void main(String args[])
{
// array declaration cum memory allocation cum initialization
int arr[] = {1, 2, -3, 4, 5};
int size = arr.length; // calculating size of the array
System.out.println("Elements of the array are: ");
// displaying array elements on the console
for(int i = 0; i < size; i++)
{
System.out.println( arr[i] );
}
}
}
Output:
Elements of the array are: 1 2 -3 4 5
Explanation:
The statement
int arr[] = {1, 2, -3, 4, 5};
first makes the declaration of the integer array whose name or reference variable is arr. We see that we have not used the new keyword. Hence, JVM implicitly allocates the memory for 5 integer elements of the array and initializes with the values 1, 2, -3, 4, and 5. The rest of the code is the same as the previous one.
Note that we have only created a one-dimensional array in the above two programs. However, we can also create a two or more than two-dimensional array in Java.
Creating Multi-Dimensional Array
Instead of using a pair square brackets ([]), we have to use two pairs of square brackets ([][]) to create a two-dimensional array in Java. A two-dimensional array is an array of array, i.e., each element of the one-dimensional array is also an array. Observe the following program.
FileName: TwoDArrayCreation.java
public class TwoDArrayCreation
{
public static void main(String args[])
{
int arr[][]; // 2 - D array declaration
// Creating 2 - D array by allocating memory
arr = new int[2][3];
// calculating number of rows of the 2 - D array
int row = arr.length;
// calculating number of columns of the 2 - D array
int col = arr[0].length;
// for assigning values to the elements of the array
int val = 9;
// iterating over each element of the 2 - D array
for(int i = 0; i < row; i++)
{
for(int j = 0; j < col; j++)
{
// assigning values
arr[i][j] = val;
// incrementing val by 1
val = val + 1;
}
}
System.out.println("Elements of the 2-dimensinal array are:");
// Displaying values contained in each element of the 2 - D array
for(int i = 0; i < row; i++)
{
for(int j = 0; j < col; j++)
{
System.out.print(arr[i][j] + " ");
}
System.out.println();
}
}
}
Output:
Elements of the 2-dimensional array are: 9 10 11 12 13 14
Explanation:
The statement
int arr[][];
is declaring a 2-dimensional array, using arr as the reference variable. Notice, we have used a pair of two square brackets ([][]). The general syntax for the declaration of a 2-dimensional array in Java is
dataType referenceVar[][];
OR
dataType [][]referenceVar;
OR
dataType[][] referenceVar;
OR
dataType []referenceVar[];
The statement
arr = new int[2][3];
allocates the memory for the 2 rows and 3 columns and assigns its reference to the variable arr. Thus, there are 3 * 2 = 6 elements in the 2-dimensional array. Each element has the value 0. We override the value of each element using the following nested for-loop.
for(int i = 0; i < row; i++)
{
for(int j = 0; j < col; j++)
{
arr[i][j] = val;
val = val + 1;
}
}
In the end, we are displaying the elements of the array.
Like a 2-dimensional array, we can also 3-dimensional array. To create 3-dimensional array, 3 pairs of square brackets ([][][]) are used, for 4-dimensional array 4 pairs of square brackets ([][][][]) are used and so on.
Creating Jagged Array
The 2-dimensional array created above has an equal number of elements in each row. In the above example, we have created two rows. Each row has 3 elements. When the number of elements in the rows varies, a jagged array is created. In other words, an array of arrays that has different column numbers is known as a jagged array. Consider the following program.
FileName: JaggedArrayCreation.java
public class JaggedArrayCreation
{
public static void main(String args[])
{
int arr[][]; // 2 - D array declaration
// Creating 2 - D array by allocating memory for 3 rows
arr = new int[3][];
// allocating memory for different rows
arr[0] = new int[3]; // first row contains 3 elements
arr[1] = new int[2]; // second row contains 2 elements
arr[2] = new int[4]; // third row contains 4 elements
// calculating number of rows of the 2 - D array
int row = arr.length;
// for assigning values to the elements of the array
int val = 9;
// iterating over each elements of the jagged array
for(int i = 0; i < row; i++)
{
// calculating size of each row
int size = arr[i].length;
for(int j = 0; j < size; j++)
{
// assigning values
arr[i][j] = val;
// incrementing val by 1
val = val + 1;
}
}
System.out.println("Elements of the jagged array are:");
// Displaying values contained in each element of the jagged array
for(int i = 0; i < row; i++)
{
// calculating size of each row
int size = arr[i].length;
for(int j = 0; j < size; j++)
{
// displaying elements of each row
System.out.print(arr[i][j] + " ");
}
System.out.println();
}
}
}
Output:
Elements of the jagged array are: 9 10 11 12 13 14 15 16 17
Explanation: In the code, nested for-loop is used for assigning values to the elements of the jagged array. As every row contains the different number of elements in a jagged array, we have to find the size of each row of the jagged array. The statement
int size = arr[i].length;
does the same thing. Then, we are iterating over every element of the row to either update its value or to display it on the console.
Anonymous Array
Arrays in the above examples are those arrays that have references. However, we can also create an array that has no reference, i.e., an anonymous array. The following program shows how to create an anonymous array.
FileName: AnonymousArray.java
public class AnonymousArray
{
// Method for printing an array elements
public static void printArray(int arr[])
{
// calculating size of the anonymous array
int size = arr.length;
System.out.println("Elements of the anonymous array are: " );
// displaying elements of the anonymous array
for(int i = 0; i < size; i++)
{
System.out.print(arr[i] + " ");
}
}
// main method
public static void main(String argvs[])
{
// calling the method printArray
// passing an anonymous array in its argument
printArray(new int[]{134, 67, 73, 58, 80, 88});
}
}
Output:
Elements of the anonymous array are: 134 67 73 58 80 88
Explanation: In the main method, we are creating an anonymous integer array and passing it as an argument of the static method printArray(). The parameter int arr[] is holding the reference of the anonymous array. This shows that arrays are passed as a reference in a method in Java. With the help of reference, we are printing the elements of the anonymous array.
Printing the Class Name of an Array
In the introductory part of the topic, we have already discussed that Java arrays are the objects of the dynamically generated class. Let’s see how we can print the class name of a Java array.
FileName: ClassName.java
public class ClassName
{
public static void main(String argvs[])
{
// declaring and allocating memory for the array
int arr[] = new int[3];
// initializing array
arr[0] = 4; arr[1] = 5; arr[2] = 6;
// calling the method getClass()
Class c = arr.getClass();
// getting the class name
String name = c.getName();
// displaying the name of the class
System.out.print("The class name is: " + name);
}
}
Output:
The class name is: [I
Explanation: We have invoked the method getClass() on the array arr. This method renders the Class type objects. The class type object represents the run time class/ dynamically generated class. The syntax of the method getClass() is
public final Class getClass()
Thus, c stores the reference of the Class type objects. On c the getName() method is called to get the class name. In the end we are printing the class name on the console.