Arrays in Java are used to store multiple values of the same data type in a single variable. Instead of creating many separate variables, arrays help organize related data efficiently.
For example, if you want to store marks of several students, using arrays is easier than creating individual variables.
int marks[] = {85, 90, 78, 88, 95};
Arrays are widely used in searching, sorting, data storage, and many programming applications.
 

Table of Contents

---

What is an Array in Java?

An array is a collection of elements of the same data type stored under a single variable name. Each element is accessed using an index value, and indexing starts from 0.
Example:

String fruits[] = {"Apple", "Mango", "Orange"};

Index positions:

Apple   → 0
Mango   → 1
Orange  → 2

Why Arrays Are Used?

1. Store Multiple Values Together: Arrays allow storing many values inside one variable instead of creating separate variables.
2. Reduce Code Repetition: Using arrays decreases the number of variables and makes programs shorter.
3. Organize Data Efficiently: Related data remains grouped together for better management.
4. Improve Readability: Programs become easier to understand when similar values are stored in arrays.
5. Support Large Data Handling: Arrays help manage large amounts of data more effectively.

Features of Arrays

1. Fixed Size Structure: The size of an array is decided at the time of creation and cannot be changed later.
2. Same Data Type Elements: All values stored inside an array must belong to the same data type.
3. Index-Based Access: Elements are accessed using index numbers starting from zero.
4. Ordered Data Storage: Elements remain stored in the order in which they are inserted.
5. Fast Element Access: Arrays provide quick access to values using indexes.

Syntax of Arrays

Declaration:

dataType arrayName[];
or
dataType[] arrayName;

Creation:

arrayName = new dataType[size];

Initialization:

int numbers[] = {10, 20, 30, 40};

Memory Representation of Arrays

Arrays in Java store elements in sequential index positions. Each element occupies a specific location and can be accessed using its index value. The array variable stores a reference to the memory location where array elements are stored.
When an array is created, memory is allocated for all elements together, and indexes start from 0.
Example:

int numbers[] = {10, 20, 30, 40, 50};

Memory representation:

Index:     0      1      2      3      4
          -----------------------------------
Values:   10     20     30     40     50
          -----------------------------------

Here:

• numbers[0] stores 10
• numbers[1] stores 20
• numbers[2] stores 30
• numbers[3] stores 40
• numbers[4] stores 50

The array variable points to the starting location of the array, and elements are accessed using their index positions.

Accessing Array Elements

Below is the Java program to demonstrate accessing array elements:

// Java program to demonstrate accessing
// array elements
public class ArrayIntroduction 
{
    public static void main(String[] args) 
    {
        int marks[] = new int[5];
        marks[0] = 80;
        marks[1] = 85;
        marks[2] = 90;
        marks[3] = 95;
        marks[4] = 100;

        System.out.println("Student Marks:");

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

Output:

Student Marks:
80
85
90
95
100

Advantages of Arrays

1. Easy Data Storage: Arrays allow storing multiple related values using one variable name which simplifies coding.
2. Faster Access to Elements: Elements can be accessed quickly using index positions.
3. Better Memory Organization: Data remains stored in an organized structure inside memory.
4. Reduced Number of Variables: Arrays remove the need to create many separate variables.
5. Useful with Loops: Arrays work efficiently with loops for processing large amounts of data.

Limitations of Arrays

1. Fixed Size Limitation: Array size cannot be increased or decreased after creation.
2. Same Data Type Restriction: Arrays only store elements belonging to one data type.
3. Memory Waste Possibility: Unused positions may waste memory if array size is larger than required.
4. Difficult Insertion and Deletion: Adding or removing elements is not convenient.
5. No Built-In Dynamic Resizing: Arrays do not automatically grow like dynamic collections.

Applications of Arrays

1. Student Record Management: Arrays are used to store marks, grades, and roll numbers.
2. Searching Operations: Many searching algorithms use arrays for data processing.
3. Sorting Programs: Arrays help arrange values in ascending or descending order.
4. Matrix Calculations: Arrays are useful for handling rows and columns of data.
5. Data Storage Systems: Programs use arrays for temporary storage of values.

Conclusion

Arrays are an important part of Java programming because they help store and manage multiple values efficiently. Understanding arrays creates a strong base before learning array traversal, one-dimensional arrays, multidimensional arrays, and array programs.

Frequently Asked Questions

1. What is an array in Java?

An array stores multiple values of the same data type in one variable.

2. Does array indexing start from 1?

No, array indexing starts from 0.

3. Can array size change automatically?

No, array size remains fixed after creation.

4. Can arrays store different data types?

No, arrays store only one type of data.

5. Which keyword creates arrays in Java?

The new keyword is used for creating arrays.