2. Vector
permette di implementare un array di oggetti di dimensioni variabili: tale
array ha una dimensione iniziale impostabile e cresce in caso di necessità
in base a capacityIncrement
alcuni metodi:
Vector v=new Vector();
v.addElement(“uno”);
v.addElement(“due”);
v.insertElement(“opp”,1);
Enumeration e=v.elements();
while (e.hasMoreElements())
System.out.println(e.nextElement());
Iterator it=v.iterator()
while(it.hasNext())
System.out.println(it.next());
int somma=0;
it=v.iterator();
while (it.hasNext())
{ String s=(String)it.next();
somma+=s.length();}
sincronizzata
3. Stack
E’ una sottoclasse di Vector
permette di implementare una pila (LIFO)
alcuni metodi:
s.push(“uno”); //inserimento
obj=s.pop(); //ritorna ed estrae un oggetto
obj=s.peek(); //ritorna senza estrarre
vuoto=s.empty() //boolean true se pila vuota
trovato=s.search(obj); //boolean true se presente
4. ArrayList
Si tratta di una lista il cui uso è simile a quello della classe
Vector.
La differenza fondamentale è che in questo caso non è
SINCRONIZZATA, questo da un lato la rende più veloce, ma
dall’altro causa probabili erroni nel caso in cui due o più thread
vadano a leggere e modificare il suo contenuto
5. LinkedList
Si tratta di una lista doppiamente collegata di oggetti, che possono anche
essere duplicati:
public class ListApp {
public static void main(String args[]){
LinkedList list = new LinkedList();
list.add("is"); list.add("is"); list.add("a"); list.add("a");
list.addLast("test");
list.addFirst("This");
displayList(list);
}
static void displayList(LinkedList list) {
ListIterator i = list.listIterator(0);
while(i.hasNext())
{ Object o = i.next();
System.out.println(o.toString());}
}
}
6. Hashtable (SINCRONIZZATA)
la tabella di Hash è un insieme di oggetti identificati tramite i
codici di Hash. Tali valori sono calcolati in modo di
massimizzare la probabilità che per oggetti diversi siano diversi.
In java tutte le classi possiedono il metodo hashCode().
Quando si crea una Hashtable è possibile specificare la
capacità iniziale e il fattore di carico (tra 0 e 1): ad esempio con
fattore di carico 70% accade che se la tabella si popola ed il
carico arriva al 70% la tabella viene ricreata con dimensioni
doppie.
In pratica comunque è possibile memorizzare degli oggetti
come coppie chiave-valore, come si può vedere nell’esempio
seguente:
7. Esempio Hashtable
Hashtable h = new Hashtable();
h.put("height","6 feet");
h.put("weight","200 pounds");
h.put("eye color","blue");
h.put("hair color","brown");
System.out.println("h: "+h);
Enumeration enum = h.keys();
System.out.print("keys: ");
while (enum.hasMoreElements()) System.out.print(enum.nextElement()+", ");
System.out.print("nelements: ");
enum = h.elements();
while (enum.hasMoreElements()) System.out.print(enum.nextElement()+", ");
System.out.println("height: "+h.get("height"));
System.out.println("weight: "+h.get("weight"));
System.out.println("eyes: "+h.get("eye color"));
System.out.println("hair: "+h.get("hair color"));
9. Properties
La classe Properties è una sottoclasse di Hashtable.
Dispone di metodi specifici per leggere o scrivere dei file di testo
strutturati in questo formato:
Jdbc.drivers = sun.jdbc.odbc.JdbcOdbcDriver
La lettura viene fatta così:
Properties props = new Properties();
FileInputStream in = new FileInputStream(“database.properties”);
props.load(in);
String drivers = props.getProperty("jdbc.drivers");
La scrittura invece:
FileOutputStream out = new FileOutputStream(“database.properties”);
Props.setProperty(“jdbc.url”,”idbc:odbc:dati”);
props.store(out,”Database”);
10. HashSet
Si tratta di una lista di oggetti non ordinati, che non possono essere duplicati:
public class SetApp {
public static void main(String args[]){
HashSet set = new HashSet();
set.add("This"); set.add("is"); set.add("is"); set.add("a"); set.add("a");
set.add("test");
displaySet(set);
}
static void displaySet(HashSet set) {
System.out.println("The size of the set is: "+set.size());
Iterator i = set.iterator();
while(i.hasNext()){
Object o = i.next();
System.out.println(o.toString());
}
}
}
11. HashMap (chiave-valore)
Si tratta di una lista di oggetti non ordinati, identificati da una chiave.
L’utilizzo è simile a quello dell’HashTable, in questo caso però non si ha
la sincronizzazione nel caso di Thread multipli che agiscono in
concorrenza sugli stessi dati.
12. TreeMap
Si tratta di una albero binario di coppie chiave-valore ordinati. L’ordinamento
avviene sulla chiave:
public class MapApp {
public static void main(String args[]){
TreeMap map = new TreeMap();
map.put("one","1"); map.put("two","2"); map.put("three","3"); map.put("four","4");
map.put("five","5");
map.put("six","6");
displayMap(map);
}
static void displayMap(TreeMap map) {
System.out.println("The size of the map is: "+map.size());
Collection c = map.entrySet();
Iterator i = c.iterator();
while(i.hasNext()){
Object o = i.next();
System.out.println(o.toString());
}
}
13. TreeSet
Si tratta di un albero binario di oggetti ordinati: non è possibile inserire
due volete lo stesso oggetto e neppure valori NULL.
A differenza del TreeMap, non essendoci la chiave, l’ordinamento
avviene sul valore.
14. Schema riassuntivo
Sincronizzati
Non Sincr. ArrayList LinkedList HashSet TreeSet HashMap TreeMap
SortedSet SortedMap
Hashtable -> PropertiesVector -> Stack
Collection
List MapSet
-blu: interfacce; Rosso: alberi binari;
-non sono mostrate le classi astratte che sono estese dalle strutture
dati indicate, per la precisione:
-AbstractCollection ->(AbstractList,AbstractSet);
-AbstractList ->(AbstractSequentialList,Vector,ArrayList);
-AbstractMap->(HashMap, TreeMap);
-AbstractSet->(HashSet,TreeSet)
-AbstractSequentialList->(LinkedList)
-Hashtable estende invece una classe obsoleta Dictionary
15. Properties
E’ una sottoclasse di Hashtable che ha la caratteristica di essere letta e scritta
attraverso un flusso. Esistono due appositi metodi load() e store() per caricare o
salvare un oggetto Properties.
In questo semplice esempio vengono caricare e visualizzate le proprietà di
sistema:
public static void main(String args[]){
Properties sysProp = System.getProperties();
sysProp.list(System.out);
}
Oppure è possibile leggere da un file
Properties p=new Properties();
FileInputStream in=new FileInputStream(“database.properties”);
p.load(in);
Potendo poi fare:
String url=p.getProperty(“jdbc.url”);
16. Ordinamento e conversione
Le classi Arrays e Collections includono alcuni metodi statici per operare
sulle collezioni.
Arrays.sort(xxx) è in grado di ordinare sia array che oggetti come liste.
List lst=Arrays.asList(array); converte in una lista un array
Esistono metodi
per la ricerca binaria: binarySearch(xxx)
per riepire una lista: fill(xxx)
per confrontare: equals(xxx)
17. BitSet
permette di memorizzare una sequenza di bit
BitSet b1=new BitSet(8); //crea un bitset di 8 bit
alcuni metodi
b1.set(0); //setta il primo bit (pone a true)
b1.clear(3); //azzera il 4° bit (false)
BitSet b2=(BitSet) b1.clone(); //crea una copia
b1.xor(b2); //realizza b1= b1 xor b2;
esistono anche i metodi and, or, andNot, inoltre si ha il metodo
equals per eseguire dei confronti.
18. StringTokenizer
E’ una classe molto utile per elaborare le stringhe:
Ad esempio avendo una stringa di questo tipo:
String s=“uno due tre quattro”;
StringTokenizer st=new StringTokenizer(s);
while(st.hasMoreTokens())
{ String token=st.nextToken();
System.out.println(token);}
Permette di separare i vari elementi che costituiscono la stringa. Come separatore è
possibile anche usare caratteri differenti, ad esempio
String s=“uno,due ; tre : quattro”;
StringTokenizer st=new StringTokenizer(s,” ,;:”);
Dove, come secondo parametro si elencano tutti i separatori validi.
Dalla versione 1.4 di java è disponibile anche un metodo della classe String
denominato split() che permette di ottenere un risultato simile. Il metodo split() ritorna
un array di stringhe, quindi non sarà in quel caso scorrerlo con nextToken().
