How to iterate through SparseArray?

java

sparse-array

android-development

performance-optimization

byNikita Barsukov·Jan 24, 2025

You generally use a for loop to iterate through a SparseArray, utilising methods like size(), keyAt(), and valueAt(). Here's a straightforward example:

SparseArray<E> sparseArray = // ... let's imagine it's magically initialized
for (int i = 0; i < sparseArray.size(); i++) {
   int key = sparseArray.keyAt(i); // find the key hidden at the 'i' th position
   E value = sparseArray.valueAt(i); // Oh! Here is the "value" for that key
   // time to play around with the key and its value!
}

This loop nicely navigates along the sparseArray's elements and hooks up the keys with their related values without stumbling over the null spots.

Practical guide for SparseArray iteration

A SparseArray can be a quirky little data structure at your disposal in Android. It's a handy tool meant to be more memory-efficient than a HashMap when your data is--you guessed it--sparse! In this case, a SparseArray, which maps integers to objects, wins over a standard Array or HashMap as it rolls without requiring auto-boxing of primitive types.

Key methods for iterating a SparseArray

size(): This tells you how many key-value pairs are hanging out in your SparseArray.
keyAt(int): Fetches the key hiding at the index. Sneaky, right?
valueAt(int): Don't bother with the key lookup, grab the value directly from its index.

Tips for efficiency

Fetch size out of the loop: Call sparseArray.size() outside the loop. It's like counting your apples before you start giving them away at a party.
Keyless value access: Get cozy with valueAt(int) to fetch the value without an additional key lookup. A direct approach is always best!

Kotlin: The magician's way

Feel like city-hopping in Kotlin? With some modern spellcasting extensions, iterating through SparseArrays could be just a breeze.

sparseArray.forEach { key, value ->
   // the key and value tag-teaming here!
}

This forEach wizardry makes your code Sparta--I mean sparkly, and very readable.

When to summon the SparseArray

Know when to roll out SparseArray instead of HashMap. HashMap is often the chosen one for key-value pairs. But watch out when your keys are prim primitive int type, and the allocation is too heavy for the poor old memory. SparseArray to the rescue!

You can consider SparseArray as one of your superpowers. But, hey, remember - "With great power, comes great responsibility". Use wisely!

Watch out for the bumps

There are a few things to keep in mind when you're cruising on SparseArray:

delete(int): Deleting, while iterating, can pull out the carpet from under your loop's feet. Does "undefined behavior" sound fun to you? I didn't think so.
Concurrency issues: If your SparseArray is susceptible to modifications during iteration, consider mechanisms to avoid conflicts. You don't want to trip over a race condition!
Null checks: SparseArray is designed to waltz over blank spaces, but it doesn't mean you should let your guard down against null Exceptions.

Performance Pit Stops

Measuring performance: Don't just assume SparseArray outperforms everything else. Try pairing it with tools like Android Studio's profiler for accurate insights.
Memory check: Frequently check memory usage. Ensure SparseArray is not just a fancy titanic but actually saves some memory compared to HashMap.

explain-codes / Java / How to iterate through SparseArray?

Linked

Sparsearray vs HashMap



Iterate through a HashMap



How to remove a key from HashMap while iterating over it?



Hashmap with multiple values under the same key



How to for each the hashmap?

