Array dinamici

Abbiamo visto come la dichiarazione di un vettore in Java venga effettuato tramite una dichiarazione del tipo:
int A[] = new int[5];
questo significa che il vettore in questione potrà avere dimensione massima di 5 elementi. In fase di esecuzione non è possibile cambiare questa impostazione. Per avere un vettore dalla dimensione modificabile in fase di esecuzione, bisogna ricorrere a due classi del package java.util: la classe Vector e la classe ArrayList.

La classe Vector

E' possibile accedere solo agli elementi compresi fra l'indice 0 e size()-1. La differenza di spazio fra capacity e size è disponibile per l'inserimento di nuovi elementi (add) questo spazio disponibile può essere annullato tramite l'operazione trimToSize() (recuperando memoria) se invece serve, aumentare le dimensioni del vettore si può usare una chiamata ensureCapacity(0) che raddoppia la la dimensione della capacità del vettore; ma questa operazione avviene automaticamente.

Qui un esempio con un oggetto Vector:

import java.util.Vector;
class Vect{
public static void main (String args []){
     Vector T=new Vector(2);
     vista(T);
     T.addElement("uno");vista(T);
     T.addElement("due");vista(T);
     T.addElement("tre");vista(T);
     T.trimToSize();vista(T);
     T.insertElementAt("ins",1);vista(T);
     T.setElementAt("mod",1);vista(T);
     T.set(1,"mod2");vista(T);
     T.removeElementAt(1);vista(T);
}//fine main
static void vista(Vector T){
     for(int i=0;i < T.size();i++)System.out.print(T.elementAt(i)+" ");
     System.out.println("\nsize:"+T.size()+" capacity:"+T.capacity());
}//fine metodo vista
}//fine class Vect

Produce il seguente output:

size:0 capacity:2
uno
size:1 capacity:2
uno due
size:2 capacity:2
uno due tre
size:3 capacity:4
uno due tre
size:3 capacity:3
uno ins due tre
size:4 capacity:6
uno mod due tre
size:4 capacity:6
uno mod2 due tre
size:4 capacity:6
uno due tre
size:3 capacity:6

Noi abbiamo impostato la capacità iniziale a 2 elementi; da notare come trimToSize() taglia la capacità alla dimensione dell'ultimo elemento inserito e come la capacità si auto incrementa all'inserimento di un nuovo elemento se viene superata la capacità attuale.

tipo	metodo	operazione
void	insertElementAt(Object x,int i)	inserisce x all'indice i
void	addElement(Object x)	attacca x in fondo
void	clear()	elimina tutti gli elementi
boolean	contains(Object x)	se contiene x
void	ensureCapacity(int cap)	aumenta lo spazio di capacità
Object	elementAt(int i)	elemento di indice i
Object	firstElement()	il primo elemento
Object	lastElement()	l'ultimo elemento
int	indexOf(Object x)	il primo indice dell'elemento x, -1 se non esiste
boolean	isEmpty()	size()==0
int	lastIndexOf(Object x)	l'ultimo indice dell'elemento x, -1 se non esiste
Object	removeElementAt(int i)	rimuove l'i-esimo elemento
void	setElementAt(Object x, int i)	mette x all'indice i
void	setSize(int nuovaDimensione)	aumenta la dimensione
int	size()	numero di elementi
Object[]	toArray()	converte Vector in Array
void	trimToSize()	tosa il vettore alla dimensione dell'ultimo elemento inserito

La classe ArrayList

E' una versione migliorata della classe Vector, viene data meno importanza al concetto di capacity.

Qui un esempio con un'istanza dellla classe ArrayList:

import java.util.ArrayList;
class Array{
public static void main (String args []){
ArrayList A=new ArrayList(2);
vista(A);
A.add("uno");vista(A);
A.add("due");vista(A);
A.add("tre");vista(A);
A.trimToSize();vista(A);
A.add(1,"inserito");vista(A);
A.set(1,"modificato");vista(A);
A.remove(1);vista(A);
}//fine main
static void vista(ArrayList A){
for(int i=0;i < A.size();i++)System.out.print(A.get(i)+" ");
System.out.println("\nsize:"+A.size());
}//fine metodo vista
}//fine class Array

Produce il seguente output:

size:0
uno
size:1
uno due
size:2 uno due tre
size:3 uno due tre
size:3
uno inserito due tre
size:4
uno modificato due tre
size:4
uno due tre
size:3

L'elenco dei metodi della classe ArrayList è la seguente:

tipo	metodo	operazione
void	add(int i, Object x)	inserisce x all'indice i
boolean	add(Object x)	attacca x in fondo
void	clear()	elimina tutti gli elementi
Object	get(int i)	restituisce l'elemento all'indice i
int	indexOf(Object x)	il primo indice dell'elemento x, -1 se x non esiste
boolean	isEmpty()	size()==0 ?
int	lastIndexOf(Object x)	restituisce l'ultimo indice dell'elemento x, -1 se x non esiste
Object	remove(int i)	cancella l'i-esimo elemento
Object	set(int i, Object x)	mette x all'indice i
int	size()	numero di elementi
Object[]	toArray()	converte ArrayList in Array
void	trimToSize()	tosa il vettore alla dimensione dell'ultimo elemento inserito

