Array Array

(1)

Array Array

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

(2)

2 2

Obiettivi Obiettivi

 Prender familiarità con l'uso di array e array-list Prender familiarità con l'uso di array e array-list

 Conoscere le classi involucro, l'auto-boxing e il ciclo Conoscere le classi involucro, l'auto-boxing e il ciclo forfor generalizzatogeneralizzato

 Studiare gli algoritmi di base su array Studiare gli algoritmi di base su array

 Imparare l'uso di array bidimensionali Imparare l'uso di array bidimensionali

 Imparare quando scegliere gli array-list e quando gli Imparare quando scegliere gli array-list e quando gli array nei propri programmi

array nei propri programmi

 Implementare array riempiti parzialmenteImplementare array riempiti parzialmente

(3)

3 3

Array Array

 ArrayArray: Sequenza di valori dello stesso tipo : Sequenza di valori dello stesso tipo

 Costruire un array:Costruire un array:

 Immagazzinare dati in una variabile di tipo Immagazzinare dati in una variabile di tipo double[]

double[]

new double[10]

double[] data = new double[10];

(4)

4 4

Array Array

 Quando si crea un array, tutti i valori sono inizializzati Quando si crea un array, tutti i valori sono inizializzati a seconda del tipo di array:

a seconda del tipo di array:

 numeri: 0numeri: 0

 boolean: boolean: falsefalse

 Riferimenti ad oggetti: Riferimenti ad oggetti: nullnull

(5)

5 5

Array Array

Array e

Riferimento ad Array

(6)

6 6

Array Array

 Si usa l'operatore Si usa l'operatore [ ][ ] per accedere ad un elemento per accedere ad un elemento

Figure 2:

data[2] = 29.95;

(7)

7 7

Array Array

 Uso del valore immagazzinato:Uso del valore immagazzinato:

 Si ottiene la lunghezza dell'array con Si ottiene la lunghezza dell'array con data.length

data.length (NB: non è un metodo!) (NB: non è un metodo!)

 I valori degli indici vanno da I valori degli indici vanno da 00 a a length - 1length - 1

System.out.println("The value of this data item is "

+ data[4]);

(8)

8 8

Array Array

 L'accesso ad un elemento non esistente provoca un L'accesso ad un elemento non esistente provoca un errore di limiti

errore di limiti

 Limitazione: gli array hanno lunghezza fissataLimitazione: gli array hanno lunghezza fissata

data[10] = 29.95; // ERRORE data[10] = 29.95; // ERRORE

(9)

9 9

Sintassi 8.1: Costruzione di Array Sintassi 8.1: Costruzione di Array

newnew typeNametypeName[[lengthlength]]

 EsempioEsempio::

new double[10]new double[10]

 Scopo: Scopo: Costruire un array di un dato numero di Costruire un array di un dato numero di elementi

elementi

(10)

10 10

Sintassi 8.2: Accesso ad un Sintassi 8.2: Accesso ad un

Elemento di un Array Elemento di un Array

arrayReference

arrayReference[[indexindex]]

 EsempioEsempio:: data[2]data[2]

 ScopoScopo: Accedere ad un elemento in un array: Accedere ad un elemento in un array

(11)

11 11

Array List Array List

 La classe La classe ArrayListArrayList gestisce una sequenza di gestisce una sequenza di oggetti

oggetti

 Può crescere e restringersi secondo le necessitàPuò crescere e restringersi secondo le necessità

 La classe La classe ArrayListArrayList fornisce metodi per molti fornisce metodi per molti compiti comuni come l'inserimento e la rimozione di compiti comuni come l'inserimento e la rimozione di

elementi elementi

(12)

12 12

Array List Array List

 La classe La classe ArrayListArrayList è generica: è generica:

ArrayList<T>

ArrayList<T> raccoglie oggetti di tipo raccoglie oggetti di tipo TT::

 Il metodo Il metodo size()size() restituisce il numero di elementi restituisce il numero di elementi

