Arrays are linear data structures that store elements of the same type in contiguous memory blocks. Each element can be accessed directly using an index, which represents a memory offset from the base address.

Initializing Arrays

Arrays can be initialized with or without default values. When no initial values are provided, elements are typically set to zero.

public void initializeArray() {
    // Empty initialization
    int[] data = new int[8];
    
    // Pre-filled initialization
    int[] values = {10, 20, 30, 40, 50};
}

Random Element Access

Arrays enable constant-time random access through index calculation:

public int getRandomElement(int[] elements) {
    int randomPos = ThreadLocalRandom.current().nextInt(0, elements.length);
    return elements[randomPos];
}

Iterating Through Elements

Two common methods for array traversal:

public void iterateArray(int[] elements) {
    // Index-based iteration
    for (int i = 0; i < elements.length; i++) {
        System.out.println(elements[i]);
    }

    // Direct element iteration
    for (int element : elements) {
        System.out.println(element);
    }
}

Element Search

Linear search examines each element sequentially:

public int locateElement(int[] elements, int searchValue) {
    for (int position = 0; position < elements.length; position++) {
        if (elements[position] == searchValue) {
            return position;
        }
    }
    return -1;
}

Inserting Elements

Insertion requires shifting subsequent elements, resulting in O(n) complexity:

public void insertElement(int[] elements, int position, int newValue) {
    // Shift elements right from insertion point
    for (int i = elements.length - 1; i > position; i--) {
        elements[i] = elements[i - 1];
    }
    elements[position] = newValue;
}

Removing Elements

Deleetion involves left-shifting elements after the target position:

public void removeElement(int[] elements, int position) {
    // Shift elements left from deletion point
    for (int i = position; i < elements.length - 1; i++) {
        elements[i] = elements[i + 1];
    }
    elements[elements.length - 1] = 0; // Clear last element
}

Array Expansion

Fixed-size arrays require creation of new arrays for expansion:

public int[] expandArray(int[] original, int newCapacity) {
    int[] expanded = new int[newCapacity];
    for (int i = 0; i < original.length; i++) {
        expanded[i] = original[i];
    }
    return expanded;
}

Advantages

• Memory efficiency from contiguous storage
• Constant-time random access
• Cache-friendly memory layout

Limitations

• O(n) time complexity for insertions and deletions
• Fixed capacity requiring expensive resizing
• Potential memory waste from overallocation

Common Applications

• Random sampling and access operations
• Sorting and searching algorithms
• Foundation for stacks, queues, and hash tables
• Machine learning and signal processing