Array. C. Horstmann Fondamenti di programmazione e Java 2 3^ edizione Apogeo

Transcript

1 Array C. Horstmann Fondamenti di programmazione e Java 2 3^ edizione Apogeo trad. Nicola Fanizzi corso di Programmazione, CdS: Informatica TPS Dip. di Informatica, Università degli studi di Bari

2 Obiettivi 2 Prender familiarità con l'uso di array e array-list Conoscere le classi involucro, l'auto-boxing e il ciclo for generalizzato Studiare gli algoritmi di base su array Imparare l'uso di array bidimensionali Imparare quando scegliere gli array-list e quando gli array nei propri programmi Implementare array riempiti parzialmente

3 Array 3 Array: : Sequenza di valori dello stesso tipo Costruire un array: new double[10] Immagazzinare dati in una variabile di tipo double[] double[] data = new double[10];

4 Array 4 Quando si crea un array, tutti i valori sono inizializzati a seconda del tipo di array: numeri: 0 boolean: false Riferimenti ad oggetti: null

5 Array 5 Array e Riferimento ad Array

6 Array 6 Si usa l'operatore [ ] per accedere ad un elemento data[2] = 29.95; Figure 2: Storing a Value in an Array

7 Array 7 Uso del valore immagazzinato: System.out.println("The value of this data item is " + data[4]); Si ottiene la lunghezza dell'array con data.length (NB: non è un metodo!) I valori degli indici vanno da 0 a length - 1

8 Array 8 L'accesso ad un elemento non esistente provoca un errore di limiti double[] data = new double[10]; data[10] = 29.95; // ERRORE Limitazione: gli array hanno lunghezza fissata

9 Sintassi 8.1: Costruzione di Array 9 new typename[length length] Esempio: new double[10] Scopo: Costruire un array di un dato numero di elementi

10 Sintassi 8.2: Accesso ad un 10 Elemento di un Array arrayreference[index index] Esempio: data[2] Scopo: : Accedere ad un elemento in un array

11 Array List 11 La classe ArrayList gestisce una sequenza di oggetti Può crescere e restringersi secondo le necessità La classe ArrayList fornisce metodi per molti compiti comuni come l'inserimento e la rimozione di elementi

12 Array List 12 La classe ArrayList è generica: ArrayList<T> raccoglie oggetti di tipo T: ArrayList<BankAccount> accounts = new ArrayList<BankAccount>(); accounts.add(new BankAccount(1001)); accounts.add(new BankAccount(1015)); accounts.add(new BankAccount(1022)); Il metodo size() restituisce il numero di elementi

13 Ritrovamento di Elementi in 13 Si usa il metodo get L'indice comincia da 0 Array List BankAccount anaccount = accounts.get(2); // ottiene il terzo elemento dell'array list Errore di limiti se l'indice è fuori dell'intervallo

14 Ritrovamento di Elementi in 14 Array List Errori di limiti più comuni: int i = accounts.size(); anaccount = accounts.get(i); // Errore // valori leciti per gli indici: 0...i-1

15 Aggiunta di Elementi 15 set sovrascrive un valore esistente: BankAccount anaccount = new BankAccount(1729); accounts.set(2, anaccount); add aggiunge un nuovo valore nella posizione precedente all'indice indicato accounts.add(i, a)

16 Aggiunta di Elementi 16 Figure 3: Adding an Element in the Middle of an Array List

17 Cancellazione di Elementi 17 remove removes an element at an index Accounts.remove(i)

18 Cancellazione di Elementi 18 Figure 4: Removing an Element in the Middle of an Array List

