Java lezione 2

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.

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

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

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” };

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

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

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];

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) {}

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;

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");

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");

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

Java lezione 2

More Related Content

What's hot (20)

More from Sergio Ronchi (20)

Java lezione 2