Cosmic Module

J

Qubits of DPK

March 14, 2026

Core Java

Layman Explanation

Instead of creating 30 separate variables for 30 students' marks, you create ONE variable that holds all 30 values in order. That's an array — a named row of boxes, each with an index.

Real World Analogy

A train with numbered seats. Seat 0, Seat 1, Seat 2... You can jump to any seat directly if you know the number. That's O(1) access by index.

Creation of Arrays

java
QUBITS OF DPK
1// Method 1 — Declare, allocate, assign
2int[] marks = new int[5];
3marks[0] = 85; marks[1] = 90;
4
5// Method 2 — Direct initialization
6int[] marks = {85, 90, 78, 92, 88};
7
8// All types
9String[] names   = {"Deepak", "Arjun"};
10double[] prices  = {9.99, 14.99};
11boolean[] flags  = {true, false, true};

Memory Model

javascript
QUBITS OF DPK
1STACK                    HEAP
2────────────────         ─────────────────────────
3marks ───────────► [ 85 | 90 | 78 | 92 | 88 ]
4(reference)           index: 0    1    2    3    4

Multidimensional Arrays

java
QUBITS OF DPK
1// 2D Array — table with rows and columns
2int[][] matrix = {
3    {85, 90, 78},   // row 0
4    {92, 88, 95},   // row 1
5    {70, 75, 80}    // row 2
6};
7
8System.out.println(matrix[1][2]);  // 95 (row 1, col 2)
9
10// Iterate 2D
11for (int row = 0; row < matrix.length; row++) {
12    for (int col = 0; col < matrix[row].length; col++) {
13        System.out.print(matrix[row][col] + " ");
14    }
15    System.out.println();
16}

Jagged Array

java
QUBITS OF DPK
1// Different column sizes per row
2int[][] jagged = new int[3][];
3jagged[0] = new int[1];   // row 0: 1 column
4jagged[1] = new int[2];   // row 1: 2 columns
5jagged[2] = new int[3];   // row 2: 3 columns
6
7// Visual:
8// Row 0: [ 1 ]
9// Row 1: [ 2 | 3 ]
10// Row 2: [ 4 | 5 | 6 ]

3D Array

java
QUBITS OF DPK
1int[][][] cube = {
2    { {1,2,3}, {4,5,6} },    // layer 0
3    { {7,8,9}, {10,11,12} }  // layer 1
4};
5// Access: cube[layer][row][col]
6System.out.println(cube[1][0][1]);  // 8

Default Values

java
QUBITS OF DPK
1int[]    nums  = new int[5];    // [0, 0, 0, 0, 0]
2double[] dec   = new double[3]; // [0.0, 0.0, 0.0]
3String[] names = new String[3]; // [null, null, null]

Advantages

javascript
QUBITS OF DPK
11. O(1) random access by index — fastest data structure for access
22. Contiguous memory — cache friendly, fast iteration
33. Memory efficient — no pointer overhead like LinkedList
44. Supports Arrays.sort() O(n log n), Arrays.binarySearch() O(log n)
55. Foundation for 2D/3D problems in DSA

Drawbacks

javascript
QUBITS OF DPK
11. FIXED SIZE — cannot grow/shrink dynamically (biggest limitation)
22. Insertion/deletion = O(n) — must shift all elements
33. Homogeneous — one data type only
44. No built-in add(), remove(), contains()
55. Memory waste if declared large but used small
66. ArrayIndexOutOfBoundsException if access beyond length

️ All Traps

java
QUBITS OF DPK
1// Trap 1 — length is property, not method
2arr.length    // ✅
3arr.length()  // ❌ compile error
4
5// Trap 2 — Index starts at 0
6int[] arr = {10, 20, 30};
7arr[3]     // ❌ ArrayIndexOutOfBoundsException
8
9// Trap 3 — Reference copy not deep copy
10int[] a = {1, 2, 3};
11int[] b = a;         // same array in heap!
12b[0] = 99;
13System.out.println(a[0]);  // 99!
14// Fix: Arrays.copyOf(a, a.length)
15
16// Trap 4 — 2D length
17matrix.length      // rows
18matrix[0].length   // columns in row 0
19
20// Trap 5 — for-each cannot modify array
21for (int x : arr) { x = 0; }  // original unchanged!
22
23// Trap 6 — Jagged uninitialized rows
24int[][] j = new int[3][];
25j[0].length;   // ❌ NullPointerException! Row not initialized.

Interview Answer (SDE-2)

"Arrays store multiple values of same type in contiguous memory, providing O(1) index access. Reference lives in stack, actual data in heap. 2D arrays are arrays of arrays — each row is a separate heap object enabling jagged arrays with variable row lengths. Key advantages: fast access, cache-friendly, memory efficient. Key drawback: fixed size — which is why ArrayList exists for dynamic needs. Insert/delete is O(n) due to shifting. Common traps: length is a property not method, index starts at 0, reference copy shares same heap array, for-each loop cannot modify elements."

Interview Questions & MAANG-Level Answers

Q1. What is the time complexity of accessing an element in an array?
O(1) — constant time. Since arrays store elements in contiguous memory, accessing arr[i] is a simple arithmetic: baseAddress + (i * elementSize). No searching needed, no traversal — direct jump to the memory address. This is the biggest advantage of arrays over LinkedLists (which are O(n) for index access).
Q2. Why is insertion at index 0 O(n) for arrays?
Because arrays are fixed contiguous blocks of memory. To insert at index 0, every existing element must shift one position to the right to make space: index 0→0 becomes 1, 1→2, etc. For n elements, that's n shifts — O(n). Same for deletion. This is why ArrayList (backed by array) is slow for frequent insertions/deletions at arbitrary positions, and why LinkedList is preferred when that's the primary operation.
Q3. What is the difference between a regular 2D array and a jagged array?
A regular 2D array has the same number of columns in every row: int[][] matrix = new int[3][4] — 3 rows, each with exactly 4 columns. A jagged array is an array of arrays where each row can have different lengths: int[][] jagged = new int[3][]; jagged[0] = new int[1]; jagged[1] = new int[3];. In Java, 2D arrays are always jagged arrays under the hood — each row is an independent array object in heap.
Q4. How do you deep copy an array in Java?
For 1D arrays: int[] copy = Arrays.copyOf(original, original.length) or System.arraycopy(). Simple int[] copy = original is a SHALLOW copy — both reference same array. For 2D arrays, you need to copy each row separately:
java
QUBITS OF DPK
1int[][] deep = new int[original.length][];
2for (int i = 0; i < original.length; i++) {
3    deep[i] = Arrays.copyOf(original[i], original[i].length);
4}
For object arrays, deep copy requires copying each object too (not just references).
Q5. Why would you use ArrayList over an array?
ArrayList when: you don't know size upfront (dynamic resizing), you need rich API (add, remove, contains, sort), you need to insert/remove elements frequently, or you need to store in a Collection-based API. Array when: size is fixed and known, you need maximum performance (no boxing/unboxing overhead), you're working with primitives, or you need multidimensional data structures (matrix problems).
Q6. What is ArrayIndexOutOfBoundsException?
Thrown when accessing an array with an invalid index — negative or >= array length. Valid indices are 0 to length-1. int[] arr = new int[5]; arr[5] = 10 throws it (valid indices: 0-4). Common cause in DSA: off-by-one errors in loop conditions (i <= arr.length instead of i < arr.length). In production, always validate indices before access or use bounds-safe methods.