Java Arrays

Last Updated : 17 Oct 2026

Java arrays are objects that store multiple elements of the same data type in a single, contiguous memory block. In this chapter, we will learn about Java arrays, their types, features, and how to use them in programs.

What is an Array?

An array is a collection of elements of the same type stored in a single, contiguous block of memory. Arrays allow us to group similar data together and access them using an index.

Array in Java

In Java, an array is an object that stores elements of a similar data type in contiguous memory locations. It is a data structure used to store a fixed number of elements.

Arrays in Java are index-based, meaning the first element is at index 0, the second at index 1, and so on.

In Java, an array is considered an object of a dynamically created class. All arrays in Java:

Implement the Serializable and Cloneable interfaces
Derive from the Object class

Arrays can store primitive values or objects, and Java supports both single-dimensional and multi-dimensional arrays.

Java also supports anonymous arrays, which are not available in C/C++. This feature allows us to create and pass arrays without explicitly declaring a variable.

Advantages

Code Optimization: It makes the code optimized, and we can retrieve or sort the data efficiently.
Random access: We can get any data located at an index position.

Disadvantages

Size Limit: Arrays have a fixed size and do not grow dynamically at runtime.

Types of Arrays in Java

There are two types of arrays.

Single-Dimensional Array
Multi-dimensional Array

Single-Dimensional Array in Java

A single-dimensional array in Java is a linear collection of elements of the same data type. It is declared and instantiated using the following syntax:

dataType[] arr; (or)  
dataType []arr; (or)  
dataType arr[];  

Instantiation of an Array

Example: Java Array

Let's see the simple example of Java array, where we have declared, instantiate, initialize and traverse an array.

Java

public class Main {    
 public static void main(String args[]) {    
    //declaration and instantiation of an array  
    int a[]=new int[5];  
    a[0]=10;//initialization    
    a[1]=20;    
    a[2]=70;    
    a[3]=40;    
    a[4]=50;    
    //traversing array    
    for(int i=0;i<a.length;i++) {//length is the property of array    
        System.out.println(a[i]);    
    }  
 }  
}  

Compile and Run

Output:

Declaration, Instantiation and Initialisation Array

In Java, we can declare, instantiate, and initialize an array in a single line, as follows:

Java

//Java Program to illustrate the use of declaration, instantiation     
//and initialization of Java array in a single line    
public class Main {    
 public static void main(String args[]) {    
    //declaration, instantiation and initialization of an array  
    int a[] = {33, 3, 4, 5};  
    //traversing array    
    for(int i=0; i<a.length ;i++)//length is the property of array    
        System.out.println(a[i]);    
 }  
}    

Compile and Run

Output:

Multidimensional Array (Two-Dimensional Array)

A multidimensional array (two-dimensional array) in Java is an array of arrays, where each element of the main array is itself an array. It is used to store data in a table-like structure with rows and columns.

Syntax: Declaring a Two-Dimensional Array

Syntax: Instantiation of a Two-Dimensional Array

or we can combine declaration and instantiation statements as follows:

Example: Two-Dimensional Array

Let's see a simple example of a two-dimensional array in Java, where we declare, instantiate, initialize, and traverse the array:

Java

public class Main {
    public static void main(String[] args) {
        // Declare and instantiate a 2D array
        int[][] numbers = new int[2][3];

        // Initialize the array
        numbers[0][0] = 10;
        numbers[0][1] = 20;
        numbers[0][2] = 30;
        numbers[1][0] = 40;
        numbers[1][1] = 50;
        numbers[1][2] = 60;

        // Traverse and print the array
        for (int i = 0; i < numbers.length; i++) {
            for (int j = 0; j < numbers[i].length; j++) {
                System.out.print(numbers[i][j] + " ");
            }
            System.out.println();
        }
    }
}

Compile and Run

Output:

10 20 30  
40 50 60

Accessing Array Elements Using For Each Loop

We can access the array elements using for-each loop. The Java for-each loop accesses the array elements one by one. It holds an array element in a variable, then executes the body of the loop.

Syntax:

for(data_type variable:array){  
//body of the loop  
}  

Let's see the example of printing the elements of the Java array using the for-each loop.

Example

