Arrays (Lists): Ordered Collections

From Bee: arr.sort() sorts as strings by default. [10, 2, 1].sort() returns [1, 10, 2]. Always pass a comparator for numbers.

What Is an Array?

An array (Python calls them lists) is an ordered collection of values. Each value has a numeric index starting at 0. The first item is at index 0; the second at index 1; and so on.

Reading and Changing Elements

Use square brackets to access an element by index. Out-of-range indexes either throw an error (Python, Java) or return undefined (JS).

Common Operations

Adding to the end (push/append), removing from the end (pop), inserting at a position, removing by value, sorting, mapping (transforming each item), filtering — these are the verbs you'll use daily with arrays.

Code Examples in Three Languages

let scores = [10, 20, 30];

scores[0];          // 10  (first)
scores.length;      // 3
scores[scores.length - 1]; // 30  (last)

// Mutate
scores.push(40);    // [10,20,30,40]
scores.pop();       // 40 — removes last
scores[1] = 99;     // [10,99,30]

// Iterate
for (const s of scores) console.log(s);

// Transform
const doubled = scores.map(n => n * 2);
const high = scores.filter(n => n > 15);

scores = [10, 20, 30]

scores[0]           # 10
len(scores)         # 3
scores[-1]          # 30  (negative = from end)

# Mutate
scores.append(40)
scores.pop()        # 40
scores[1] = 99

# Iterate
for s in scores:
    print(s)

# Transform (list comprehension)
doubled = [n * 2 for n in scores]
high = [n for n in scores if n > 15]

int[] scores = {10, 20, 30};
scores[0];             // 10
scores.length;         // 3 (no parens — it's a property)

// Fixed-size arrays can't grow. Use ArrayList:
List<Integer> list = new ArrayList<>();
list.add(40);
list.remove(0);
list.set(1, 99);

for (int s : scores) {
    System.out.println(s);
}

Best Practices

1. Use built-in methods (map, filter) over manual loops when transforming.
2. Avoid sparse arrays (gaps with no values) — they confuse readers.
3. Don't modify an array while looping over it.
4. Use array destructuring (JS/Python) for cleaner code: const [a, b] = arr;

Common Mistakes

• Off-by-one when accessing the last element. Index of last is length - 1.
• Out-of-bounds access. Returns undefined in JS but throws in Python and Java.
• Treating length as a method in Java arrays. It's a property — no parentheses.
• Confusing fixed-size and resizable arrays in Java. Use ArrayList when you need to grow.

How It Works Under the Hood

An array is, in most languages, a contiguous block of memory holding values of equal size. Reading arr[5] takes constant time: the runtime computes start_address + 5 × element_size and reads that memory location. This is why array indexing is so fast.

Insertion at the end (push) is amortized O(1): the array has spare capacity for occasional growth. Insertion in the middle (splice) requires shifting every later element — O(n). When you find yourself doing many middle-insertions, reach for a different data structure (linked list, deque).

JavaScript arrays are technically objects (sparse, mixed-type), but engines optimize "regular" arrays into the fast path you'd expect. Mixing types or leaving holes can deoptimize them.

From Beginner to Pro

The same concept gets deeper as you grow. Here's what mastery looks like at three levels:

Performance & Gotchas

• JS sort is alphabetical by default. Always pass a comparator for numbers.
• Spread does shallow copy. Nested objects still share refs.
• Array out-of-bounds returns undefined in JS but throws in Python/Java.
• Mutating during iteration skips elements.

Quick Quiz

Real-World Uses (Production Code, Today)

Frequently Asked Questions

Related Concepts