La classe LinkedList

Una LinkedList può essere assimilata ad una coda doppia, cioè una struttura sequenziale in cui è possibile inserire ed estrarre i dati da entrambi i lati.

L'elenco dei principali metodi della classe LinkedList è la seguente:

tipo	metodo	operazione
void	clear()	Svuota la lista.
boolean	contains(Object x)	Verifica se la lista contiene l'oggetto specificato, usando il metodo standard equals (l'oggetto può occorrere più volte).
boolean	add(int i, Object x)	inserisce x all'indice i
boolean	add(Object x)	Inserisce un oggetto in fondo alla lista
boolean	remove(Object x)	Cancella la prima occorrenza dell'oggetto a partire dall'inizio della lista, che rimane inalterata se non contiene l'oggetto. Il metodo standard equals viene impiegato per trovare la prima occorrenza

Altri metodi utilizzabili sono riportati negli esempi seguenti:

//creazione di una lista e inserimento di oggetti nella stessa
import java.util.LinkedList; public class ll1 {
public static void main(String[] args){
LinkedList T = new LinkedList();
T.add("uno");
T.add("due");
T.add("tre");
T.add("quattro");
System.out.println(T);
System.out.println("Size: "+T.size());
System.out.println("vuota? "+T.isEmpty());
System.out.println("Contiene 'tre'? "+T.contains("tre"));
}
}

//duplicazione di un'istanza di oggetto linkedlist tramite
//l'uso della funzione clone()

import java.util.LinkedList;
public class ll2 {
public static void main(String[] args){
LinkedList T = new LinkedList();
T.add("primo");
T.add("secondo");
T.add("terzo");
T.add("quarto");
System.out.println("lista attuale:"+T);
LinkedList copy = (LinkedList) T.clone();
System.out.println("lista clonata:"+copy);
}
}

//lettura del primo elemento di una linkedlist
import java.util.LinkedList;
public class ll3 {
public static void main(String[] args){
LinkedList T = new LinkedList();
T.add("uno");
T.add("due");
T.add("tre");
System.out.println("primo elemento: "+T.element());
System.out.println("primo elemento: "+T.getFirst());
System.out.println("primo elemento: "+T.peek());
System.out.println("primo elemento: "+T.peekFirst());
}
}

//lettura dell'ultimo elemento di una linkedlist
import java.util.LinkedList;
public class ll4 {
public static void main(String[] args){
LinkedList T = new LinkedList();
T.add("uno");
T.add("due");
T.add("tre");
System.out.println("ultimo elemento: "+T.getLast());
System.out.println("ultimo elemento: "+T.peekLast());
}
}

//inserimento di un elemento in testa alla lista
import java.util.LinkedList;
public class ll5 {
public static void main(String[] args){
LinkedList T = new LinkedList();
T.add("uno");
T.add("due");
T.add("tre");
System.out.println(T);
System.out.println("inserimento in testa");
T.addFirst("primo");
System.out.println(T);
System.out.println("inserimento in testa");
T.offerFirst("primo2");
System.out.println(T);
}
}

//inserimento di un elemento in coda alla linkedlist

import java.util.LinkedList; public class ll6 {
public static void main(String a[]){
LinkedList T = new LinkedList();
T.add("uno");
T.add("due");
T.add("tre");
System.out.println(T);
System.out.println("inserimento in coda");
T.addLast("ultimo");
System.out.println(T);
System.out.println("inserimento in coda");
T.offerLast("ultimo1");
System.out.println(T);
System.out.println("inserimento in coda ");
T.offer("ultimo2");
System.out.println(T);
}
}

//vari metodi per la rimozione di elementi da una linkedlist

import java.util.LinkedList;
public class ll7 {
public static void main(String[] args){
LinkedList T = new LinkedList();
T.add("uno");
T.add("due");
T.add("tre");
T.add("quattro");
T.add("cinque");
T.add("sei");
T.add("sette");
System.out.println(T);
System.out.println("chiamata remove():"+T.remove());
System.out.println("dopo remove():");
System.out.println(T);
System.out.println("chiamata remove(index):"+T.remove(2));
System.out.println("dopo remove(index):"); System.out.println(T);
System.out.println("chiamata remove(object):"+T.remove("tre"));
System.out.println("dopo remove(object):"); System.out.println(T);
System.out.println("chiamata removeFirst():"+T.removeFirst());
System.out.println("dopo removeFirst():"); System.out.println(T);
System.out.println("chiamata removeLast():"+T.removeLast());
System.out.println("dopo removeLast():"); System.out.println(T);
}
}