//Java Program to print the array elements using for-each loop  
public class Main{  
 public static void main(String args[]){  
    //declaration and initialization of an array
    int arr[]={33,3,4,5};  
    //traversal of an array using for-each loop  
    for(int i:arr)  
        System.out.println(i);  
 }
}  

Compile and Run

Output:

Passing Array to a Method

We can pass the Java array to the method so that we can reuse the same logic on any array. When we pass an array to a method in Java, we are essentially passing a reference to the array. It means that the method will have access to the same array data as the calling code, and any modifications made to the array within the method will affect the original array.

Example: Finding Minimum Element

//Java Program to demonstrate the way of passing an array to method.  
public class Main{  
//creating a method which receives an array as a parameter  
    static void min(int arr[]){  
        int min=arr[0];  
        for(int i=1;i<arr.length;i++)  
            if(min>arr[i])  
                min=arr[i];  
  
        System.out.println(min);  
    }  
  
 public static void main(String args[]){  
    int a[]={33,3,4,5};//declaring and initializing an array  
    min(a);//passing array to method  
 }
}  

Compile and Run

Output:

Explanation

In the above code, the min() method takes an integer array arr[] as a parameter and finds the minimum element in the array using a simple iterative loop. In the main() method, an integer arrays a is declared and initialized with values {33, 3, 4, 5}, and then the min() method is called with this array as an argument. The min() method iterates through the array to find the minimum element and prints it to the console.

Anonymous Array

Java's anonymous arrays eliminate the requirement for separate declarations of array variables by enabling developers to build and initialize arrays directly within method calls or other expressions. When working with temporary arrays that are just needed for a single job and do not need a persistent reference within the program, this is quite helpful.

Java supports the feature of an anonymous array, so we do not need to declare the array while passing an array to the method.

Example

//Java Program to demonstrate the way of passing an anonymous array to method  
public class Main{  
    //creating a method which receives an array as a parameter  
    static void printArray(int arr[]){  
        for(int i=0;i<arr.length;i++)  
            System.out.println(arr[i]);  
    }  
 public static void main(String args[]){  
    printArray(new int[]{10,22,44,66});//passing anonymous array to method  
 }
}  

Compile and Run

Output:

Explanation

In this example, the printArray() method takes an integer array as a parameter and prints each element of the array. In the main() method, an anonymous array {10, 20, 30} is directly passed as an argument to the printArray() method. The concise syntax demonstrates the usage of anonymous arrays.

Returning Array from the Method

In Java, methods are not limited to returning simple data types or objects; they can also return arrays. This feature allows for more flexibility in method design and enables developers to encapsulate complex logic for generating arrays within methods.

Example

//Java Program to return an array from the method  
public class Main{  
    //creating method which returns an array  
    static int[] get(){  
        return new int[]{10,30,50,90,60};  
    }  
 public static void main(String args[]){  
    //calling method which returns an array  
    int arr[]=get();  
    //printing the values of an array  
    for(int i=0;i<arr.length;i++)  
        System.out.println(arr[i]);  
 }
}

Compile and Run

Output:

Explanation

The example demonstrates how to return an array from a method and subsequently use the returned array in the calling code. By encapsulating array creation and initialization logic within the get() method, the code becomes more modular and reusable.

ArrayIndexOutOfBoundsException

In Java, the ArrayIndexOutOfBoundsException is a runtime exception thrown by the Java Virtual Machine (JVM) when attempting to access an invalid index of an array. The exception occurs if the index is negative, equal to the size of the array, or greater than the size of the array while traversing the array.

Example

//Java Program to demonstrate the case of 
//ArrayIndexOutOfBoundsException in a Java Array.
public class TestArrayException{
public static void main(String args[]){
int arr[]={50,60,70,80};
for(int i=0;i<=arr.length;i++){
System.out.println(arr[i]);
}
}}

Compile and Run

Output:

50
60
70
80
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 4 out of bounds for length 4
	at Main.main(Main.java:7)

Jagged Arrays

In Java, a jagged array is an array of arrays where each row of the array can have a different number of columns. This contrasts with a regular two-dimensional array, where each row has the same number of columns.

Declaring and Initializing a Jagged Array

To declare a jagged array in Java, you first declare the array of arrays, and then you initialize each row separately with its own array of columns.

