1. What is an Array?

An array is a linear data structure that stores a fixed-size sequence of elements of the same type in contiguous memory locations.

In simple terms:

An array is like a row of boxes, where each box holds a value of the same type.

In Java, all elements in an array must be of the same data type.

Example:

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

Here:

int → type of data stored
numbers → array name
{10, 20, 30, 40} → elements stored in the array

2. Types of Arrays in Java

(a) One-Dimensional Array

A simple list of elements.

int[] marks = {85, 90, 78, 92};

(b) Two-Dimensional Array (Matrix)

An array of arrays — like a table with rows and columns.

int[][] matrix = {
    {1, 2, 3},
    {4, 5, 6}
};

Used in:

Graph representation
Image processing
Mathematical matrices

3. Creating Arrays in Java

Method 1: Declaration + Initialization together

int[] arr = {5, 10, 15, 20};

Method 2: Using new keyword (size fixed)

int[] arr = new int[5]; // Creates array of size 5

Default values:

int → 0
double → 0.0
boolean → false
String → null

Example:

int[] arr = new int[3];
System.out.println(arr[0]); // Output: 0

4. Array Indexing

Java arrays are 0-indexed, meaning:

Index	0	1	2	3
Value	10	20	30	40

So:

arr[0] = 10;  // First element
arr[3] = 40;  // Fourth element

If we try to access outside range:

arr[5]; // Throws ArrayIndexOutOfBoundsException

5. Traversal of an Array

Using for loop

for(int i = 0; i < arr.length; i++) {
    System.out.println(arr[i]);
}

Using enhanced for loop (for-each)

for(int num : arr) {
    System.out.println(num);
}

Time Complexity:

Traversal = O(n) (you visit each element once)

6. Insertion in an Array

Since arrays are fixed in size, insertion is tricky.

Example: Insert 25 at index 2

Original:

[10, 20, 30, 40, _]

After shifting:

[10, 20, 25, 30, 40]

Code:

int[] arr = new int[5];
arr[0] = 10;
arr[1] = 20;
arr[2] = 30;
arr[3] = 40;

int index = 2;
int value = 25;

// Shift elements to the right
for(int i = arr.length - 1; i > index; i--) {
    arr[i] = arr[i - 1];
}

arr[index] = value;

Time Complexity:

Worst case insertion = O(n) (shifting elements)

7. Deletion in an Array

Example: Delete element at index 1

Before:

[10, 20, 30, 40]

After shifting left:

[10, 30, 40, _]

Code:

int index = 1;

// Shift elements left
for(int i = index; i < arr.length - 1; i++) {
    arr[i] = arr[i + 1];
}

Time Complexity:

Worst case deletion = O(n)

8. Visualizing Array Access

O(1) — Direct Access

Why is array access O(1)?

Because Java can compute the memory location directly:

address = base_address + (index * size_of_element)

So accessing arr[5] takes the same time as arr[0].

9. Advantages of Arrays

✔ Fast access using index → O(1)

✔ Easy to implement

✔ Memory efficient (contiguous storage)

✔ Good for fixed-size data

10. Limitations of Arrays

❌ Fixed size — cannot grow dynamically

❌ Insertion/deletion is expensive → O(n)

❌ Wastes memory if size is too large

❌ Cannot store different data types together

11. Next in the Series

Next, we move to: Stack in Java

We’ll cover:

Stack as an ADT
Push and Pop
Implementation using Array
Real application: Postfix evaluation