Java array, algoritmi sugli array

1. Array
Gli array in java vengono gestiti in modo simile al C, anche se vi
sono alcune differenze, prima tra tutte il fatto che non esiste la
similitudine tra array e puntatori.

2. Dichiarazione e definizione
Gli array in java vengono dichiarati utilizzando la seguente notazione:
int tab[]=new int[10];
In tal modo viene creato un array di 10 elementi interi inizializzati a 0.
E’ anche possibile scindere la dichiarazione dalla definizione;
int tab[];
int k=10;
tab=new int[k];
Questo è utile soprattutto se non si conosce inizialmente la dimensione di
un array.
E’ anche possibile definire un array mediante inizializzazione:
int v[]={4,3,45,2,7,5,21,2,1,4};

3. Riferimenti e indici
Gli array in java hanno indici che iniziano da 0, inoltre possiedono una
proprietà che consente di determinare la loro dimensione:
tab.length
Si noti che length non è un metodo, come lo era per la classe String in
quanto un array non è una classe.
Per riferirsi ad un elemento all’interno di un array si utilizza un indice posto
all’interno di parentesi quadre, l’esempio seguente stampa un array.
for (k=0;k<tab.length;k++)
{System.out.print(tab[k]+",");}
-Se viene superato il limite di un array viene generata l’eccezione:
- ArrayIndexOutOfBound

4. Array di classi
Un array può contenere qualsiasi tipo di dati, ad esempio vediamo un
array di stringhe:
String elenco[]=new String[10];
In questo caso ogni elemento dell’array è un oggetto con tutte le relative
proprietà e metodi e dovrà essere istanziato.
Inizialmente un array di stringhe conterrà tutte stringhe null che potranno
poi essere inizializzate:
elenco[0]=“Pippo”;
Nel caso delle Stringhe è possibile creare istanze semplicemente con un
operazione di assegnamento. Oppure inizializzando l’array:
String elenco[]= {“Paolo”,”Nadia”,Roberto”,”Silvia” };

5. Esempio SelectionSort
public class SelectionSort
{ public static void main(String args[])
{int v[]={4,3,45,2,7,5,21,2,1,4};
int min=0;
int i,j,k;
int posmin=0;
for (i=0;i<v.length-1;i++)
{ posmin=i;
for (j=i+1;j<v.length;j++)
{ if (v[j]<v[posmin])
{ posmin=j;}
}
min=v[posmin];
v[posmin]=v[i];
v[i]=min;
}
}
}

6. Esempio BubbleSort
for (i=0;i<lung;i++)
{
for(j=0;j<lung-1;j++)
if(array[j]>array[j+1])
{
swap=array[j];
array[j]=array[j+1];
array[j+1]=swap;
}
}

7. Copia di array
Per copiare un array è necessario effettuare una copia elemento per
elemento.
Infatti la sequenza di istruzioni:
int tab[]={10,2,3};
int p[]=new int[3];
p=tab;
System.out.println(p[0]);
tab[0]=21;
System.out.println(p[0]);
Dimostra che tab e p non sono due array contenenti gli stessi valori, ma lo
stesso array con due nomi diversi.
Praticamente p=tab determina l’uguaglianza dei puntatori.
(Lo stesso concetto varrà per gli oggetti)
Per fare una copia si deve copiare elemento per elemento:
for(i=0;i<tab.length;i++) p[i]=tab[i];

8. Input da tastiera
Fino ad ora non abbiamo mai letto l’input da tastiera. Ora avendo introdotto gli
array possiamo utilizzare un primo metodo per farlo.
byte vect[]=new byte[100];
int lung;
System.out.print("Inserisci una frase: ");
lung=System.in.read(vect);
String str=new String(vect);
Questo tuttavia crea un errore in compilazione perché ogni input potrebbe
potenzialmente generare un’eccezione.
Per provare il codice utilizziamo un blocco try cath che tuttavia spiegheremo
meglio in seguito.
try
{
…….
}
catch(Exception e) {}

9. Array pluridemensionali
Un array può essere pluridimensionale
char matrix[][] =new char[8][10];
E’ anche possibile definire un array bidimensionale così:
char matrix[][] =new char[8][];
char matrix0[]={' ',' ',' ','*','*','*',' ',' '};
char matrix1[]={' ',' ','*',' ',' ',' ','*',' '};
char matrix2[]={' ',' ','*',' ',' ',' ','*',' '};
char matrix3[]={' ',' ','*',' ',' ',' ','*',' '};
char matrix4[]={' ',' ','*','*','*','*','*',' '};
char matrix5[]={' ',' ','*',' ',' ',' ','*',' '};
char matrix6[]={' ',' ','*',' ',' ',' ','*',' '};
char matrix7[]={' ',' ','*',' ',' ',' ','*',' '};
matrix[0]=matrix0;
matrix[1]=matrix1;
matrix[2]=matrix2;
matrix[3]=matrix3;
matrix[4]=matrix4;
matrix[5]=matrix5;
matrix[6]=matrix6;
matrix[7]=matrix7;

10. Ricerca con TAPPO
int v[]={3,4,1,45,5,3,6,-1}; //Attenzione -1 è il TAPPO
int i;
int lung=v.length;
v[lung-1]=num; //IL TAPPO
i=0;
while(v[i++]!=num);
if (i<lung-1) System.out.println("TROVATO");
else System.out.println("NON TROVATO");

11. Ricerca binaria
(per array ordinati)
int v[]={1,3,5,7,12,45,56,76,89,120,345,367};
int ini=0;
int fine=v.length-1;
int mid=0;
if (args.length>0)
{ int num = Integer.parseInt(args[0]);
while(ini<fine)
{ mid=ini+((fine-ini)>>1);
if (v[mid]==num) break;
if (v[mid]>num) fine=mid-1;
else ini=mid+1;
}
if (v[mid]==num || v[ini]==num)
System.out.println("TROVATO");
else
System.out.println("NON TROVATO");

12. Una classe di utility per gli
Array
Esiste una classe del package java.util che mette a disposizione
numerosi metodi statici per gli array.
Si tratta della classe Arrays.
Avendo cura di importare il package:
import java.util.*;
È possibile ordinare un array di qualsiasi tipo (algoritmo quicksort):
Arrays.sort(tab);
Confrontare due array
boolean e=Arrays.equals(tab1,tab2);
Riempire un array
Arrays.fill(tab,0); //riempie di zeri
Arrays.fill(tab,0,da,a) //riempie dalla posizione da alla posizione a
Eseguire una ricerca binaria
int pos=Arrays.binarySearch(tab,0); //ritorna la prima occorrenza dello
zero