int arr[][] = new int[3][];  
arr[0] = new int[3];  
arr[1] = new int[4];  
arr[2] = new int[2];

Example

//Java Program to illustrate the jagged array  
public class Main{  
    public static void main(String[] args){  
        //declaring a 2D array with odd columns  
        int arr[][] = new int[3][];  
        arr[0] = new int[3];  
        arr[1] = new int[4];  
        arr[2] = new int[2];  
        //initializing a jagged array  
        int count = 0;  
        for (int i=0; i<arr.length; i++)  
            for(int j=0; j<arr[i].length; j++)  
                arr[i][j] = count++;  
   
        //printing the data of a jagged array   
        for (int i=0; i<arr.length; i++){  
            for (int j=0; j<arr[i].length; j++){  
                System.out.print(arr[i][j]+" ");  
            }  
            System.out.println();//new line  
        }  
    }  
}  

Compile and Run

Output:

0 1 2 
3 4 5 6 
7 8

Explanation

The program demonstrates the concept of a jagged array, where an array of arrays is created, with each inner array having a different number of columns. Initially, a 2D array named arr is declared with 3 rows, but with each row having a different number of columns: the first row has 3 columns, the second row has 4 columns, and the third row has 2 columns. The program then initializes the jagged array by filling it with sequential values starting from 0. Finally, it iterates through the array and prints out each element, row by row, separated by a space, with a newline character indicating the end of each row.

Arrays as Objects

In Java, an array is an object. However, arrays have a special feature in Java where the JVM generates a proxy class for each array object. This proxy class represents the runtime type of the array. To obtain the class name of a Java array, you can use the getClass().getName() method, which is available on all Java objects. This method returns a String representing the fully qualified name of the class of the object, including any package information.

Example

The following example shows how to get the runtime class name of an array in Java using the getClass().getName() method.

Java

//Java Program to get the class name of array in Java  
public class Main{  
 public static void main(String args[]){  
    //declaration and initialization of array  
    int arr[]={4,4,5};  
    //getting the class name of Java array  
    Class c=arr.getClass();  
    String name=c.getName();  
    //printing the class name of Java array   
    System.out.println(name);  
 }
}  

Compile and Run

Output:

