ResumosMIEI

Uma coleção de resumos, para ajudar os que precisam daquele empurrão.

Project maintained by mendess Hosted on GitHub Pages — Theme by mattgraham

Collections

As collections de Java permitem-nos abstrair o comportamento habitual de guardar os nosso objetos em arrays, arvores, hastables, etc. Estes padrões de programação são tão comuns que não vale a pena estar sempre a definilos.

Neste documento vou falar de Collection e Map, que não é uma collection mas serve um proposito similar.

Nota: Este resumo assume que os conceitos de Hierarquia de Classes estão bem compreendidos.

Nota: Este resumo apenas apresenta uma reduzida lista de classes e metodos de forma exemplificativa. Existem muitas mais classes e metodos.

Hierarquia de classes das collections

A API das Collections disponibiliza as seguintes classes: (Existem mais, este é apenas um pequeno exemplo)

                                  +-------------------------------+
                    +------------>|        Collection<E>          |<------+
                    |             +-------------------------------+       |
                    |                ^                                    |
                    |                |                                    |
                    |                |                                    |
               +---------+      +----------+                          +--------+
      ++======>| List<E> |      | Queue<E> |<=====++                  | Set<E> |<====++
      ||       +---------+      +----------+      ||                  +--------+     ||
      ||             ^^            ^^             ||                     ^^          ||
      ||             ||            ||             ||                     ||          ||
      ||             ||            ||             ||                     ||          ||
++==============++  ++===============++ ++==================++  ++============++   +--------------+
|| ArrayList<E> ||  || LinkedList<E> || || PriorityQueue<E> ||  || HashSet<E> ||   | SortedSet<E> |
++==============++  ++===============++ ++==================++  ++============++   +--------------+
                                                                       ^                  ^^
                                                                       |                  ||
                                                                       |                  ||
                                                          ++==================++   ++============++
                                                          || LinkedHashSet<E> ||   || TreeSet<E> ||
                                                          ++==================++   ++============++
Legenda:
++==++                        ^^  ==>
||  ||  -> Classe             ||       -> Implements
++==++                        ||

+----+                         ^ -->
|    |  -> Interface           |       -> Extends
+----+                         |

Podemos consultar a documentação de todas estas para saber que métodos temos disponíveis:

Collection

A interface Collection garante que todas as classes que a implementam disponibilizam, entre outros, métodos para adicionar, verificar a existência e remover elementos.

boolean add(E e)
boolean remove(E e)

Ambos retornando true se o estado da collection foi alterado.

boolean contains(Object o)

Que retorna true case o objecto esteja contido na coleção.

List

Esta interface que estende a Collection adiciona, entre outros, métodos com a noção de índice, muito analogo a um array:

int indexOf(Object o) Que retorna o índice de um determinado objeto
E get(int index) Que retorna o objeto que está num dado índice
boolean remove(int index) Que remove um objeto num dado índice

ArrayList

A implementação de lista mais usada é o ArrayList. Este exibe o comportamento de um array dinâmico. Disponibilizando assim métodos que esperamos encontrar numa lista que herda.

Map

Um map, ou dicionário, server para guardar pares chave-valor. Efetivamente são uma Hash Table.

Hierarquia de classes do Map

A API do Map disponibiliza as seguintes classes: (Existem mais, este é apenas um pequeno exemplo)

                       +----------------------+
             ++=======>|       Map<K,V>       |<---------+
             ||        +----------------------+          |
             ||                                          |
    ++================++                        +-------------------+
    ||  HashMap<K,V>  ||                        |   SortedMap<K,V>  |
    ++================++                        +-------------------+
              ^                                          ^
              |                                          |
              |                                 +-------------------+
   ++====================++                     | NavigableMap<K,V> |
   || LinkedHashMap<K,V> ||                     +-------------------+
   ++====================++                              ^^
                                                         ||
                                                ++=================++
                                                ||   TreeMap<K,V>  ||
                                                ++=================++

Podemos consultar a documentação de todas estas para saber que métodos temos disponíveis:

Map API

A interface Map garante que todas as classes que a implementam disponibilizam, entre outros, métodos para adicionar, verificar a existência, obter e remover elementos

boolean put(K key, V value)
boolean containsKey(Object key)
V get(K key)
V remove(K key)

Outros métodos importantes são:

Set<K> keySet() para obter o conjunto das chaves.
Collection<V> values() para obter uma coleção de valores do map.
Set<Map.Entry<K,V>> entrySet() que devolve um conjunto de pares chave-valor.

Importante notar que estes métodos podem ter fraco desempenho em algumas implementações da interface, por exemplo HashMap, devido à ineficiência de iterar sobre este tipo de estruturas. Por esta razão, Map não implementa Iterable.