ArrayList<BankAccount> accounts = ArrayList<BankAccount> accounts =

new ArrayList<BankAccount>();

accounts.add(new BankAccount(1001));

(13)

13 13

Ritrovamento di Elementi in Ritrovamento di Elementi in

Array List Array List

 Si usa il metodo Si usa il metodo getget

 L'indice comincia da L'indice comincia da 00

 Errore di limiti se l'indice è fuori dell'intervallo Errore di limiti se l'indice è fuori dell'intervallo

BankAccount anAccount = accounts.get(2);

// ottiene il terzo elemento dell'array list // ottiene il terzo elemento dell'array list

(14)

14 14

Ritrovamento di Elementi in Ritrovamento di Elementi in

Array List Array List

 Errori di limiti più comuni:Errori di limiti più comuni:

int i = accounts.size();

anAccount = accounts.get(i);

anAccount = accounts.get(i); // Errore// Errore

// valori leciti per gli indici: 0. . .i-1 // valori leciti per gli indici: 0. . .i-1

(15)

15 15

Aggiunta di Elementi Aggiunta di Elementi

 setset sovrascrive un valore esistente: sovrascrive un valore esistente:

 addadd aggiunge un nuovo valore nella posizione aggiunge un nuovo valore nella posizione precedente all'indice indicato

precedente all'indice indicato

BankAccount anAccount = new BankAccount anAccount = new BankAccount(1729);

BankAccount(1729);

accounts.set(2, anAccount);

accounts.add(i, a) accounts.add(i, a)

(16)

16 16

Aggiunta di Elementi Aggiunta di Elementi

Figure 3:

Adding an Element in the Middle of an Array List

(17)

17 17

Cancellazione di Elementi Cancellazione di Elementi

 removeremove removes an element at an index removes an element at an index

Accounts.remove(i) Accounts.remove(i)

(18)

18 18

Cancellazione di Elementi Cancellazione di Elementi

Figure 4:

Removing an Element in the Middle of an Array List

(19)

19 19

ArrayListTester.java ArrayListTester.java

01: import java.util.ArrayList;

02: 02:

03: /**

04: Programma che testa la classe ArrayList.

05: */

06: public class ArrayListTester 06: public class ArrayListTester 07: {

07: {

08: public static void main(String[] args) 08: public static void main(String[] args) 09: {

09: {

10: ArrayList<BankAccount> accounts 10: ArrayList<BankAccount> accounts

11: = new ArrayList<BankAccount>();

12: accounts.add(new BankAccount(1001));

15: accounts.add(1, new BankAccount(1008));

16: accounts.remove(0);

(20)

20 20

ArrayListTester.java ArrayListTester.java

17: 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: } 25: } 26: } 26: }

(21)

21 21

BankAccount.

BankAccount. java java

01: /**

02: Un conto corrente ha un saldo che può essere cambiato da 02: Un conto corrente ha un saldo che può essere cambiato da 03: depositi e prelievi.

03: depositi e prelievi.

04: */