[I

Explanation

The Java program demonstrates how to retrieve the class name of an array in Java using the getClass().getName() method. It initializes an array arr[] with integer values, obtains the runtime class of the array using getClass(), and retrieves the class name using getName(). The obtained class name, typically represented by a single character followed by square brackets, reflects the dimensionality and type of elements in the array.

Copying Arrays

Copying an array in Java can be achieved by using the System.arraycopy() method. It allows us to copy elements from a source array to a destination array with a specified starting position and length.

Syntax:

public static void arraycopy(
Object src, int srcPos,Object dest, int destPos, int length
)

Here, src is the source array, srcPos is the starting position in the source array, dest is the destination array, destPos is the starting position in the destination array, and length is the number of elements to be copied.

Example

The following example demonstrates how to copy elements from one array to another in Java using the System.arraycopy() method.

Java

//Java Program to copy a source array into a destination array in Java  
public class Main {  
    public static void main(String[] args) {  
        //declaring a source array  
        char[] copyFrom = { 'd', 'e', 'c', 'a', 'f', 'f', 'e',  
                'i', 'n', 'a', 't', 'e', 'd' };  
        //declaring a destination array  
        char[] copyTo = new char[7];  
        //copying array using System.arraycopy() method  
        System.arraycopy(copyFrom, 2, copyTo, 0, 7);  
        //printing the destination array  
        System.out.println(String.valueOf(copyTo));  
    }  
}  

Compile and Run

Output:

caffein

Explanation

The Java program initializes two-character arrays, copyFrom and copyTo, with predefined values. It then utilizes the System.arraycopy() method to copy a portion of the copyFrom array into the copyTo array, starting from index 2 and copying 7 elements. Finally, it prints the contents of the copyTo array, resulting in the output "caffein".

Cloning an Array

In Java, arrays implement the Cloneable interface, allowing us to create clones of arrays. If we create a clone of a single-dimensional array, it creates a deep copy of the Java array. It means it will copy the actual value. But, if we make a clone of a multi-dimensional array, it creates a shallow copy of the array, which means it copies the references.

This distinction is important because modifying elements in a shallow copied multidimensional array will affect both the original and cloned arrays, while in a deep copied single-dimensional array, modifications will not impact the original.

Example

The following example demonstrates the closing of an array in Java:

Java

class Main {    
    public static void main(String args[]) {    
        int arr[] = {33, 3, 4, 5};    
        System.out.println("Printing original array:");    
        for (int i : arr) {    
            System.out.println(i);    
        }
        System.out.println("Printing clone of the array:");    
        int carr[] = arr.clone();    
        for (int i : carr) {    
            System.out.println(i);    
        }
        System.out.println("Are both equal?");    
        System.out.println(arr == carr);    
    }  
}

Compile and Run

Output:

Printing original array:
33
3
4
5
Printing clone of the array:
33
3
4
5
Are both equal?
False

Explanation

An integer array called arr[] is initialized with the numbers {33, 3, 4, 5} in this Java programme, and its elements are printed. Then, it uses the clone() method to duplicate arr, assigns the result to carr, and prints the items of the duplicated array. The last line of the programme compares arr and carr using the == operator; the result evaluates to false, meaning that arr and carr are distinct array objects. The elements in both arrays, though, are the same.

Addition Two Multidimensional Arrays (Two Matrices)

A fundamental operation in linear algebra and computer science, matrix addition is frequently utilised in a variety of applications, including scientific computing, computer graphics, and image processing. To create a new matrix with the same dimensions as the original, matching elements from each matrix must be added when adding two matrices in Java. This Java program shows how to add matrices effectively by using stacked loops to do a basic example of the process.

Example

This Java program shows how to add matrices effectively by using stacked loops to do a basic example of the process.

Java

public class Main {  
    public static void main(String args[]) {  
        // creating two matrices  
        int a[][] = {{1, 3, 4}, {3, 4, 5}};  
        int b[][] = {{1, 3, 4}, {3, 4, 5}};  
        // creating another matrix to store the sum of two matrices  
        int c[][] = new int[2][3];  
        // adding and printing addition of 2 matrices  
        for (int i = 0; i < 2; i++) {  
            for (int j = 0; j < 3; j++) {  
                c[i][j] = a[i][j] + b[i][j];  
                System.out.print(c[i][j] + " ");  
            }  
            System.out.println(); // new line  
        }  
    }  
}

Compile and Run

Output:

2 6 8
6 8 10

Explanation

This Java program demonstrates matrix addition by adding two predefined matrices, a and b, element-wise and storing the result in matrix c. The matrices a and b are initialized with values, and matrix c is created to store the sum. It iterates through each element of the matrices using nested loops, adding corresponding elements from a and b and storing the result in the corresponding position in c. Finally, it prints the resulting matrix c. The output displays the element-wise addition of the two matrices, with each element in the resulting matrix c being the sum of the corresponding elements in a and b.

Multiplication Two Multidimensional Arrays (Two Matrices)

Matrix multiplication is a crucial operation in mathematics and computer science, often utilized in various applications such as graphics rendering, optimization algorithms, and scientific computing. In Java, multiplying two matrices involves a systematic process where each element in the resulting matrix is computed by taking the dot product of a row from the first matrix and a column from the second matrix.

Example

The following example demonstrates multiplication of two matrices of 3 rows and 3 columns.

Java

public class Main {  
    public static void main(String args[]) {  
        // creating two matrices    
        int a[][] = {{1, 1, 1}, {2, 2, 2}, {3, 3, 3}};    
        int b[][] = {{1, 1, 1}, {2, 2, 2}, {3, 3, 3}};    
        // creating another matrix to store the multiplication of two matrices    
        int c[][] = new int[3][3];  // 3 rows and 3 columns  
        // multiplying and printing multiplication of 2 matrices    
        for (int i = 0; i < 3; i++) {    
            for (int j = 0; j < 3; j++) {    
                c[i][j] = 0;      
                for (int k = 0; k < 3; k++) {      
                    c[i][j] += a[i][k] * b[k][j];      
                } // end of k loop  
                System.out.print(c[i][j] + " ");  // printing matrix element  
            } // end of j loop  
            System.out.println(); // new line    
        }    
    }  
}

Compile and Run

Output:

6 6 6 
12 12 12 
18 18 18

Explanation

This Java program computes the multiplication of two 3x3 matrices, 'a' and 'b', storing the result in matrix 'c'. It initializes matrices 'a' and 'b' with predefined values and creates matrix 'c' to store the result. Using nested loops, it iterates through each element of the resulting matrix 'c', calculating the dot product of corresponding row and column elements from matrices 'a' and 'b'. The computed result for each element is accumulated in the corresponding position of 'c'.

Features of Arrays in Java

Fixed Size: During runtime, an array's size cannot be altered once it has been constructed. An array cannot be declared unless the necessary size is known.

Arrays are less adaptable for storing dynamic data because of this restriction.

Example:

int[] numbers = new int[5]; // Can store only 5 integers
numbers[0] = 10;
numbers[5] = 50; // Error: ArrayIndexOutOfBoundsException

Efficient Access (Fast Lookups)

Using an element's index to access it takes constant time O(1). When it comes to changing or retrieving values at known locations, arrays are therefore quite effective.

Example:

Stored in Contiguous Memory: The individual elements of an array are arranged side by side in memory since arrays in Java are kept in contiguous memory areas.

Since CPU caching is optimized, this results in speedier access, particularly when utilized in loops.

Default Values: Every element in an array is automatically initialized with a default value determined by the data type when it is created:

int, float, long → 0
boolean → false
char → '\u0000' (null character)
Object types → null

Example:

boolean[] flags = new boolean[3]; 
System.out.println(flags[0]); // false

Cloneable and Serializable

Cloneable: We can create a shallow copy using clone() method.

Serializable: Arrays can be saved and transmitted across networks if needed.

Example:

int[] original = {1, 2, 3};
int[] copy = original.clone();
System.out.println(original == copy); // false (different references)

Arrays Programs

The following are the important arrays programs in Java:

Next TopicMulti-Dimensional Arrays in Java

← prev next →

We deliver comprehensive tutorials, interview question-answers, MCQs, study materials on leading programming languages and web technologies like Data Science, MEAN/MERN full stack development, Python, Java, C++, C, HTML, React, Angular, PHP and much more to support your learning and career growth.

Contact info

G-13, 2nd Floor, Sec-3, Noida, UP, 201301, India

hr@tpointtech.com

+91-9599086977

Interview Questions

Python Java Data Structure C++ C HTML JavaScript jQuery SQL Power BI

Online Compilers

C Compiler R Compiler C++ Compiler PHP Compiler Java Compiler HTML Editor Swift Compiler Python Compiler JavaScript Editor TypeScript Editor

Latest Post | Tutorials List | Privacy Policy | About Us | Contact Us

Java Tutorial

Control Statements

Java Object Class

Java Inheritance

Java Polymorphism

Java Abstraction

Java Encapsulation

Java Array

Java OOPs Misc

Java String

Java Regex

Exception Handling

Java Inner Class

Java Multithreading

Java Synchronization

Java I/O

File Handling in Java

Java Serialization

Java Networking

Java Reflection

Java Collections

Java 5 Features

Java 8 Features

Java JDBC

RMI

Internationalization

Advanced Java Tutorial

Java Projects

Java Arrays

What is an Array?

Array in Java

Advantages

Disadvantages

Types of Arrays in Java

Single-Dimensional Array in Java

Multidimensional Array (Two-Dimensional Array)

Syntax: Declaring a Two-Dimensional Array

Syntax: Instantiation of a Two-Dimensional Array

Example: Two-Dimensional Array

Accessing Array Elements Using For Each Loop

Syntax:

Example

Passing Array to a Method

Example: Finding Minimum Element

Anonymous Array

Example

Returning Array from the Method

Example

ArrayIndexOutOfBoundsException

Example

Jagged Arrays

Declaring and Initializing a Jagged Array

Example

Arrays as Objects

Example

Java

Copying Arrays

Syntax:

Example

Java

Cloning an Array

Example

Java

Addition Two Multidimensional Arrays (Two Matrices)

Example

Java

Multiplication Two Multidimensional Arrays (Two Matrices)

Example

Java

Features of Arrays in Java

Example:

Efficient Access (Fast Lookups)

Cloneable and Serializable

Arrays Programs

Related Posts

Subscribe to Tpoint Tech

Contact info

Follow us

Top Tutorials

Interview Questions