Arrays in Java

Array Declaration in Java

In Java, arrays are objects that hold a fixed number of elements of a single type. Unlike arrays in C or C++, Java arrays are first-class objects with a length property and inherit from Object.

Syntax

// Declare an array variable
int[] numbers;      // Preferred style
int numbers2[];     // Also valid (C-style, not recommended)

// The declaration does NOT create the array
// numbers = null at this point

Creating Arrays

// Using new keyword - creates array with default values
int[] scores = new int[5];           // [0, 0, 0, 0, 0]
String[] names = new String[3];      // [null, null, null]
double[] prices = new double[4];     // [0.0, 0.0, 0.0, 0.0]

// Default values by type:
// int, long, short, byte → 0
// float, double → 0.0
// char → '\u0000'
// boolean → false
// Object references → null

Array Size

int[] arr = new int[10];
int length = arr.length;  // 10 (not a method call, it's a field)

// Arrays are FIXED size after creation
// You cannot add or remove elements
// To 'resize', you must create a new array

Multiple Declaration

// Declare multiple arrays
int[] a, b;  // a and b are both int arrays

// Be careful with this:
int c[], d;  // c is int array, d is just int!

Key Points

1. Array size must be non-negative
2. Array size is determined at runtime (not compile-time constant)
3. Array index starts at 0
4. Accessing invalid index throws ArrayIndexOutOfBoundsException
5. Arrays know their own length via .length field

Array Initialization Methods

Java provides multiple ways to initialize arrays with values.

Static Initialization

// Short form - compiler infers size
int[] primes = {2, 3, 5, 7, 11, 13};
String[] fruits = {"apple", "banana", "cherry"};

// Long form
int[] primes2 = new int[]{2, 3, 5, 7, 11, 13};

// Note: You cannot specify size with static initialization
// int[] arr = new int[3]{1, 2, 3};  // COMPILE ERROR!

Dynamic Initialization

// Create array and set values separately
int[] numbers = new int[5];
numbers[0] = 10;
numbers[1] = 20;
numbers[2] = 30;
numbers[3] = 40;
numbers[4] = 50;

// Or use a loop
int[] squares = new int[10];
for (int i = 0; i < squares.length; i++) {
    squares[i] = i * i;
}

Array Copy

// Method 1: System.arraycopy()
int[] src = {1, 2, 3, 4, 5};
int[] dest = new int[5];
System.arraycopy(src, 0, dest, 0, src.length);

// Method 2: Arrays.copyOf()
int[] copy = Arrays.copyOf(src, src.length);

// Method 3: clone()
int[] cloned = src.clone();

// Method 4: Manual copy
int[] manual = new int[src.length];
for (int i = 0; i < src.length; i++) {
    manual[i] = src[i];
}

Array with Variable Size

// Size determined at runtime
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();
int[] dynamicArray = new int[n];

// This is still a fixed-size array!
// Once created, cannot change size

Anonymous Arrays

// Create and pass array in one line
printArray(new int[]{1, 2, 3, 4, 5});
printArray(new String[]{"hello", "world"});

static void printArray(int[] arr) {
    for (int num : arr) {
        System.out.print(num + " ");
    }
}

Array Traversal Techniques

Traversing (iterating through) arrays is one of the most fundamental operations.

Traditional For Loop

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

// Forward traversal
for (int i = 0; i < arr.length; i++) {
    System.out.println("Element at index " + i + ": " + arr[i]);
}

// Backward traversal
for (int i = arr.length - 1; i >= 0; i--) {
    System.out.println("Element at index " + i + ": " + arr[i]);
}

Enhanced For Loop (For-Each)

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

// Enhanced for loop - simpler syntax
for (int num : arr) {
    System.out.println(num);
}

// Limitations:
// - Cannot access index
// - Cannot modify array elements
// - Cannot iterate backwards

While Loop

int[] arr = {10, 20, 30, 40, 50};
int i = 0;

while (i < arr.length) {
    System.out.println(arr[i]);
    i++;
}

Using Arrays.toString()

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

// Quick way to print entire array
System.out.println(Arrays.toString(arr));
// Output: [1, 2, 3, 4, 5]

Practical Examples

// Find maximum element
int[] arr = {5, 2, 9, 1, 7};
int max = arr[0];
for (int i = 1; i < arr.length; i++) {
    if (arr[i] > max) {
        max = arr[i];
    }
}
System.out.println("Maximum: " + max);  // 9

// Reverse array in place
int[] arr = {1, 2, 3, 4, 5};
int left = 0, right = arr.length - 1;
while (left < right) {
    int temp = arr[left];
    arr[left] = arr[right];
    arr[right] = temp;
    left++;
    right--;
}
// arr is now {5, 4, 3, 2, 1}

Time Complexity

• All traversal methods: O(n)
• No difference in performance between loop types

java.util.Arrays Utility Class

The Arrays class provides static methods to work with arrays.

Sorting

import java.util.Arrays;

