Why Arrays Got Introduced?

Let's take a step back and consider why we need arrays in the first place. 🤔

Why not make use of primitives?

In Java int takes 4 bytes. So, the declaration below occupies 4 bytes of memory.

int a = 100;

What if we want to store six int values (or 24 bytes)? We need to use six different variables individually, each occupying 4 bytes so that the total will be 6 * 4 = 24 bytes.

// each of the following occupies 4 bytes, which is 6 * 4 bytes
int a1 = 100;
int a2 = 200;
int a3 = 300;
int a4 = 400;
int a5 = 500;
int a6 = 600;

Creating six different variables is a bit dirty and not a good idea. What if we wanted to store a million entries? Are we supposed to create a million different variables? 😢 Isn't this bad coding?

Arrays to the rescue 🤩

Instead, we store the million items in an array sequentially in an int[] array. This can be achieved easily by following the declaration and initialization with values.

int[] array = {100, 200, 300, 400, 500, 600};

Arrays are used for efficient data storage, quick access, and optimized memory usage.

Isn't the array beautiful? 😻

Key reasons

Arrays were introduced in Java for several key reasons, as part of Java SDK design decisions.

This helps fast O(1) memory-efficient access, type-safe storage of same-type elements. Foundation for collections like ArrayList. Essential for performance-critical code.

Memory Efficiency & Performance

• Arrays store elements of the same type in contiguous memory locations, making memory usage predictable and efficient
• Direct access to any element via index in constant time O(1) - much faster than searching through a list

Simplicity & Familiarity

• Developers coming from C/C++ expected arrays as a fundamental data structure
• Simple syntax: int[] numbers = new int[10] is intuitive and easy to learn

Foundation for Higher-Level Collections

• Arrays serve as the underlying implementation for many Java collections like ArrayList, Vector, and StringBuilder
• Provides a low-level building block that other data structures can build upon

JVM Optimization

• The Java Virtual Machine can heavily optimize array operations since it knows the exact memory layout
• Enables efficient bounds checking and garbage collection

Type Safety

• Arrays enforce type consistency at compile time - an int[] can only hold integers
• Fits well with Java's strong typing system

Integration with Language Features

• Arrays work seamlessly with for-each loops: for(int num : numbers)
• Support for multi-dimensional arrays: int[][] matrix