Array, Vector, Stack et similia in Java
Quali sono le interfacce e le classi che Java offre per gestire collezioni di oggetti? Con questo articolo vediamo cosa utilizzare e come poterlo utilizzare.
Array
In Java abbiamo a disposizione gli array come in ogni altro linguaggio. Per definire un array di interi possiamo utilizzare il seguente codice
|
1 2 3 |
int[] array_di_interi=new int[5]; int altro_array_di_interi[]=new int[5]; String[] array_di_stringhe=new String[7]; |
Inizialmente questi array vengono creati vuoti. Per popolare un array e poi accedere ai suoi elementi dobbiamo utilizzare il nome dell’array specificando la posizione dell’elemento a cui siamo interessati (la posizione in questi array parte da 0). Ecco quindi un esempio di codice che utilizza gli array
|
1 2 3 4 5 6 7 8 9 10 11 12 |
int[] array_di_interi=new int[5]; array_di_interi[0]=34; array_di_interi[1]=65; array_di_interi[2]=24; array_di_interi[3]=16; array_di_interi[4]=19; //array_di_interi[5] non lo possiamo utilizzare perchè //abbiamo definito un array di 5 elementi e quindi andremmo //a inserire il sesto .... .... System.out.println("Il secondo elemento è "+array_di_interi[1]); |
Vector
In Java abbiamo a disposizione la classe Vector del package java.util che ci permette di poter gestire una serie di oggetti. La classe Vector rispetto all’array classico non ha il problema del sovradimensionamento, visto che quando aggiungiamo degli elementi l’oggetto gestisce automaticamente la sua dimensione (e nel caso aumenta la size). Il Vector hai dei metodi per poter aggiungere e recuperare oggetti, non tipi base. Vediamo come poter utilizzare questa classe
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
Vector vettore=new Vector(); String ciao=new String("Ciao"); Integer numero=new Integer(5); vettore.add(ciao); vettore.add(numero); .... .... for (int i=0;i<vettore.size();i++) System.out.println(vettore.elementAt(i)); .... .... //Rimuovo la stringa dal vettore vettore.remove(ciao); |
Enumeration e Iterator
Queste due interfacce definisco una serie di elementi, la quale può esserci restituita da altre classi Java. Per poter scorrerre questa serie di elementi abbiamo a disposizione due metodi principali, hasMoreElements() e next(). Il primo metodo serve per sapere se la collezione ha ancora degli elementi e la seconda invece restituisce il prossimo elemento. Ipotizzando quindi di avere un Enumeration ecco quindi come dovremmo fare per stampare il su contenuto a schermo
|
1 2 3 4 5 6 7 8 9 |
Enumeration e; Vector vettore=new Vector(); String ciao=new String("Ciao"); Integer numero=new Integer(5); vettore.add(ciao); vettore.add(numero); e=vettore.elements(); while(e.hasMoreElements()) System.out.println(e.next()); |
L’interfaccia Iterator ha dei metodi simili a Enumeration e in più ha un metodo, remove(), che serve a togliere l’elemento dalla collezione.
Map, HashMap e Hashtable
L’interfaccia Map in Java definisce un oggetto che memorizza una serie di oggetti, collegando ad ogni oggetto una chiave. Non possono esistere chiavi uguali, ma sicuramente possono esserci elementi uguali memorizzati all’interno del Map. Attraverso i metodi containsKey() e containsValue() possiamo avere informazioni sulla presenza o meno di chiavi e valori.
I metodi get(), put(), e remove() permettono rispettivamente di prendere, inserire e rimuovere un oggetto dal Map. Una classe che implementa questa interfaccia è Hashtable. Ecco di seguito un esempio di codice dove utilizziamo Hashtable
|
1 2 3 4 5 6 7 |
Hashtable hashtable=new Hashtable(); hashtable.put("primo",new String("cdkm")); hashtable.put("secondo",new String("cdlk")); hashtable.put("terzo",new String("cskscscsc")); …. …. System.out.println(hashtable.get("primo")); |
Esistono diverse classi all’interno del package java.util che implementano l’interfaccia Map ed ognuna ha una sua particolarità e un suo scopo. Ad esempio HashMap è la versione non sincronizzata di Hashtable.
Collection
Questa interfaccia rappresenta il punto di partenza per molti oggetti e interfacce le quali possiamo utilizzare per collezionare oggetti in Java. Dal punto di vista funzionale è un gruppo di elementi. I metodi che vengono definiti in questa interfaccia sono quelli che servono appunto per gestire una collezione. In molti casi dovremo utilizzare classi che implementano questa interfaccia o classi che ci restituiscono attraverso un loro metodo questa interfaccia quindi darci un’occhiata non può farci male.
Set e HashSet
L’interfaccia Set definisce che una classe che implementa questa interfaccia non conterrà al suo interno oggetti ripetuti. Ovvero a partire da un insieme più vasto di elementi (ad esempio una Collection), quando otteniamo il suo Set non avremo due oggetti uguali in questa collezione, mentre nel Collection poteva esserci. HashSet è un’implementazione non sincronizzata dell’interfaccia Set
List e ArrayList
Dall’interfaccia Collection deriva anche List, interfaccia che viene implementata da classi molto utilizzate come Vector e ArrayList. List a differenza di Set permette di avere oggetti duplicati e mantiene gli oggetti in un ordine stabilito (mentre per Set non c’era un ordine ma solo un insieme di oggetti). Vediamo quindi come utilizzare l’ArrayList
|
1 2 3 4 5 6 7 8 9 10 11 |
List lista = new ArrayList(); for (int i = 0; i < 5; i++) { lista.add(new Integer(i)); } …. …. ListIterator listIterator = lista.listIterator(); while (listIterator.hasNext()) { System.out.println(listIterator.next()); } |
Come potete vedere anche in questo caso, come abbiamo fatto precedentemente, otteniamo un Iterator (un ListIterator) dalla collezione ArrayList e ce lo scorriamo stampando a schermo tutti gli elementi.
Ricerca, ordinamento et similia
Esistono tante tipologie di ordinamenti e di utilità che possono essere definite su un insieme di elementi. Java per default ha una classe, Collections, che ha una serie di elementi statici che possiamo utilizzare nei nostri programmi. Vediamo ad esempio come poter ricercare degli oggetti all’interno di collezioni
|
1 2 3 4 5 6 7 8 |
List lista = new ArrayList(); lista.add(new String("Federico")); lista.add(new String("J2ME")); lista.add(new String("Goethe")); …. …. int posizione=Collections.binarySearch(lista,new String("J2ME")); System.out.println(lista.get(posizione)); |
In questo caso abbiamo utilizzato il metodo binarySearch(), il quale effettua una ricerca binaria sulla lista prendendo come chiave di ricerca un oggetto. Qui di seguito riportiamo altri metodi utili della classe Collections
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 |
List lista = new ArrayList(); lista.add(new String("Federico")); lista.add(new String("J2ME")); lista.add(new String("Goethe")); //Per copiare una lista dentro un’altra possiamo //utilizzare il metodo copy() List lista2=new ArrayList(); Collections.copy(lista2,lista); //Otteniamo l’elemento maggiore della lista, in base //alla natura dell’oggetto, con il metodo max() List lista3 = new ArrayList(); lista3.add(new Integer(34)); lista3.add(new String(23)); lista3.add(new String(69)); Integer massimo=(Integer)Collections.max(lista3); //Sostituiamo tutti gli elementi nella lista che sono uguali //ad un determinato oggetto con uno nuovo boolean result=Collections.replaceAll(lista,"J2ME","J2EE"); //Rigiriamo l’ordine della lista Collections.reverse(lista); //Ordiniamo la lista, in base all’ordine naturale degli //elementi che sono presenti Collections.sort(lista3); |
Come avete potuto vedere ci sono molti metodi interessanti nella classe Collections, che possono essere utilizzati nei nostri programmi.
Stack
L’ultima classe che andiamo a vedere è Stack, che praticamente estende la classe Vector e che ci permette di gestire una serie di oggetti proprio come in uno stack, ovvero con chiamate come pop() e push().
|
1 2 3 4 5 |
Stack stack = new Stack(); stack.push("Ciao"); stack.push("Bye"); System.out.println(stack.pop()); //Stampa Bye System.out.println(stack.pop()); //Stampa Ciao |
Conclusioni
Le API standard Java ci offrono molti modi per poter gestire insiemi di oggetti. Chiaramente di volta in volta, di programma in programma, dovremo utilizzare le classi più adatte ai nostri obiettivi. Inoltre a partire da queste classi possiamo costruire delle particolari collezioni che servono per il nostro programma (un array circolare ad esempio).
Per maggiori informazioni vi rimando all guida della SUN su JCF (Java Collection Framework)
che potete trovare al seguente indirizzo:
http://java.sun.com/j2se/1.4.2/docs/guide/collections/index.html
