How to add new elements to an array?

java

array-manipulation

best-practices

performance

byAnton Shumikhin·Jul 22, 2024

Java arrays have a fixed size, meaning we can't directly resize or dynamically expand them. A common workaround is using ArrayList which provides dynamic sizing. You can then convert this back to an array when needed:

// "ArrayList" sounds like a superhero name, doesn't it?
ArrayList<Integer> list = new ArrayList<>();
list.add(1);  // Fighting crime by adding elements
list.add(2);
// Back to the civilian Identity
Integer[] array = list.toArray(new Integer[0]);

But if you're constrained to plain arrays, you can create a new, larger array copying the elements over:

// Original array, cozy but cramped
int[] original = {1, 2, 3};
// New spacious array, like moving from studio flat to a mansion
int[] extended = Arrays.copyOf(original, original.length + 1);
// Welcome the new roomie!
extended[original.length] = 4;

Most of the time, using ArrayList provides a comfortable and efficient way to handle growing collections.

Tackling arrays without ArrayList

There are inevitable scenarios where you're unable to use ArrayList for various reasons, in such cases, you can still manage arrays through:

Apache Commons Lang: Nifty little helper libraries like Apache Commons Lang offer ArrayUtils.add() which takes care of array resizing for you. Useful when you're in a pinch!

// It's like your best friend who understands both your drama and your arrays
int[] array = {1, 2, 3};
array = ArrayUtils.add(array, 4);

System.arraycopy: When you prefer handling things at a low-level, System.arraycopy() is your tool of choice to shift elements and insert new ones without manually looping.

// Like moving furniture to fit the new armchair
int[] array = {1, 2, 3};
int[] larger = new int[array.length + 1];
System.arraycopy(array, 0, larger, 0, array.length);
larger[array.length] = 4; // The new guy settles in

Efficiency Matters: Do remember that array resizing isn't a "free" operation. If your operations involve frequent additions, maybe it's time to knock ArrayList's door again!

Watch-your-step moments

Direct array manipulation

Frolicking with arrays directly could be adventurous yet tricky, it involves high-performance or low-level operations, remember to buckle up!

Bounds Checking: Never forget to check the array length before adding elements to avoid unintentional invitation to an ArrayIndexOutOfBounds party.
Thread Safety: Note that ArrayList isn't synchronized. When multiple threads barge into the scene, consider using Vector or putting up a "Do Not Disturb" sign with manual synchronization.
Memory Considerations: Wearing its additional object overhead, ArrayList walks in with larger memory footprint. If your application is number conscious, it might prefer plain arrays, they're simpler.

Embracing lists

Joshua Bloch, in his enlightening "Effective Java", suggests that preferring Lists over arrays could be your recipe for code that is both flexible and robust.

Power of List Interface: The List interface brings along its powerful methods like .add(), .remove(), and .get(), thus often seen as a favorite choice for managing data collections.
Evading Array Type Issues: ArrayList provides a helpful escape from the generic array creation issue by letting you add any kind of Mr. or Ms. Object without discrimination.

Real-world analogy: Adding carriages to a train

Current Train (Array): [🚃, 🚃, 🚃]

No vacancy! Array carriages are fixed, no space for newcomers!

Ideal Scenario: [🚃, 🚃, 🚃, 🚋]

Creating space: Build a new & larger train (array) with extra vacancies and relocate passengers (elements).

Step 1: [🚃, 🚃, 🚃] ➡️️🚧➡️ [🚃🚋, 🚃, 🚃, null]
Step 2: Fill the new vacancy ➡️ [🚃, 🚃, 🚃, 🚋]

Result: A bigger train ready to take off with new elements aboard.

Upgraded Train (Array): [🚃, 🚃, 🚃, 🚋]

Pro Tip: Arrays in Java aren't naturally gifted with dynamic expansion; if you desire flexible size adjustments, ArrayList might be the ticket!

Array manipulation best practices & tips

Picking the best tool

ArrayList: When your requirement evolves frequently and dynamically like fashion trends.
Arrays: When you're dealing with a static-sized group of elements with consistency and performance being your prime concern.

Seamless iteration

The for-each loop makes your trip through an ArrayList smooth and scenic, keeping off-by-one errors at bay and increasing code readability.

// Just a casual evening walk through the list.
for (Integer i : list) {
    System.out.println(i);
}

Memory & Performance

Remember: ArrayList's .toArray() creates a photocopy of your list making it look like an array, hence it uses an extra layer of memory. Use it carefully!
Amortized Costs: Why is ArrayList so welcoming? Its expansion operations have an O(1) average time, giving you fast additions amidst occasional expensive resize operations.