Applications of Array in Java

In Object-Oriented Programming, Array is a data structure that stores homogenous data in a linear way. The size of the array is fixed, i.e., once declared, the size of the array cannot be modified.

In other words, array stores data of the same type (int, float, string, Boolean, etc.) in a contiguous memory location.

For example, we need to store roll numbers of 100 students; we have to declare 100 different variables as roll1, roll2,…, roll100 that is difficult and lengthy process. Using array, we can easily store 100 students's roll numbers even in a single variable, as follows.

Applications of Array in Java

Arrays can be used to implement stack and queue data structures. Both stack and queue are essential data structures used in various Java applications. Unlike LinkedLists, arrays are easier to implement the stack and queue data structure.
Arrays are good to implement Vectors and Lists.
CPU scheduling algorithm can be implemented using an array. Arrays play an important role in maintaining the efficiency of the operating system. In CPU scheduling, we need to maintain a list of all the processes that need to be scheduled; arrays can be a useful data structure to store this list of processes.
As compared to pointers, arrays can be a better approach to implement Tree data structure. And the tree data structure itself can be used to implement various other data structures.
The Heap, Map and Set use the binary search tree and the balanced binary tree. These trees can also be implemented using arrays.
Various mathematical problems like matrices can be easily and efficiently solved with the help of an array data structure.
Arrays can also be used to implement lookup The lookup table is itself an array that stores pre-fetched or pre-calculated values that save the computation time or fetching time required to compute the pre-fetched data and stored in the lookup table.
The large data is managed by an array using a single variable name. It can maintain multiple variable names with a single name. Thus avoiding the confusion of using multiple variables.
Matrix operations can be implemented using arrays. There are many databases (small and large) consisting of one-dimensional and multi-dimensional arrays.
The large arrays can also be used to emulate in-program dynamic memory allocation, mostly the memory pool allocation. Previously, this has been the only way to allocate dynamic memory.
We can use arrays to determine the partial or complete flow in the code. It can be termed as an alternative to multiple IF statements. In this context they are called control tables and are used in conjunction with an interpreter. The flow of control in this interpreter is managed according to the array values.
Arrays can be used in speech processing, where every speech signal is an array.
The two-dimensional array (2D array) also called a matrix is used in image processing.

Let's consider following examples to understand some of the applications of array in Java.

Example 1: Matrix Multiplication

MatrixMultiplication.java

import java.util.*;

public class MatrixMultiplication {  

public static void display(int mat[][], int rSize, int cSize){
	for(int i = 0; i < rSize; i++){
		for(int j = 0; j < cSize; j++){
			System.out.print(mat[i][j] + " "); 
		}
		System.out.println();
	}
}

public static void matrixMultiply(int r1, int c1, int mat1[][], 
								  int r2, int c2, int mat2[][]){
	int i, j, k;

	// printing the first and second matrix
	System.out.println("Matrix 1:");
	display(mat1, r1, c1);
	System.out.println("Matrix 2:");
	display(mat2, r2, c2);


	// to check if matrix multiplication is possible
	if (r2 != c1) {
		System.out.println("Cannot multiply matrices! RowSize of matrix 2 must be equal to ColumnSize of matrix 1");
		return;
	}

	// declaring matrix to store the product
	int res_mat[][] = new int[r1][c2];

	// multiplying two matrices
	 for (i = 0; i < r1; i++) {
            for (j = 0; j < c2; j++) {
                for (k = 0; k < r2; k++)
                    res_mat[i][j] += mat1[i][k] * mat2[k][j];
            }
        }

     // printing the result
        System.out.println("Product of matrices is:");
        display(res_mat, r1, c2);

}

public static void main (String args[]){

// Declaring the size of array
int row1 = 4, col1 = 3, row2 = 3, col2 = 4;

//creating two matrices  
int arr1[][] = {{2, 4, 1},
				{4, 3, 7}, 
				{7, 2, 1}, 
				{5, 2, 1}};

int arr2[][] = {{3, 5, 7, 9},
				{4, 1, 8, 2}, 
				{1, 3, 2, 7}};
			
//calling the function
matrixMultiply(row1, col1, arr1, row2, col2, arr2);
}
}

Output:

Example 2: Stack operations using array

StackOperations.java

import java.util.Scanner;  
public class StackOperations {  
public static void main(String[] args) {  
    int ch=0;  
    Scanner sc = new Scanner(System.in);  
    Stack s = new Stack();  
    System.out.println("Stack operations using array:\n");  
    
    while(ch != 4)  
    {  
        System.out.println("\nSelect an option:");  
        System.out.println("\n1.Push\n2.Pop\n3.Show\n4.Exit");  
        System.out.println("\n Enter your choice \n");        
        ch = sc.nextInt();  
        switch(ch)  
        {  
            case 1:  
            {   
                System.out.println("Enter a value to add:");  
                int val = sc.nextInt(); 
                s.push(val);  
                break;  
            }  
            case 2:  
            {  
                s.pop();  
                break;  
            }  
            case 3:  
            {  
                s.display();  
                break;  
            }  
            case 4:   
            {  
                System.out.println("Exiting!");  
                System.exit(0);  
                break;   
            }  
            default:  
            {  
                System.out.println("Please enter valid choice!");  
            }   
        };  
    }  
}  
}  

class Stack {  

    int top;   
    int maxSize = 10;  
    int[] arr = new int[maxSize];  
      
      
    // method to check whether stack is empty
    boolean isEmpty(){  
        return (top < 0);  
    } 

    // constructor to initialize the top 
    Stack(){  
        top = -1;  
    }

    // method to add element in stack
    boolean push (int val){  
        if(top == maxSize-1)  
        {  
            System.out.println("Overflow !!");  
            return false;  
        }  
        else   
        {  
            top++;  
            arr[top]=val;  
            System.out.println("Item pushed");  
            return true;  
        }  
    }  

    // method to remove element from stack
    boolean pop (){  
        if (top == -1)  
        {  
            System.out.println("Underflow !!");  
            return false;  
        }  
        else   
        {  
            top --;   
            System.out.println("Item popped");  
            return true;  
        }  
    }  

    // method to display stack elements
    void display (){  
        System.out.println("Printing stack elements:");  
        for(int i = top; i>=0;i--)  
        {  
            System.out.println(arr[i]);  
        }  
    }  
}

Output 1:

Output 2:

Example 3: Lookup tables using array

LookupTableUsingArray.java

public class LookupTableUsingArray{
	
	public static void main(String args[]) {
		
		// defining the lookup table using array
		int[] lookupTable = new int[5];

		// calculating and storing the square of elements 
		// directly into the lookup table
		for(int i = 0; i < 5; i++){

			lookupTable[i] = (i+1)*(i+1);
		}


		// displaying the sqaure values
		for(int j = 0; j < 5; j++){
			System.out.println("Square of element " +(j+1)+" is " + lookupTable[j]);
		}

	}

}

Output: