In Android zijn er kaarten waarin je primitieve types…

Ja, voor het werken met primitieve types in Android SDK, zijn er gespecialiseerde implementaties van Map, geoptimaliseerd voor prestaties en geheugenbesparing in vergelijking met de standaard HashMap<K, V>.

De meest voorkomende zijn:

SparseIntArray: slaat paren van int sleutels en int waarden op.
SparseLongArray: slaat paren van int sleutels en long waarden op.
SparseBooleanArray: slaat paren van int sleutels en boolean waarden op.
LongSparseArray<E>: slaat paren van long sleutels en objecten van type E op.

Voordelen van het gebruik van deze klassen:

Geheugen efficiëntie: Ze gebruiken interne arrays om gegevens op te slaan, waardoor de overhead van het maken van wrapper-objecten voor primitieve types (Integer, Long, Boolean) en de gekoppelde lijststructuur van HashMap wordt vermeden.
Prestaties: Invoeg-, opvraag- en verwijderbewerkingen zijn over het algemeen sneller, vooral bij veel elementen, dankzij een eenvoudigere interne structuur en het vermijden van hashing voor primitieve sleutels in het geval van SparseArray.

Voorbeeld van gebruik van SparseIntArray:

// Aanmaken van SparseIntArray
SparseIntArray sparseArray = new SparseIntArray();

// Elementen toevoegen
sparseArray.put(0, 100);
sparseArray.put(1, 200);
sparseArray.put(10, 300);

// Waarde opvragen via sleutel
int value = sparseArray.get(1); // waarde zal 200 zijn

// Waarde opvragen via sleutel met standaardwaarde
int valueWithDefault = sparseArray.get(5, -1); // waarde zal -1 zijn

// Element verwijderen via sleutel
sparseArray.delete(10);

// Iteratie over elementen
for (int i = 0; i < sparseArray.size(); i++) {
    int key = sparseArray.keyAt(i);
    int val = sparseArray.valueAt(i);
    // Verwerkingslogica voor key en val
}

Evenzo worden SparseLongArray, SparseBooleanArray en LongSparseArray gebruikt. LongSparseArray vereist het specificeren van het objecttype, omdat de waarden objecten zijn en geen primitieve types.

De keuze tussen standaard HashMap en gespecialiseerde Sparse-kaarten hangt af van je vereisten:

Als de sleutels willekeurige objecten zijn of primitieve types die geen int of long zijn, gebruik dan HashMap.
Als de sleutels int of long zijn, en de waarden primitieve types of objecten in het geval van LongSparseArray, en geheugen- en prestatiedoelen belangrijk zijn, is het beter om Sparse-kaarten te gebruiken.

Het is belangrijk op te merken dat Sparse-kaarten niet thread-safe zijn. Als je een thread-safe implementatie nodig hebt, overweeg dan het gebruik van ConcurrentHashMap met wrapper-objecten voor primitieve types. Echter, in de meeste gevallen, binnen de UI-thread van een Android-applicatie, waar deze structuren vaak worden gebruikt, is thread safety geen probleem.

In Android zijn er kaarten waarin je primitieve types kunt toevoegen. Kun je hier meer over vertellen?