edutecnica
 


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.

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

Nella classe Vector viene creato un vettore caratterizzato da una dimension (size) e da una capacità (capacity).

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 cap
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);
}
}

 

 

edutecnica