19 ArrayListTester.java 19 01: import java.util.arraylist; 02: 03: /** 04: Programma che testa la classe ArrayList. 05: */ 06: public class ArrayListTester 07: { 08: public static void main(string[] args) 09: { 10: ArrayList<BankAccount> accounts 11: = new ArrayList<BankAccount>(); 12: accounts.add(new BankAccount(1001)); 13: accounts.add(new BankAccount(1015)); 14: accounts.add(new BankAccount(1729)); 15: accounts.add(1, new BankAccount(1008)); 16: accounts.remove(0);

20 ArrayListTester.java 20 17: 18: System.out.println("size=" + accounts.size()); 19: BankAccount first = accounts.get(0); 20: System.out.println("first account number=" 21: + first.getaccountnumber()); 22: BankAccount last = accounts.get(accounts.size() - 1); 23: System.out.println("last account number=" 24: + last.getaccountnumber()); 25: } 26: }

21 BankAccount.java 21 01: /** 02: Un conto corrente ha un saldo che può essere cambiato da 03: depositi e prelievi. 04: */ 05: public class BankAccount 06: { 07: /** 08: Costruisce un conto con saldo zero anaccountnumber il numero di questo conto 10: */ 11: public BankAccount(int anaccountnumber) 12: { 13: accountnumber = anaccountnumber; 14: balance = 0; 15: } 16:

22 BankAccount.java 22 17: /** 18: Costruisce un conto con un dato saldo iniziale anaccountnumber il numero del conto initialbalance il saldo iniziale 21: */ 22: public BankAccount (int anaccountnumber, double initialbalance) 23: { 24: accountnumber = anaccountnumber; 25: balance = initialbalance; 26: } 27: 28: /** 29: ottiene il numero di questo conto corrente. numero di conto 31: */ 32: public int getaccountnumber() 33: { 34: return accountnumber; 35: }

23 BankAccount.java 23 36: 37: /** 38: Deposita denaro sul conto. amount l'ammontare del deposito 40: */ 41: public void deposit(double amount) 42: { 43: double newbalance = balance + amount; 44: balance = newbalance; 45: } 46: 47: /** 48: Preleva denaro dal conto. amount ammontare del prelievo 50: */ 51: public void withdraw(double amount) 52: { 53: double newbalance = balance - amount; 54: balance = newbalance;

24 BankAccount.java 24 55: } 56: 57: /** 58: Ottiene il saldo corrente del conto. il saldo corrente 60: */ 61: public double getbalance() 62: { 63: return balance; 64: } 65: 66: private int accountnumber; 67: private double balance; 68: } Output: size=3 first account number=1008 last account number=1729

25 Wrapper 25 Non si possono inserire tipi primitivi direttamente nelle array list Per trattare i valori di tipi primitivi come oggetti, si usano le classi involucro (wrapper): ArrayList<Double> data = new ArrayList<Double>(); data.add(29.95); double x = data.get(0);

26 Wrapper 26 Figure 5: An Object of a Wrapper Class

27 Wrapper 27 Ci sono classi involucro per tutti gli otto tipi primitivi:

28 Auto-boxing 28 Auto-boxing: : da Java 5.0, la conversione tra tipi primitivi e classi involucro corrispondenti è automatica Double d = 29.95; // auto-boxing: analogo a Double d = new Double(29.95); double x = d; // auto-unboxing: analogo a double x = d.doublevalue();

29 Auto-boxing 29 L'auto-boxing funziona anche all'interno di espressioni aritmetiche: Double e = d + 1; significa: Fai l'auto-unbox di d in un double Aggiungi 1 Fai l'auto-box del risultato in un nuovo Double Immagazzina in e un riferimento all'oggetto involucro appena creato

30 Ciclo for Generalizzato 30 Cicla su tutti gli elementi di una collezione: double[] data =...; double sum = 0; for (double e : data) // da leggersi: "per ogni e in data" { sum = sum + e; }

31 Ciclo for Generalizzato 31 Alternativa tradizionale: double[] data =...;. double sum = 0; for (int i = 0; i < data.length; i++) { double e = data[i]; sum = sum + e; }

32 Ciclo for Generalizzato 32 Funziona anche per le ArrayLists: ArrayList<BankAccount> accounts =... ; double sum = 0; for (BankAccount a : accounts) { sum = sum + a.getbalance(); }