05: public class BankAccount 05: public class BankAccount 06: {

06: { 07: /**

07: /**

08: Costruisce un conto con saldo zero 08: Costruisce un conto con saldo zero

09: @param anAccountNumber il numero di questo conto 09: @param anAccountNumber il numero di questo conto 10: */

10: */

11: public BankAccount(int anAccountNumber) 11: public BankAccount(int anAccountNumber) 12: {

12: {

13: accountNumber = anAccountNumber;

14: balance = 0;

15: } 15: } 16: 16:

(22)

22 22

BankAccount.

BankAccount. java java

17: /**

18: Costruisce un conto con un dato saldo iniziale 18: Costruisce un conto con un dato saldo iniziale 19: @param anAccountNumber il numero del conto

19: @param anAccountNumber il numero del conto 20: @param initialBalance il saldo iniziale 20: @param initialBalance il saldo iniziale 21: */

21: */

22: public BankAccount 22: public BankAccount

(int anAccountNumber, double initialBalance) (int anAccountNumber, double initialBalance) 23: {

23: {

24: accountNumber = anAccountNumber;

25: balance = initialBalance;

26: } 26: } 27: 27:

28: /**

29: ottiene il numero di questo conto corrente.

30: @return numero di conto 30: @return numero di conto 31: */

31: */

32: public int getAccountNumber() 32: public int getAccountNumber() 33: {

33: {

34: return accountNumber;

35: } 35: }

(23)

23 23

BankAccount.

BankAccount. java java

36: 36:

37: /**

38: Deposita denaro sul conto.

39: @param amount l'ammontare del deposito 39: @param amount l'ammontare del deposito 40: */

40: */

41: public void deposit(double amount) 41: public void deposit(double amount) 42: {

42: {

43: double newBalance = balance + amount;

44: balance = newBalance;

45: } 45: } 46: 46:

47: /**

48: Preleva denaro dal conto.

49: @param amount ammontare del prelievo 49: @param amount ammontare del prelievo 50: */

50: */

51: public void withdraw(double amount) 51: public void withdraw(double amount) 52: {

52: {

53: double newBalance = balance - amount;

54: balance = newBalance;

(24)

24 24

BankAccount.

BankAccount. java java

55: } 55: } 56: 56:

57: /**

58: Ottiene il saldo corrente del conto.

59: @return il saldo corrente 59: @return il saldo corrente 60: */

60: */

61: public double getBalance() 61: public double getBalance() 62: {

62: {

63: return balance;

64: } 64: } 65: 65:

66: private int accountNumber;

67: private double balance;

68: } 68: }

size=3 size=3

first account number=1008 first account number=1008 last account number=1729 last account number=1729

 Output:Output:

(25)

25 25

Wrapper Wrapper

 Non si possono inserire tipi primitivi direttamente Non si possono inserire tipi primitivi direttamente nelle array list

nelle array list

 Per trattare i valori di tipi primitivi come oggetti, si Per trattare i valori di tipi primitivi come oggetti, si usano le

usano le classi involucroclassi involucro ( (wrapperwrapper):):

ArrayList<Double> data = new ArrayList<Double>();

data.add(29.95);

double x = data.get(0);

(26)

26 26

Wrapper Wrapper

Figure 5:

An Object of a Wrapper Class

(27)

27 27

Wrapper Wrapper

 Ci sono classi involucro per tutti gli otto tipi primitivi: Ci sono classi involucro per tutti gli otto tipi primitivi:

(28)

28 28

Auto-boxing Auto-boxing

 Auto-boxingAuto-boxing: da Java 5.0, la conversione tra tipi : da Java 5.0, la conversione tra tipi primitivi e classi involucro corrispondenti è

primitivi e classi involucro corrispondenti è automatica

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)

29 29

Auto-boxing Auto-boxing

 L'auto-boxing funziona anche all'interno di L'auto-boxing funziona anche all'interno di espressioni aritmetiche:

espressioni aritmetiche:

significa:

 Fai l'auto-unbox di Fai l'auto-unbox di dd in un double in un double

 Aggiungi 1 Aggiungi 1

 Fai l'auto-box del risultato in un nuovo DoubleFai l'auto-box del risultato in un nuovo Double

 Immagazzina in eImmagazzina in e un riferimento all'oggetto involucro un riferimento all'oggetto involucro appena creato

appena creato

Double e = d + 1;

(30)

30 30

Ciclo

Ciclo for for Generalizzato Generalizzato

 Cicla su tutti gli elementi di una collezione:Cicla su tutti gli elementi di una collezione:

double[] data = . . .;

double sum = 0;

for (double e : data) for (double e : data)

// da leggersi: "per ogni e in data"

{{

sum = sum + e;

} }

(31)

31 31

Ciclo

