Memória utilizada nos aplicativos é sempre um grande problema, quando falamos em dispositivos móveis. O android possui estruturas específicas que podem melhorar o uso de memória do aplicativo, e que foram criadas especialmente para seu framework. Nestes slides você poderá conhecer estas estruturas um pouco melhor.

1. Estruturas de Dados Android
Otimizando uso de memória em aplicações android
Paula Rosa
Desenvolvedora Android

2. Estruturas de dados Java
• API do Java;
• Representam estruturas de dados avançadas;
• Vieram para facilitar a manipulação de
estruturas;
• Mais utilizadas no android: ArrayList, HashMap;

3. Estrutura de dados Java
ArrayList LinkedList HashMap TreeMap
interface
List
interface
Map
- Permite valores duplicados - Não Permite chaves duplicadas

4. ArrayList
• Representa um array (série de elementos do mesmo tipo);
• Foi criada para facilitar manipulação com os arrays
• Rápida para acessar elementos get(index);
• Não é syncronized
LinkedList
• Lista ligada: cada elemento Entry possui 3
referencias: next, previous e element;
• Rápida para adicionar e remover elementos;
• Não é syncronized

5. HashMap
• Possui conceito de chave-valor (key-value);
• Implementa a interface Map;
• 2 conceitos importantes:
- initial size: default 16 posições
- load factor (float mensura o momento em que dobrará o
número de posições) - default: 0.75
• Métodos: put(key, value), get(key), containsKey(key)…
• Não é syncronized

7. Estrutura de dados Android: SparseArray e
ArrayMap
• São estruturas de dados criadas especificamente
para o Android;
• Usadas em situações que precisamos de estruturas
Chave-Valor (key-value);

8. 1˚ motivo: Autoboxing
• Conversão automática de um primitivo na sua classe
Wrapper;
• Ocorre em tempo de compilação;
• Hashmap não permite chaves com primitivos;
Integer i = 5;

9. 2˚ motivo: Objetos Extras para mapeamento
• Cria um objeto extra (int) usado no cálculo da posição;
• Precisa armazenar os valores de hashcode, chave,
valor e próximo registro;
1
0
5
1
5
2
3
função hash
f(x) = x mod 13
Posição
chave
null
null
2
3
null
5
15
bucket
Colisão

10. SparseArray
• Utiliza conceito de chave-valor (key-value);
• utiliza valores int ou long primitivos como chave;
• Utiliza um array separado para a chave;
• Utiliza busca binária internamente;
• Recomendado para estruturas até 1000 elementos;

11. SparseArray
• Os elementos removidos são marcados, o array não
sofre compactação logo em seguida da remoção;
• Futuramente será recolhido pelo GC;
Chave Valor
Arrays
Adicionar de Elementos Remoção de elementos
0
1
2
3
4
5
A
B
C
K
E
F
put(3,”K") 0
1
2
3
4
5
A
B
C
Deleted
E
F
remove(3)0
1
2
3
4
5
A
B
C
D
E
F

12. SparseArray
Considerações:
• O elemento removido é marcado
como DELETED;
• Ao requisitar o tamanho ou um
elemento, ocorre a compactação;
• Ao inserir verifica se a posição já
esta marcada como Deleted;
SparceArray Tipo de dados
SparseArray <int, Object>
SparseIntArray <int, int>
SparseBooleanArray <int , boolean>
SparseLongArray <int, long>
LongSparseArray <long, Object>

13. Curiosidades
• SparseArray é recomendado para estrutura de dados
pequenas
"João"
"Amanda"
"Luiz"
HashMap
função
hash
Amanda
Luiz
0
1
2
…
João
…
14
Bucket
O(1) constante (melhor caso)
O(n) proporcional (pior caso)
SparseArrays
0
1
2
3
4
5
A
B
C
D
E
F
O(log n) - busca binária
inserir e deletar mais trabalhoso
get get

14. Resultado
• Redução na quantidade de objetos utilizados;
• Implica em menos objetos para serem recolhidos pelo garbage
collector;
• Melhor aproveitamento da estrutura;
• Economia de memória;

15. ArrayMap
• Utiliza conceito de chave-valor (key-value);
• Utiliza objetos como chave;
• Utiliza dois arrays: um com valor de hash outro com
chave/valor;
• Utiliza busca binária internamente;
• Implementa a interface Map;
• Recomendado para estruturas até 1000 elementos;

16. ArrayMap
Considerações:
• Recomendado para maior frequência de leitura (get);
• Adicionar e remover são mais custosos;
• Cache interno de Arrays de tamanho 4 e 8 para evitar spam
do GC;
• API 19+;
Array 1 Array 2
hash #1
hash #2
hash #3
key #1
value #1
key #2
value #2
key #3
value #3

17. ArrayMap
Iteração

18. Curiosidades
• ArrayMap é recomendado para estrutura de dados
pequenas
"João"
"Amanda"
"Luiz"
HashMap
função
hash
Amanda
Luiz
0
1
2
…
João
…
14
Bucket
O(1) constante (melhor caso)
O(n) proporcional (pior caso)
hash #1
hash #2
hash #3
key #1
value #1
key #2
value #2
key #3
value #3
ArrayMap
O(log n) - busca binária
inserir e deletar mais trabalhoso
get get

19. Resultado
• Redução na quantidade de objetos utilizados;
• Implica em menos objetos para serem recolhidos pelo garbage
collector;
• Melhor aproveitamento da estrutura;
• Economia de memória;

20. Curiosidades
• SparseArrayCompat (suporte versões API < 19)
• removeAtRange(int index, int size);
• ArrayMap implementa interface Map
• SimpleArrayMap (suporte)
• importante: não implementa Map, mas contém a
maioria dos métodos;
• ArraySet implementa Collection<E> e Set<E>;

21. Curiosidades
• Syncronized:
• ArrayList, LinkedList
• Collections.syncronizedList(lista);
• HashMap
• Collections.syncronizedMap(map);
• HashTable;

22. finally{}
• Utilizar estrutura de dados do Android quando
necessário;
• Tamanho de dados não exceder 1000 itens;
• Chaves int ou long: SparseArray
• Chaves objetos: ArrayMap
• Usar SimpleArrayMap quando não precisar de
compatibilidade com Map;

23. Referências
• https://developer.android.com/reference/android/util/SparseArray.htm
l
• https://developer.android.com/reference/android/support/v4/util/Array
Map.html
• https://www.youtube.com/watch?v=ORgucLTtTDI
• https://www.youtube.com/watch?v=I16lz26WyzQ&t=129s
• http://gunhansancar.com/sparsearray-vs-hashmap/
• https://blog.mindorks.com/android-app-optimization-using-arraymap-and-
sparsearray-f2b4e2e3dc47#.lhprjal9a
• http://deepakmishra.me/blog/index.php/2015/10/19/hashmaps-arraymaps-
and-sparsearrays-in-android/
• http://www.roman10.net/2017/01/29/arraymap-and-its-friends-in-android/
• http://www.roman10.net/2017/01/21/sparsearray-and-its-friends-in-android/