14. Liste e collezioni

Le liste sono un tipo di dato che rappresenta una lista dinamica.

Ci sono varie implementazioni: ArrayList, LinkedList...

A partite da Java 5 sono parametriche, cioè hanno bisogno di un tipo di dato associato ad esse: List<Integer>, List<String>...

Esempio di Lista

import java.util.ArrayList;
List<Person> team = new ArrayList<Person>();

team.add(new Person("Bob"));

Metodi comuni

I metodi add(index, object) e remove(index) aggiungono o rimuovono un elemento alla posizione specificata, modificando la lunghezza della lista.

I metodi get(index) e set(index, object) permettono di accedere agli elementi in una posizione specifica (gli indici iniziano da 0).

Il metodo set sostituisce l’oggetto presente alla posizione index con quello specificato da object. Tuttavia, questo metodo non va usato se alla posizione specificata da index non è presente alcun oggetto!

Sottotipi

Data la classe A e la sua subclasse B, allora la collezione Gen<B> non è sottoclasse di Gen<A>.

Ad esempio, List<String> non è sottotipo di List<Object>.

Collezioni

In generale, le liste sono un particolare tipo di collezione.

C’è una gerarchia tra le varie strutture dati in Java.

Metodi delle collezioni

int size();

boolean isEmpty();

boolean contains(Object element);

boolean add(E element);// Opzionale

boolean remove(Object element);// Opzionale

Iterator iterator();

boolean containsAll(Collection<?> c); //Collection<?> shortcut per Collection<? extends Object>

boolean addAll(Collection<? extends E> c);// Opzionale

boolean removeAll(Collection<?> c);// Opzionale

boolean retainAll(Collection<?> c);// Opzionale

void clear();// Opzionale

Set

Un Set rappresenta un insieme di oggetti privo di elementi duplicati. In generale, non conserve un ordinamento, tranne nel caso in cui si usi un SortedSet.

Alcune sue implementazioni sono HashSet, TreeSet, LinkedHashSet.

List

Una List rappresenta una sequenza di oggetti che può contenere duplicati.

Alcune implementazioni sono ArrayList, LinkedList, Vector.

Le operazioni basilari delle liste sono:

1. E get(int index);
2. E set(int index, E element);
3. boolean add(E element);
4. void add(int index, E element);
5. E remove(int index);
6. boolean addAll(int index, Collection<?extendsE> c);

7. int indexOf(Object o);
8. int lastIndexOf(Object o);

9. ListIterator<E> listIterator();
10. ListIterator<E> listIterator(int index);

Queue

Una Queue rappresenta una coda di oggetti che può contenere duplicati. Una sua implementazione è LinkedList.

Il sottotipo Deque rappresenta una cosa con entrambi gli estremi manipolabili (double ended queue).

Le operazioni sono:

• Inserimento —> add(e), offer(e)

• Rimozione —> remove(), poll()

• Esaminare —> element(), peek()

La prima lancia un’eccezione, la seconda ritorna un valore speciale in caso di errore.

Map

Una Map rappresenta un’associazione di valori a delle chiavi: non ammette duplicati, ma ammette valori nulli.

Alcune sue implementazioni sono HashMap, TreeMap, LinkedHashMap.

Le operazioni basilari sono:

1. V put(K key, V value);
2. V get(Object key);
3. V remove(Object key);
4. boolean containsKey(Object key);
5. boolean containsValue(Object value);
6. int size();
7. boolean isEmpty();

8. Set<K> keySet();
9. Collection<V> values();
10. Set<Map.Entry<K,V>> entrySet();

HashTable

Una HashTable è un'implementazione di una Map: non ammette valori nulli ed è sincronizzata.