Ciclo for for Generalizzato Generalizzato

 Alternativa tradizionale:Alternativa tradizionale:

double[] data =

double[] data = . . .. . .;; double sum = 0;

double sum = 0;

for (int i = 0; i < data.length; i++) for (int i = 0; i < data.length; i++) {{

double e = data[i];

sum = sum + e;

} }

(32)

32 32

Ciclo

Ciclo for for Generalizzato Generalizzato

 Funziona anche per le Funziona anche per le ArrayListsArrayLists::

ArrayList<BankAccount> accounts =

ArrayList<BankAccount> accounts = . . .. . . ; ; double sum = 0;

double sum = 0;

for (BankAccount a : accounts) for (BankAccount a : accounts) {{

sum = sum + a.getBalance();

} }

(33)

33 33

Ciclo

Ciclo for for Generalizzato Generalizzato

 Equivalente al seguente ciclo Equivalente al seguente ciclo forfor normale: normale:

double sum = 0;

for (int i = 0; i < accounts.size(); i++) for (int i = 0; i < accounts.size(); i++) {{

BankAccount a = accounts.get(i);

sum = sum + a.getBalance();

} }

(34)

34 34

Sintassi 8.3: Ciclo "Per Ogni"

forfor ((TypeType variablevariable :_: collectioncollection)₎ statementstatement

 EsempioEsempio::

for (double e : data)for (double e : data) sum = sum + e;

sum = sum + e;

 ScopoScopo: eseguire un iterazione per ogni elemento : eseguire un iterazione per ogni elemento

della collezione. Ad ogni iterata, viene assegnato alla della collezione. Ad ogni iterata, viene assegnato alla

variabile il prossimo elemento della collezione per variabile il prossimo elemento della collezione per

poi eseguire l'istruzione poi eseguire l'istruzione

(35)

35 35

Algoritmi Semplici su Array:

Conteggio delle Corrispodenze Conteggio delle Corrispodenze

 Controllare tutti gli elementi e contare le Controllare tutti gli elementi e contare le corrispondenze fino alla fine dell'array-list corrispondenze fino alla fine dell'array-list

public class Bank public class Bank {{

public int count(double atLeast) public int count(double atLeast) { {

int matches = 0;

for (BankAccount a : accounts) for (BankAccount a : accounts) {

{

if (a.getBalance() >= atLeast) matches++;

// trovata una corrispondenza // trovata una corrispondenza }

}

return matches;

} }

. . . . . .

private ArrayList<BankAccount> accounts;

(36)

36 36

Algoritmi Semplici su Array:

Trovare un Valore Trovare un Valore

 Controllare tutti gli elementi fino a trovare una Controllare tutti gli elementi fino a trovare una corrispondenza:

corrispondenza:

public class Bank public class Bank {{

public BankAccount find(int accountNumber) public BankAccount find(int accountNumber) { {

for (BankAccount a : accounts) for (BankAccount a : accounts)

{ {

if (a.getAccountNumber() == accountNumber) if (a.getAccountNumber() == accountNumber)

return a; // corrispondenza trovata return a; // corrispondenza trovata

} }

return null;

// nessuna corrispondenza in tutto array list // nessuna corrispondenza in tutto array list } }

. . . . . . }}

(37)

37 37

Algoritmi Semplici su Array:

Trovare il Massimo/Minimo Trovare il Massimo/Minimo

 Inizializzare un candidato con l'elemento inizialeInizializzare un candidato con l'elemento iniziale

 Confrontare il candidato con i restanti elementiConfrontare il candidato con i restanti elementi

 Aggiornare se si trova un valore più grande/piccoloAggiornare se si trova un valore più grande/piccolo

(38)

38 38

Algoritmi Semplici su Array:

Trovare il Massimo/Minimo Trovare il Massimo/Minimo

 Esempio: Esempio:

BankAccount largestYet = accounts.get(0);

for (int i = 1; i < accounts.size(); i++) for (int i = 1; i < accounts.size(); i++) {{

BankAccount a = accounts.get(i);

if (a.getBalance() > largestYet.getBalance()) if (a.getBalance() > largestYet.getBalance())

largestYet = a;

}}

return largestYet;

(39)

39 39

Algoritmi Semplici su Array:

Trovare il Massimo/Minimo Trovare il Massimo/Minimo

 Funziona solo se c'è almeno un elemento nell'array Funziona solo se c'è almeno un elemento nell'array list

list

 Se Se listlist è vuoto, restituisce è vuoto, restituisce nullnull

if (accounts.size() == 0) return null;

BankAccount largestYet = accounts.get(0);

. . . . . .

(40)

40 40

Bank.java Bank.java

01: import java.util.ArrayList;

02: 02:

03: /**

04: Questa banca contiene una collezione di conti correnti 04: Questa banca contiene una collezione di conti correnti 05: */

05: */

06: public class Bank 06: public class Bank 07: {

07: { 08: /**

08: /**

09: Constructs a bank with no bank accounts.

10: */

11: public Bank() 11: public Bank() 12: {

12: {

13: accounts = new ArrayList<BankAccount>();

14: } 14: } 15: 15:

16: /**

17: aggiunge un conto alla banca.

18: @param a conto da aggiungere 18: @param a conto da aggiungere 19: */

19: */

(41)

41 41

Bank.java Bank.java

20: public void addAccount(BankAccount a) 20: public void addAccount(BankAccount a) 21: {

21: {

22: accounts.add(a);

23: } 23: } 24:

24:

25: /**

26: ritorna la somma dei saldi dei conti della banca 26: ritorna la somma dei saldi dei conti della banca 27: @return somma dei saldi

27: @return somma dei saldi 28: */

28: */

29: public double getTotalBalance() 29: public double getTotalBalance() 30: {

30: {

31: double total = 0;

32: for (BankAccount a : accounts) 32: for (BankAccount a : accounts) 33: {

33: {

34: total = total + a.getBalance();

35: } 35: }

36: return total;

37: } 37: } 38: 38:

(42)

42 42

Bank.java Bank.java

39: /**

40: conta il numero dei conti il cui saldo sia pari 40: conta il numero dei conti il cui saldo sia pari 41: almeno ad un dato valore.

41: almeno ad un dato valore.

42: @param atLeast saldo minimo 42: @param atLeast saldo minimo

43: @return numero dei conti che hanno almeno un saldo 43: @return numero dei conti che hanno almeno un saldo

// pari al valore dato // pari al valore dato 44: */

44: */

45: public int count(double atLeast) 45: public int count(double atLeast) 46: {

46: {

47: int matches = 0;

49: {

50: if (a.getBalance() >= atLeast) matches++;

// trovato // trovato 51: }

51: }

52: return matches;

53: } 53: } 54: 54:

(43)

43 43

Bank.java Bank.java

55: /**

56: trova un conto con un dato numero.

57: @param accountNumber numero da trovare 57: @param accountNumber numero da trovare

58: @return il conto del dato numero, oppure null 58: @return il conto del dato numero, oppure null 59: se non è presente quel conto

59: se non è presente quel conto 60: */

60: */

61: public BankAccount find(int accountNumber) 61: public BankAccount find(int accountNumber) 62: {

62: {

64: {

65: if (a.getAccountNumber() == accountNumber) 65: if (a.getAccountNumber() == accountNumber)

// trovato // trovato 66: return a;

66: return a;

67: } 67: }

68: return null; // trovato nessun conto con quel numero 68: return null; // trovato nessun conto con quel numero 69: }

69: } 70: 70:

(44)

44 44

Bank.java Bank.java

71: /**

72: restituisce il conto con il saldo maggiore 72: restituisce il conto con il saldo maggiore

73: @return il conto con il saldo maggiore, oppure 73: @return il conto con il saldo maggiore, oppure 74: null se la banca non ha conti aperti

74: null se la banca non ha conti aperti 75: */

75: */

76: public BankAccount getMaximum() 76: public BankAccount getMaximum() 77: {

77: {

78: if (accounts.size() == 0) return null;

79: BankAccount largestYet = accounts.get(0);

80: for (int i = 1; i < accounts.size(); i++) 80: for (int i = 1; i < accounts.size(); i++) 81: {

81: {

82: BankAccount a = accounts.get(i);

83: if (a.getBalance() > largestYet.getBalance()) 83: if (a.getBalance() > largestYet.getBalance()) 84: largestYet = a;

84: largestYet = a;

85: } 85: }

86: return largestYet;

87: } 87: } 88: 88:

89: private ArrayList<BankAccount> accounts;

90: } 90: }

(45)

45 45

BankTester.java BankTester.java

01: /**

02: Programma di test per la classe Bank.

03: */

04: public class BankTester 04: public class BankTester 05: {

05: {

07: {

08: Bank firstBankOfJava = new Bank();

09: firstBankOfJava.addAccount 09: firstBankOfJava.addAccount

(new BankAccount(1001, 20000));

12: 12:

13: double threshold = 15000;

14: int c = firstBankOfJava.count(threshold);

15: System.out.println 15: System.out.println

(c + " accounts with balance >= " + threshold);

(46)

46 46

BankTester.java BankTester.java

16:

17: int accountNumber = 1015;

18: BankAccount a = 18: BankAccount a =

firstBankOfJava.find(accountNumber);

19: if (a == null) 19: if (a == null)

("No account with number " + accountNumber);

21: else 21: else

("Account with number " + accountNumber ("Account with number " + accountNumber 23:

23: + " has balance " + a.getBalance());+ " has balance " + a.getBalance());

24: 24:

25: BankAccount max = firstBankOfJava.getMaximum();

26: System.out.println("Account with number "

27: + max.getAccountNumber() 27: + max.getAccountNumber()

28: + " has the largest balance.");

29: } 29: } 30: } 30: }

(47)

47 47

BankTester.java BankTester.java

 OutputOutput

2 accounts with balance >= 15000.0 2 accounts with balance >= 15000.0

Account with number 1015 has balance 10000.0 Account with number 1015 has balance 10000.0

Account with number 1001 has the largest balance.

(48)

48 48

Array Bidimensionali Array Bidimensionali

 Nel costruire un array bidimensionale, Nel costruire un array bidimensionale,

si specifica di quante righe e colonne si ha bisogno:

 Si ha accesso agli elementi con una coppia di indici Si ha accesso agli elementi con una coppia di indici a[i][j]

a[i][j]: :

final int ROWS = 3;

final int COLUMNS = 3;

String[][] board = new String[ROWS][COLUMNS];

board[i][j] = "x";

(49)

49 49

Tavola per il Filetto Tavola per il Filetto

Figure 6:

A Tic-Tac-Toe Board

(50)

50 50

Attraversamento Attraversamento di Array Bidimensionali di Array Bidimensionali

 È tipico usare due cicli nidificati nel riempimento o la È tipico usare due cicli nidificati nel riempimento o la ricerca:

ricerca:

for (int i = 0; i < ROWS; i++) for (int i = 0; i < ROWS; i++)

for (int j = 0; j < COLUMNS; j++) for (int j = 0; j < COLUMNS; j++) board[i][j] = " ";

board[i][j] = " ";

(51)

51 51

TicTacToe.java TicTacToe.java

01: /**

02: Una tavola di Filetto 3 x 3.

03: */

04: public class TicTacToe 04: public class TicTacToe 05: {

05: {

06: /**

07: Costruisce la tavola vuota.

08: */

09: public TicTacToe() 09: public TicTacToe() 10: {

10: {

11: board = new String[ROWS][COLUMNS];

12: // riempie con spazi 12: // riempie con spazi

13: for (int i = 0; i < ROWS; i++) 13: for (int i = 0; i < ROWS; i++)

14: for (int j = 0; j < COLUMNS; j++) 14: for (int j = 0; j < COLUMNS; j++) 15: board[i][j] = " ";

15: board[i][j] = " ";

16: } 16: } 17: 17:

(52)

52 52

TicTacToe.java TicTacToe.java

18: /**

19: Imposta una casella (non deve essere occupata) 19: Imposta una casella (non deve essere occupata) 20: @param i indice della riga

20: @param i indice della riga

21: @param j indice della colonna 21: @param j indice della colonna

22: @param player il giocatore ("x" oppure "o") 22: @param player il giocatore ("x" oppure "o") 23: */

23: */

24: public void set(int i, int j, String player) 24: public void set(int i, int j, String player) 25: {

25: {

26: if (board[i][j].equals(" ")) 26: if (board[i][j].equals(" ")) 27: board[i][j] = player;

27: board[i][j] = player;

28: } 28: } 29: 29:

30: /**

31: Crea una rappresentazione della tavola 31: Crea una rappresentazione della tavola

in forma di stringa come ad es.:

32: |x o|

33: | x | 33: | x | 34: | o|

34: | o|

35: @return la rappresentazione in forma di stringa 35: @return la rappresentazione in forma di stringa

(53)

53 53

TicTacToe.java TicTacToe.java

37: public String toString() 37: public String toString() 38: {

38: {

39: String r = "";

40: for (int i = 0; i < ROWS; i++) 40: for (int i = 0; i < ROWS; i++) 41: {

41: {

42: r = r + "|";

43: for (int j = 0; j < COLUMNS; j++) 43: for (int j = 0; j < COLUMNS; j++) 44: r = r + board[i][j];

44: r = r + board[i][j];

45: r = r + "|\n";

46: } 46: }

47: return r;

48: } 48: } 49: 49:

50: private String[][] board;

51: private static final int ROWS = 3;

52: private static final int COLUMNS = 3;

53: } 53: }

(54)

54 54

TicTacToeTester.java TicTacToeTester.java

01: import java.util.Scanner;

02: 02:

03: /**

04: Programma di test della classe TicTacToe 04: Programma di test della classe TicTacToe

05: che chiede all'utente di impostare le posizioni 05: che chiede all'utente di impostare le posizioni 06: sulla tavola e stampa il risultato.

06: sulla tavola e stampa il risultato.

07: */

08: public class TicTacToeTester 08: public class TicTacToeTester 09: {

09: {

11: {

12: Scanner in = new Scanner(System.in);

13: String player = "x";

14: TicTacToe game = new TicTacToe();

15: boolean done = false;

16: while (!done) 16: while (!done) 17: {

17: {

(55)

55 55

TicTacToeTester.java TicTacToeTester.java

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 23: else 24: {

24: {

25: System.out.print 25: System.out.print

("Column for " + player + ": ");

26: int column = in.nextInt();

27: game.set(row, column, player);

28: if (player.equals("x")) 28: if (player.equals("x")) 29: player = "o";

29: player = "o";

30: else 30: else

31: player = "x";

32: } 32: } 33: }

33: } 34: }

34: }

(56)

56 56

Output Output

|| ||

Row for x (-1 to exit): 1 Row for x (-1 to exit): 1 Column for x: 2

Column for x: 2

|| | |

|| xx | |

|| ||

Row for o (-1 to exit): 0 Row for o (-1 to exit): 0 Column for o: 0

Column for o: 0

|o|o | |

|| xx | |

| | | |

Row for x (-1 to exit): -1 Row for x (-1 to exit): -1

(57)

57 57

Copiare Array:

Copiare i Riferimenti Copiare i Riferimenti

 Copiare una variabile array comporta un secondo Copiare una variabile array comporta un secondo riferimento allo stesso (oggetto) array

riferimento allo stesso (oggetto) array

// riempie l'array . . . // riempie l'array . . . double[] prices = data;

double[] prices = data;

(58)

58 58

Copiare Array:

Copiare i Riferimenti Copiare i Riferimenti

Figure 7:

(59)

59 59

Copiare Array:

Clonare gli Array Clonare gli Array

 Si usa il metodo Si usa il metodo cloneclone per farne una vera copia per farne una vera copia

double[] prices = (double[]) data.clone();

(60)

60 60

Copiare Array:

Clonare gli Array Clonare gli Array

Figure 8:

Cloning an Array

(61)

61 61

Copiare Array:

Copiare Elementi di Array Copiare Elementi di Array

System.arraycopy(from, fromStart, to, toStart, count);

(62)

62 62

Copiare Array:

Copiare Elementi di Array Copiare Elementi di Array

Figure 9:

The System.arraycopy Method

(63)

63 63

Aggiungere Elementi ad Array Aggiungere Elementi ad Array

System.arraycopy System.arraycopy

(data, i, data, i + 1, data.length - i - 1);

data[i] = x;

(64)

64 64

Aggiungere Elementi ad Array Aggiungere Elementi ad Array

Figure 10:

Inserting a New Element Into an Array

(65)

65 65

Eliminare un Elemento Eliminare un Elemento

System.arraycopy(data, i + 1, data, i, data.length - i - 1);

(66)

66 66

Rimuovere Elementi da Array Rimuovere Elementi da Array

Figure 11

Removing an Element from an Array

(67)

67 67

Ampliare un Array Ampliare un Array

 Se l'array è pieno e si ha bisogno di più spazio è Se l'array è pieno e si ha bisogno di più spazio è possibile ampliare l'array:

possibile ampliare l'array:

 Creare un nuovo array più grande Creare un nuovo array più grande

 Copiare tutti gli elementi nel nuovo array Copiare tutti gli elementi nel nuovo array

 Immagazzinare il riferimento al nuovo array nella Immagazzinare il riferimento al nuovo array nella precedente variabile array

precedente variabile array

double[] newData = new double[2 * data.length];

System.arraycopy(data, 0, newData, 0, data.length);

(68)

68 68

Ampliare un Array Ampliare un Array

Figure 12:

(69)

69 69

Creare Array Paralleli Creare Array Paralleli

in Array di Oggetti in Array di Oggetti

Figure 13:

// Da NON fare // Da NON fare

int[] accountNumbers;

double[] balances;

(70)

70 70

Creare Array Paralleli Creare Array Paralleli

in Array di Oggetti in Array di Oggetti

 Evitare l'uso di array paralleli trasformandoli in array Evitare l'uso di array paralleli trasformandoli in array di oggetti:

di oggetti:

Figure 14:

BankAccount[] = accounts;

(71)

71 71

Array Parzialmente Riempiti Array Parzialmente Riempiti

 Lunghezza di array = massimo numero di elementi Lunghezza di array = massimo numero di elementi nell'array

nell'array

 Di solito è riempito solo parzialmente Di solito è riempito solo parzialmente

 Serve una variabile d'appoggio per tener traccia Serve una variabile d'appoggio per tener traccia della dimensione corrente

della dimensione corrente

 Convenzione uniforme sui nomi:Convenzione uniforme sui nomi:

final int DATA_LENGTH = 100;

double[] data = new double[DATA_LENGTH];

int dataSize = 0;

(72)

72 72

Array Parzialmente Riempiti Array Parzialmente Riempiti

 Aggiornare Aggiornare dataSizedataSize al riempimento dell'array: al riempimento dell'array:

data[dataSize] = x;

dataSize++;

(73)

73 73

Array Parzialmente Riempiti Array Parzialmente Riempiti

Figure 15:

(74)

74 74

Un Vecchio Worm su Internet Un Vecchio Worm su Internet

Figure 16: