What I learned from Head First Java: Arrays and ArrayList

Java offers multiple ways to store collections of data, but two of the most commonly used option (Arrays and ArrayLists) often confuse. In this article, I'll break down the differences between these two data structures in a way that's easy to understand, even if you're new to Java.

Hello 👋 and welcome to Head First series!

🚨Spoiler Alert 😉
I'm assuming that you are familiar with arrays and ArrayLists basics. Nothing much, just creating will be good for now. Ready? Lets goooo!

---

Definition of terms: The Bookshelf Analogy

I tried to come up with a fair comparison of the scenario using shelves. Think of an array as a bookshelf you buy from IKEA (a common furniture store) with a specific number of slots. Once assembled, you can't add more shelves without buying a completely new unit. An ArrayList, on the other hand, is like a magic bookshelf that automatically expands whenever you need more space.

Arrays: The Traditional Fixed-Size Option

Arrays in Java are the original way to store multiple values of the same type. Once created, their size is set in stone.

// Creating an array that can hold exactly 5 integers
int[] scoresArray = new int[5];

// Adding elements at specific positions
scoresArray[0] = 85;
scoresArray[1] = 92;
scoresArray[2] = 78;
scoresArray[3] = 95;
scoresArray[4] = 88;

// Want to add a 6th score? You can't!
// scoresArray[5] = 90; // This crashes with ArrayIndexOutOfBoundsException

// You can also create and initialize an array in one go
String[] daysOfWeek = {"Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"};

What happens if you need to store more elements than initially planned? You'll need to create a new, larger array and copy all the elements over, a tedious process that requires manual coding.

ArrayList: The Flexible Modern Alternative

Enter ArrayList 🥁, part of Java's Collections Framework. It handles all the resizing hassle behind the scenes so you can focus on your data, not managing storage.

// First, you need to import it
import java.util.ArrayList;

// Creating an ArrayList of Strings
ArrayList<String> shoppingList = new ArrayList<>();

// Adding items is easy
shoppingList.add("Milk");
shoppingList.add("Bread");
shoppingList.add("Eggs");

// Forgot something? No problem!
shoppingList.add("Coffee");
shoppingList.add("Cheese");

// Oops, already have eggs at home
shoppingList.remove("Eggs");

// Need to check if an item is on your list?
boolean needsMilk = shoppingList.contains("Milk"); // returns true

// How many items on the list?
int itemCount = shoppingList.size(); // returns 4

The beauty of ArrayList lies in its flexibility and built-in methods that make common operations simple.

Side-by-Side Comparison

Feature	Array	ArrayList
Size	Fixed	Dynamic (resizable)
Syntax	Type[] name	ArrayList<Type> name
Memory	More efficient	Slight overhead
Performance	Generally faster	Slightly slower for very large data sets
Element types	Primitives or objects	Objects only (uses wrappers for primitives)
Utility methods	Almost none	Many (add, remove, contains, etc.)
Type safety	Checked at compile time	Generic type checked at compile time

When to Use Arrays

Despite the conveniences of ArrayList, arrays still have their place:

1. Performance-critical applications: Arrays have less overhead.
2. Working with primitives: If you need a large collection of int, double, etc. values, arrays avoid the wrapper objects overhead.
3. Multi-dimensional data: While you can create ArrayLists of ArrayLists, multi-dimensional arrays like int[][] are more straightforward for certain algorithms.
4. When size truly is fixed: If you're representing something with an inherently fixed size (like days of the week, chess board squares, etc.).

When to Use ArrayList

ArrayList shines in many modern use cases:

1. Unknown or changing size: When you don't know in advance how many elements you'll need.
2. Frequent insertions/deletions: When you need to add or remove elements frequently.
3. Need for built-in methods: When you want convenient methods like indexOf(), contains(), or removeIf().
4. Working with collections: When interfacing with other collection types or using streams.

Real-World Example: Managing Student Records

Let's see both approaches in a practical scenario—tracking students in a class:

// Array approach - Fixed number of students
Student[] classRoster = new Student[30]; // Hope we don't get a 31st student!

// Adding students
classRoster[0] = new Student("Alex", "Johnson");
classRoster[1] = new Student("Taylor", "Smith");
// ... and so on

// ArrayList approach - Flexible roster
ArrayList<Student> classRoster = new ArrayList<>();

// Adding students
classRoster.add(new Student("Alex", "Johnson"));
classRoster.add(new Student("Taylor", "Smith"));

// Mid-semester transfer student? No problem
classRoster.add(new Student("Jordan", "Williams"));

// Student drops the class
classRoster.remove(1); // Removes Taylor

// Find a specific student
int alexPosition = -1;
for (int i = 0; i < classRoster.size(); i++) {
    if (classRoster.get(i).getFirstName().equals("Alex")) {
        alexPosition = i;
        break;
    }
}

The Syntax Differences

One thing that often trips up Java beginners is the syntax differences (That's a subjective point of view, hey 😅):

For arrays:

// Declaration and initialization
int[] numbers = new int[5];

// Accessing elements
numbers[2] = 42;
int value = numbers[2];

// Getting length
int length = numbers.length; // Note: length is a property, not a method

For ArrayLists:

// Declaration and initialization
ArrayList<Integer> numbers = new ArrayList<>();

// Accessing elements
numbers.add(42); // Adds to the end
numbers.set(2, 42); // Sets value at index 2
int value = numbers.get(2);

// Getting size
int size = numbers.size(); // Note: size() is a method, not a property

Behind the Scenes

Understanding what happens internally can help you make better choices:

Arrays are contiguous blocks of memory with direct access to any element via its index—making lookups extremely fast (O(1) time).

ArrayLists store data in a resizable array. When it fills up, ArrayList creates a new, larger array (typically 1.5x the current size) and copies all elements over. This happens automatically but can cause performance hiccups if done frequently with large collections.

So to wrap things up.....

Both arrays and ArrayLists are valuable tools in Java programming. Arrays offer simplicity and raw performance with fixed sizes, while ArrayLists provide flexibility and convenience at a minor performance cost.

I'd recommend starting with ArrayList in most cases—its flexibility and built-in methods make it more forgiving and productive. As your Java skills advance, you'll develop a sense of when arrays might be the better option for specific scenarios.

Remember, good programming isn't just about choosing the right tool, but understanding why it's the right tool for the job at hand.

What's your experience with arrays and ArrayLists? Drop a comment below and let me know which you prefer and why!

Until next time......