33 Ciclo for Generalizzato 33 Equivalente al seguente ciclo for normale: double sum = 0; for (int i = 0; i < accounts.size(); i++) { BankAccount a = accounts.get(i); sum = sum + a.getbalance(); }

34 Sintassi 8.3: Ciclo "Per Ogni" 34 for (Type variable : collection) statement Esempio: for (double e : data) sum = sum + e; Scopo: : eseguire un iterazione per ogni elemento della collezione. Ad ogni iterata, viene assegnato alla variabile il prossimo elemento della collezione per poi eseguire l'istruzione

35 Algoritmi Semplici su Array: 35 Conteggio delle Corrispodenze Controllare tutti gli elementi e contare le corrispondenze fino alla fine dell'array-list public class Bank { public int count(double atleast) { int matches = 0; for (BankAccount a : accounts) { if (a.getbalance() >= atleast) matches++; } // trovata una corrispondenza } return matches; }... private ArrayList<BankAccount> accounts;

36 Algoritmi Semplici su Array: 36 Trovare un Valore Controllare tutti gli elementi fino a trovare una corrispondenza: public class Bank { public BankAccount find(int accountnumber) } { }... for (BankAccount a : accounts) { if (a.getaccountnumber() == accountnumber) return a; // corrispondenza trovata } return null; // nessuna corrispondenza in tutto array list

37 Algoritmi Semplici su Array: 37 Trovare il Massimo/Minimo Inizializzare un candidato con l'elemento iniziale Confrontare il candidato con i restanti elementi Aggiornare se si trova un valore più grande/piccolo

38 Algoritmi Semplici su Array: 38 Esempio: Trovare il Massimo/Minimo BankAccount largestyet = accounts.get(0); for (int i = 1; i < accounts.size(); i++) { BankAccount a = accounts.get(i); if (a.getbalance() > largestyet.getbalance()) largestyet = a; } return largestyet;

39 Algoritmi Semplici su Array: 39 Trovare il Massimo/Minimo Funziona solo se c'è almeno un elemento nell'array list Se list è vuoto, restituisce null if (accounts.size() == 0) return null; BankAccount largestyet = accounts.get(0);...

40 Bank.java 40 01: import java.util.arraylist; 02: 03: /** 04: Questa banca contiene una collezione di conti correnti 05: */ 06: public class Bank 07: { 08: /** 09: Constructs a bank with no bank accounts. 10: */ 11: public Bank() 12: { 13: accounts = new ArrayList<BankAccount>(); 14: } 15: 16: /** 17: aggiunge un conto alla banca. a conto da aggiungere 19: */

41 Bank.java 41 20: public void addaccount(bankaccount a) 21: { 22: accounts.add(a); 23: } 24: 25: /** 26: ritorna la somma dei saldi dei conti della banca somma dei saldi 28: */ 29: public double gettotalbalance() 30: { 31: double total = 0; 32: for (BankAccount a : accounts) 33: { 34: total = total + a.getbalance(); 35: } 36: return total; 37: } 38:

42 Bank.java 42 39: /** 40: conta il numero dei conti il cui saldo sia pari 41: almeno ad un dato valore. atleast saldo minimo numero dei conti che hanno almeno un saldo // pari al valore dato 44: */ 45: public int count(double atleast) 46: { 47: int matches = 0; 48: for (BankAccount a : accounts) 49: { 50: if (a.getbalance() >= atleast) matches++; // trovato 51: } 52: return matches; 53: } 54:

43 Bank.java 43 55: /** 56: trova un conto con un dato numero. accountnumber numero da trovare il conto del dato numero, oppure null 59: se non è presente quel conto 60: */ 61: public BankAccount find(int accountnumber) 62: { 63: for (BankAccount a : accounts) 64: { 65: if (a.getaccountnumber() == accountnumber) // trovato 66: return a; 67: } 68: return null; // trovato nessun conto con quel numero 69: } 70:

44 Bank.java 44 71: /** 72: restituisce il conto con il saldo maggiore il conto con il saldo maggiore, oppure 74: null se la banca non ha conti aperti 75: */ 76: public BankAccount getmaximum() 77: { 78: if (accounts.size() == 0) return null; 79: BankAccount largestyet = accounts.get(0); 80: for (int i = 1; i < accounts.size(); i++) 81: { 82: BankAccount a = accounts.get(i); 83: if (a.getbalance() > largestyet.getbalance()) 84: largestyet = a; 85: } 86: return largestyet; 87: } 88: 89: private ArrayList<BankAccount> accounts; 90: }

45 BankTester.java 45 01: /** 02: Programma di test per la classe Bank. 03: */ 04: public class BankTester 05: { 06: public static void main(string[] args) 07: { 08: Bank firstbankofjava = new Bank(); 09: firstbankofjava.addaccount (new BankAccount(1001, 20000)); 10: firstbankofjava.addaccount (new BankAccount(1015, 10000)); 11: firstbankofjava.addaccount (new BankAccount(1729, 15000)); 12: 13: double threshold = 15000; 14: int c = firstbankofjava.count(threshold); 15: System.out.println (c + " accounts with balance >= " + threshold);

46 BankTester.java 46 16: 17: int accountnumber = 1015; 18: BankAccount a = firstbankofjava.find(accountnumber); 19: if (a == null) 20: System.out.println ("No account with number " + accountnumber); 21: else 22: System.out.println ("Account with number " + accountnumber 23: + " has balance " + a.getbalance()); 24: 25: BankAccount max = firstbankofjava.getmaximum(); 26: System.out.println("Account with number " 27: + max.getaccountnumber() 28: + " has the largest balance."); 29: } 30: }

47 BankTester.java 47 Output 2 accounts with balance >= Account with number 1015 has balance Account with number 1001 has the largest balance.

48 Array Bidimensionali 48 Nel costruire un array bidimensionale, si specifica di quante righe e colonne si ha bisogno: final int ROWS = 3; final int COLUMNS = 3; String[][] board = new String[ROWS][COLUMNS]; Si ha accesso agli elementi con una coppia di indici a[i][j]: board[i][j] = "x";

49 Tavola per il Filetto 49 Figure 6: A Tic-Tac-Toe Board

50 Attraversamento 50 di Array Bidimensionali È tipico usare due cicli nidificati nel riempimento o la ricerca: for (int i = 0; i < ROWS; i++) for (int j = 0; j < COLUMNS; j++) board[i][j] = " ";

51 TicTacToe.java 51 01: /** 02: Una tavola di Filetto 3 x 3. 03: */ 04: public class TicTacToe 05: { 06: /** 07: Costruisce la tavola vuota. 08: */ 09: public TicTacToe() 10: { 11: board = new String[ROWS][COLUMNS]; 12: // riempie con spazi 13: for (int i = 0; i < ROWS; i++) 14: for (int j = 0; j < COLUMNS; j++) 15: board[i][j] = " "; 16: } 17:

52 TicTacToe.java 52 18: /** 19: Imposta una casella (non deve essere occupata) i indice della riga j indice della colonna player il giocatore ("x" oppure "o") 23: */ 24: public void set(int i, int j, String player) 25: { 26: if (board[i][j].equals(" ")) 27: board[i][j] = player; 28: } 29: 30: /** 31: Crea una rappresentazione della tavola in forma di stringa come ad es.: 32: x o 33: x 34: o la rappresentazione in forma di stringa 36: */

53 TicTacToe.java 53 37: public String tostring() 38: { 39: String r = ""; 40: for (int i = 0; i < ROWS; i++) 41: { 42: r = r + " "; 43: for (int j = 0; j < COLUMNS; j++) 44: r = r + board[i][j]; 45: r = r + " \n"; 46: } 47: return r; 48: } 49: 50: private String[][] board; 51: private static final int ROWS = 3; 52: private static final int COLUMNS = 3; 53: }

54 TicTacToeTester.java 54 01: import java.util.scanner; 02: 03: /** 04: Programma di test della classe TicTacToe 05: che chiede all'utente di impostare le posizioni 06: sulla tavola e stampa il risultato. 07: */ 08: public class TicTacToeTester 09: { 10: public static void main(string[] args) 11: { 12: Scanner in = new Scanner(System.in); 13: String player = "x"; 14: TicTacToe game = new TicTacToe(); 15: boolean done = false; 16: while (!done) 17: {

55 TicTacToeTester.java 55 18: System.out.print(game.toString()); 19: System.out.print( 20: "Row for " + player + " (-1 to exit): "); 21: int row = in.nextint(); 22: if (row < 0) done = true; 23: else 24: { 25: System.out.print ("Column for " + player + ": "); 26: int column = in.nextint(); 27: game.set(row, column, player); 28: if (player.equals("x")) 29: player = "o"; 30: else 31: player = "x"; 32: } 33: } 34: } 35: }

56 Output 56 Row for x (-1 to exit): 1 Column for x: 2 x Row for o (-1 to exit): 0 Column for o: 0 o x Row for x (-1 to exit): -1

57 Copiare Array: 57 Copiare i Riferimenti Copiare una variabile array comporta un secondo riferimento allo stesso (oggetto) array double[] data = new double[10]; // riempie l'array... double[] prices = data;

58 Copiare Array: 58 Copiare i Riferimenti Figure 7: Two References to the Same Array

59 Copiare Array: 59 Clonare gli Array Si usa il metodo clone per farne una vera copia double[] prices = (double[]) data.clone();

60 Copiare Array: 60 Clonare gli Array Figure 8: Cloning an Array

61 Copiare Array: 61 Copiare Elementi di Array System.arraycopy(from, fromstart, to, tostart, count);

62 Copiare Array: 62 Copiare Elementi di Array Figure 9: The System.arraycopy Method

63 Aggiungere Elementi ad Array 63 System.arraycopy (data, i, data, i + 1, data.length - i - 1); data[i] = x;

64 Aggiungere Elementi ad Array 64 Figure 10: Inserting a New Element Into an Array

65 Eliminare un Elemento 65 System.arraycopy(data, i + 1, data, i, data.length - i - 1);

66 Rimuovere Elementi da Array 66 Figure 11 Removing an Element from an Array

67 Ampliare un Array 67 Se l'array è pieno e si ha bisogno di più spazio è possibile ampliare l'array: Creare un nuovo array più grande double[] newdata = new double[2 * data.length]; Copiare tutti gli elementi nel nuovo array System.arraycopy(data, 0, newdata, 0, data.length); Immagazzinare il riferimento al nuovo array nella precedente variabile array data = newdata;

68 Ampliare un Array 68 Figure 12: Growing an Array

69 Creare Array Paralleli 69 in Array di Oggetti // Da NON fare int[] accountnumbers; double[] balances; Figure 13: Avoid Parallel Arrays

70 Creare Array Paralleli 70 in Array di Oggetti Evitare l'uso di array paralleli trasformandoli in array di oggetti: BankAccount[] = accounts; Figure 14: Reorganizing Parallel Arrays into Arrays of Objects

71 Array Parzialmente Riempiti 71 Lunghezza di array = massimo numero di elementi nell'array Di solito è riempito solo parzialmente Serve una variabile d'appoggio per tener traccia della dimensione corrente Convenzione uniforme sui nomi: final int DATA_LENGTH = 100; double[] data = new double[data_length]; int datasize = 0;

72 Array Parzialmente Riempiti 72 Aggiornare datasize al riempimento dell'array: data[datasize] = x; datasize++;

73 Array Parzialmente Riempiti 73 Figure 15: A Partially Filled Array

74 Un Vecchio Worm su Internet 74 Figure 16: A "Buffer Overrun" Attack