int[] arr = {5, 2, 8, 1, 9};
Arrays.sort(arr);  // [1, 2, 5, 8, 9]

// Sorting with custom order
Integer[] nums = {5, 2, 8, 1, 9};
Arrays.sort(nums, Collections.reverseOrder());  // [9, 8, 5, 2, 1]

// Sorting part of array
int[] arr2 = {5, 2, 8, 1, 9, 3};
Arrays.sort(arr2, 1, 4);  // Sort index 1 to 3: [5, 1, 2, 8, 9, 3]

Searching (Binary Search)

int[] arr = {1, 2, 3, 4, 5};
int index = Arrays.binarySearch(arr, 3);  // 2 (found)
int index2 = Arrays.binarySearch(arr, 6);  // -4 (not found, insertion point)

// Must be sorted before searching!

Copying

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

// Copy with same size
int[] copy1 = Arrays.copyOf(src, src.length);  // [1, 2, 3, 4, 5]

// Copy with new size (larger or smaller)
int[] copy2 = Arrays.copyOf(src, 3);   // [1, 2, 3]
int[] copy3 = Arrays.copyOf(src, 7);   // [1, 2, 3, 4, 5, 0, 0]

// Copy range
int[] copy4 = Arrays.copyOfRange(src, 1, 4);  // [2, 3, 4]

Filling

int[] arr = new int[5];
Arrays.fill(arr, 10);  // [10, 10, 10, 10, 10]

// Fill range
int[] arr2 = new int[5];
Arrays.fill(arr2, 2, 4, 100);  // [0, 0, 100, 100, 0]

Comparison

int[] a = {1, 2, 3};
int[] b = {1, 2, 3};
int[] c = {1, 2, 4};

Arrays.equals(a, b);  // true
Arrays.equals(a, c);  // false

// For multi-dimensional arrays
int[][] x = {{1, 2}, {3, 4}};
int[][] y = {{1, 2}, {3, 4}};
Arrays.deepEquals(x, y);  // true

Converting to String

int[] arr = {1, 2, 3, 4, 5};
String str = Arrays.toString(arr);  // "[1, 2, 3, 4, 5]"

// For multi-dimensional
int[][] arr2 = {{1, 2}, {3, 4}};
String str2 = Arrays.deepToString(arr2);  // "[[1, 2], [3, 4]]"

Converting to List

// For object arrays
Integer[] nums = {1, 2, 3, 4, 5};
List<Integer> list = Arrays.asList(nums);  // Fixed-size list
List<Integer> mutableList = new ArrayList<>(Arrays.asList(nums));

// For primitive arrays - no direct method
int[] primitives = {1, 2, 3};
List<Integer> list2 = Arrays.stream(primitives)
                            .boxed()
                            .collect(Collectors.toList());

Array Operations Time Complexity

Understanding the performance characteristics of array operations is crucial for interviews.

Operation Complexities

Operation	Time	Space	Notes
Access by index	O(1)	O(1)	Direct memory calculation
Search (unsorted)	O(n)	O(1)	Must check each element
Search (sorted)	O(log n)	O(1)	Binary search possible
Insert at end	O(1)*	O(1)	*If space available
Insert at beginning	O(n)	O(n)	Must shift all elements
Insert at middle	O(n)	O(n)	Must shift half elements
Delete at end	O(1)	O(1)	Just decrease size
Delete at beginning	O(n)	O(n)	Must shift all elements
Delete at middle	O(n)	O(n)	Must shift elements

Why O(1) Access?

// Memory address calculation:
// address = base_address + (index * element_size)

int[] arr = new int[5];
// Base address: 1000
// Element size: 4 bytes (int)

// arr[3] = 1000 + (3 * 4) = 1012
// Direct calculation, no traversal needed!

Why O(n) Insertion/Deletion?

// Insert 99 at index 2
int[] arr = {1, 2, 3, 4, 5};
// Step 1: Shift elements right
// [1, 2, _, 3, 4, 5]  ← shift 3, 4, 5
// Step 2: Insert
// [1, 2, 99, 3, 4, 5]

// Deletion at index 2
int[] arr = {1, 2, 99, 3, 4, 5};
// Step 1: Remove element
// [1, 2, _, 3, 4, 5]
// Step 2: Shift elements left
// [1, 2, 3, 4, 5]

When to Use Arrays

Good for:

• When you know the exact number of elements
• When you need fast random access
• When memory is a concern (arrays are more compact)
• When working with primitive types (no boxing overhead)

Bad for:

• When you need to add/remove elements frequently
• When you don't know the size in advance
• When you need advanced operations like sorting by custom criteria

Common Interview Patterns

// Pattern 1: Two-pointer (for sorted arrays)
// Pattern 2: Sliding window (for subarray problems)
// Pattern 3: Prefix sum (for range queries)
// Pattern 4: Sorting first (when order doesn't matter)
// Pattern 5: HashMap (for frequency/counting)