Capitolo 7 array e array list - DEI

Obiettivi del capitolo
80
Capitolo 7
array e array list
Acquisire familiarità con l’utilizzo di array e
array list (vettori )
| Studiare le classi involucro, la tecnica di autoimpacchettamento e il ciclo for generalizzato
| Apprendere gli algoritmi più comuni per gli
array
| Capire come usare array bidimensionali
| Imparare a scegliere array o vettori nei vostri
programmi
| Realizzare array riempiti solo in parte
|
Fondamenti Informatica
Array
80
|
z
|
Costruisci un array:
new double[10]
z
1
Array
80
Sequenza di valori dello stesso tipo
UNIPD © 2007
Quando un array viene creato, tutti i valori
vengono inizializzati in base al tipo
dell’array:
Numeri: 0
Boolean: false
z Riferimenti agli oggetti: null
z
Memorizza in variabile del tipo double[ ]
z
double[] data = new double[10];
Continued…
Fondamenti Informatica
UNIPD © 2007
2
Fondamenti Informatica
UNIPD © 2007
3
80
|
Array
DieTester.java
80
Si usa [ ] per accedere ad un elemento
01:
02:
03:
04:
05:
06:
07:
08:
09:
data[2] = 29.95;
10:
12:
14:
15:
16:
17:
Fondamenti Informatica
80
|
UNIPD © 2007
4
Array
|
System.out.println("The data item is " + data[4]);
Si ricava la lunghezza dell’array con
data.length.
(Non è un metodo!)
|
Il valore dell’indice deve essere compreso fra
0 e length - 1
UNIPD © 2007
UNIPD © 2007
5
Array
Accedere ad un elemento non esistente è
un errore
double[] data = new double[10];
data[10] = 29.95; // ERROR
|
Fondamenti Informatica
Questo programma registra dieci lanci di un dado.
*/
public class DieTester
{
public static void main(String[] args)
{
final int TRIES = 10;
Die d = new Die(6);
int[] lanci = new int[TRIES];
for (int i = 0; i < TRIES; i++) {
lanci[i] = d.cast();
}
System.out.println(lanci);
}
}
Fondamenti Informatica
80
Per utilizzare il valore memorizzato:
/**
6
|
Limitazione: gli array hanno una lunghezza
fissa
Fondamenti Informatica
UNIPD © 2007
7
80
Sintassi 8.1: Costruzione di
Array
80
Sintassi 8.2: Accesso a
Elementi di Array
new nomeTipo [lunghezza]
riferimentoAdArray [Indice]
Esempio:
new double[10]
Esempio:
data[2]
Obiettivo:
Costruire un array con un dato numero di elementi
Fondamenti Informatica
80
1.
UNIPD © 2007
Obiettivo:
Accedere ad un elemento diun array
8
Verifica
Fondamenti Informatica
80
2.
Quali valori sono presenti nell’array dopo
l’esecuzione dei seguenti enunciati?
double[] data = new double[10];
for (int i = 0; i < data.length; i++) data[i] = i * i;
Verifica
Cosa visualizzano i seguenti frammenti di
programma? Oppure, se c’è un errore,
descrivete l’errore ed indicate se si tratta
di un errore di compilazione o di un errore
di esecuzione.
1.
2.
3.
Fondamenti Informatica
UNIPD © 2007
10
9
UNIPD © 2007
Fondamenti Informatica
double[] a = new double[10];
System.out.println(a[0]);
double[] b = new double[10];
System.out.println(b[10]);
double[] c;
System.out.println(c[0]);
UNIPD © 2007
11
Risposte
80
1.
Array bidimensionali
80
0, 1, 4, 9, 16, 25, 36, 49, 64, 81, ma non
100
|
2.
1.
2.
3.
0
Errore di esecuzione: indice di array fuori
dai limiti
Errore di compilazione: c non è
inizializzata
Costruendo un array bidimensionale,
specificate di quante righe o colonne avete
bisogno:
final int ROWS = 3;
final int COLUMNS = 3;
String[][] board = new String[ROWS][COLUMNS];
|
Accedete ad elementi con una coppia di
indici a[i][j]
board[i][j] = "x";
Fondamenti Informatica
80
UNIPD © 2007
12
Una scacchiera Tic Tac Toe
Fondamenti Informatica
80
|
UNIPD © 2007
13
Attraversare array
bidimensionali
Di solito si usano cicli annidati quando si
inseriscono o si cercano dati:
for (int i = 0; i < ROWS; i++)
for (int j = 0; j < COLUMNS; j++)
board[i][j] = " ";
Fondamenti Informatica
UNIPD © 2007
14
Fondamenti Informatica
UNIPD © 2007
15
File TicTacToe.java
80
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
/**
A 3 x 3 tic-tac-toe board.
*/
public class TicTacToe
{
/**
Constructs an empty board.
*/
public TicTacToe()
{
board = new String[ROWS][COLUMNS];
// Fill with spaces
for (int i = 0; i < ROWS; i++)
for (int j = 0; j < COLUMNS; j++)
board[i][j] = " ";
}
Segue…
Fondamenti Informatica
80
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53: }
UNIPD © 2007
16
File TicTacToe.java
/**
Sets a
@param
@param
@param
18
field in the board. The field must be unoccupied.
i the row index
j the column index
player the player ("x" or "o")
*/
public void set(int i, int j, String player)
{
if (board[i][j].equals(" "))
board[i][j] = player;
}
/**
Creates a string representation of the board, such as
|x o|
| x |
|
o|
@return the string representation
Segue…17
*/Informatica
Fondamenti
UNIPD © 2007
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
17:
private String[][] board;
private static final int ROWS = 3;
private static final int COLUMNS = 3;
UNIPD © 2007
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
File
TicTacToeTester.java
80
public String toString()
{
String r = "";
for (int i = 0; i < ROWS; i++)
{
r = r + "|";
for (int j = 0; j < COLUMNS; j++)
r = r + board[i][j];
r = r + "|\n";
}
return r;
}
Fondamenti Informatica
File TicTacToe.java
80
import java.util.Scanner;
/**
This program tests the TicTacToe class by prompting the
user to set positions on the board and printing out the
result.
*/
public class TicTacToeTester
{
public static void main(String[] args)
{
Scanner in = new Scanner(System.in);
String player = "x";
TicTacToe game = new TicTacToe();
boolean done = false;
while (!done)
{
Fondamenti Informatica
UNIPD © 2007
Segue…
19
File
TicTacToeTester.java
System.out.print(game.toString());
80
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35: }
System.out.print(
"Row for " + player + " (-1 to exit): ");
int row = in.nextInt();
if (row < 0) done = true;
else
{
System.out.print("Column for " + player + ": ");
int column = in.nextInt();
game.set(row, column, player);
if (player.equals("x"))
player = "o";
else
player = "x";
}
}
80
11.
12.
Segue…
UNIPD © 2007
Column for x: 2
|
|
| x|
|
Row for o (-1 to exit): 0
Column for o: 0
|o |
|
20
Verifica
|
Fondamenti
Row
forInformatica
x (-1 to exit): -1
80
UNIPD © 2007
UNIPD © 2007
21
Risposte
int[][] array = new int[4][4];
Come si dichiara e si inizializza un array
di interi 4 per 4?
Come si conta il numero di caselle non
occupate nella scacchiera tic-tac-toe?
Fondamenti Informatica
| |
| |
| |
Row for x (-1 to exit): 1
| x|
}
Fondamenti Informatica
Output
80
11.
12.
22
int count = 0;
for (int i = 0; i < ROWS; i++)
for (int j = 0; j < COLUMNS; j++)
if (board[i][j] == ' ') count++;
Fondamenti Informatica
UNIPD © 2007
23
80
|
Copiare Array:
Copiare riferimenti agli array
80
Copiare Array:
Copiare riferimenti agli array
Copiando una variabile array otterrete un
altro riferimento allo stesso array
double[] data = new double[10];
// fill array . . .
double[] prices = data;
Segue…
Fondamenti Informatica
80
|
24
UNIPD © 2007
Copiare = Clonare array
Fondamenti Informatica
80
UNIPD © 2007
25
Copiare = Clonare array
Usate clone per fare una vera copia
double[] prices = (double[]) data.clone();
Segue…
Fondamenti Informatica
UNIPD © 2007
26
Fondamenti Informatica
UNIPD © 2007
27
80
Copiare Array:
Copiare elementi array
System.arraycopy(from, fromStart, to, toStart, count);
Fondamenti Informatica
80
UNIPD © 2007
Aggiungere un elemento ad un
array
80
System.arraycopy(data, i, data, i + 1, data.length - i - 1);
data[i] = x;
28
Rimuovere un elemento da
un array
Fondamenti Informatica
|
29
Ingrandire un array
80
System.arraycopy(data, i + 1, data, i, data.length - i - 1);
UNIPD © 2007
Se l’array è pieno e avete bisogno di più spazio,
potete ingrandirlo:
1.
Creare un nuovo array più grande.
double[] newData = new double[2 * data.length];
2.
Copiare tutti gli elementi nel nuovo array
System.arraycopy(data, 0, newData, 0, data.length);
3.
Salvare il riferimento al nuovo array nella variabile
array
data = newData;
Fondamenti Informatica
UNIPD © 2007
30
Fondamenti Informatica
UNIPD © 2007
31
80
Ingrandire un array
80
13.
14.
Fondamenti Informatica
80
UNIPD © 2007
32
Risposte
Usate I metodi insert e remove.
14.
Perché è uno spreco di tempo,
bisognerebbe ripetere il processo ogni
volta che si aggiunge un elemento.
Fondamenti Informatica
UNIPD © 2007
•
34
Come si aggiungono o si eliminano
elementi in una posizione intermedia di
un vettore?
Perché, quando non c’è più spazio in un
array, ne raddoppiamo la dimensione
invece di aumentarla di un’unità?
Fondamenti Informatica
80
13.
Verifica
UNIPD © 2007
33
Trasformare array paralleli in
array di oggetti
// Don't do this
int[] accountNumbers;
double[] balances;
Fondamenti Informatica
UNIPD © 2007
35
Trasformare array paralleli in
array di oggetti
80
|
Evitate array paralleli Ö array di oggetti:
80
Array riempiti solo in parte
Lunghezza di un array = numero massimo
di elementi in un array
| Di solito è riempito solo in parte
| Necessita di una variabile associata per
tenere traccia della dimensione corrente
| Uniformate I nomi:
|
BankAccount[] = accounts;
final int DATA_LENGTH = 100;
double[] data = new double[DATA_LENGTH];
int dataSize = 0;
Fondamenti Informatica
80
|
UNIPD © 2007
36
Array riempiti solo in parte
Segue…
Fondamenti Informatica
80
UNIPD © 2007
37
Array riempiti solo in parte
Aggiornate dataSize quando l’array è
pieno:
data[dataSize] = x;
dataSize++;
Fondamenti Informatica
UNIPD © 2007
38
Fondamenti Informatica
UNIPD © 2007
39
80
Buffer over-run
80
Vettori
La classe ArrayList controlla una serie di
oggetti
| Può crescere e restringersi in base alle
necessità
| La classe ArrayList fornisce metodi per
svolgere le operazioni più comuni, come
l’inserimento o la rimozione di elementi
|
Continued…
Fondamenti Informatica
80
|
UNIPD © 2007
40
Vettori
Fondamenti Informatica
80
La classe ArrayList è una classe
generica: ArrayList<T> contiene oggetti
del tipo T:
UNIPD © 2007
41
Ricavare elementi di un
vettore
|
Si usa il metodo get
|
L’indice parte da 0
| BankAccount anAccount = accounts.get(2);
// ricava il terzo elemento di un vettore
ArrayList<BankAccount> accounts = new ArrayList<BankAccount>();
accounts.add(new BankAccount(1001));
accounts.add(new BankAccount(1015));
accounts.add(new BankAccount(1022));
|
|
Se l’indice è fuori dai valori, risulta un
errore di limiti
Il metodo size restituisce la dimensione
attuale di un vettore
Fondamenti Informatica
UNIPD © 2007
42
Fondamenti Informatica
UNIPD © 2007
43
80
|
Ricavare elementi di un
vettore
Aggiungere e rimuovere
elementi
80
|
Errori di limiti più comuni:
set sovrascrive un elemento esistente
BankAccount anAccount = new BankAccount(1729);
accounts.set(2, anAccount);
int i = accounts.size();
anAccount = accounts.get(i); // Error
// legal index values are 0. . .i-1
|
add aggiunge un nuovo valore nella posizione
indicata
accounts.add(i, a)
|
remove rimuove l’elemento nella posizione
indicata
Accounts.remove(i)
Continued…
Fondamenti Informatica
80
UNIPD © 2007
44
Aggiungere e rimuovere
elementi
Fondamenti Informatica
Fondamenti Informatica
UNIPD © 2007
File:
ArrayListTester.java
80
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
46
45
UNIPD © 2007
import java.util.ArrayList;
/**
This program tests the ArrayList class.
*/
public class ArrayListTester
{
public static void main(String[] args)
{
ArrayList<BankAccount> accounts
= new ArrayList<BankAccount>();
accounts.add(new BankAccount(1001));
accounts.add(new BankAccount(1015));
accounts.add(new BankAccount(1729));
accounts.add(1, new BankAccount(1008));
accounts.remove(0);
Fondamenti Informatica
UNIPD © 2007
jcreator
47
File:
ArrayListTester.java
80
17:
18:
19:
20:
21:
22:
23:
24:
25:
26: }
System.out.println("size=" + accounts.size());
BankAccount first = accounts.get(0);
System.out.println("first account number="
+ first.getAccountNumber());
BankAccount last = accounts.get(accounts.size() - 1);
System.out.println("last account number="
+ last.getAccountNumber());
}
Fondamenti Informatica
80
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
80
48
UNIPD © 2007
File: BankAccount.java
Fondamenti Informatica
UNIPD © 2007
/**
A bank account has a balance that can be changed by
deposits and withdrawals.
*/
public class BankAccount
{
/**
Constructs a bank account with a zero balance
@param anAccountNumber the account number for this account
*/
public BankAccount(int anAccountNumber)
{
accountNumber = anAccountNumber;
balance = 0;
}
Fondamenti Informatica
80
/**
Constructs a bank account with a given balance
@param anAccountNumber the account number for this account
@param initialBalance the initial balance
*/
public BankAccount(int anAccountNumber, double initialBalance)
{
accountNumber = anAccountNumber;
balance = initialBalance;
}
/**
Gets the account number of this bank account.
@return the account number
*/
public int getAccountNumber()
{
return accountNumber;
}
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
16:
Continued…
50
File: BankAccount.java
49
UNIPD © 2007
File: BankAccount.java
36:
37:
/**
38:
Deposits money into the bank account.
39:
@param amount the amount to deposit
40:
*/
41:
public void deposit(double amount)
42:
{
43:
double newBalance = balance + amount;
44:
balance = newBalance;
45:
}
46:
47:
/**
48:
Withdraws money from the bank account.
49:
@param amount the amount to withdraw
50:
*/
51:
public void withdraw(double amount)
52:
{
53:
double newBalance = balance - amount;
54: Fondamenti Informatica
balance = newBalance;
UNIPD © 2007
Continued…
51
File: BankAccount.java
80
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68: }
80
/**
3.
Gets the current balance of the bank account.
@return the current balance
*/
public double getBalance()
{
return balance;
}
4.
size=3
first account number=1008
Informatica
lastFondamenti
account
number=1729
3.
4.
UNIPD © 2007
52
Risposte
Fondamenti Informatica
80
|
new String[10];
new ArrayList<String>();
names contiene le stringhe "B" e "C" alle
posizioni 0 e 1
Fondamenti Informatica
UNIPD © 2007
Come si costruisce un array di 10
stringhe? E un vettore di stringhe?
Cosa contiene names dopo l’esecuzione
dei seguenti enunciati?
ArrayList<String> names = new ArrayList<String>();
names.add("A");
names.add(0, "B");
names.add("C");
names.remove(1);
private int accountNumber;
private double balance;
Output
80
Verifica
}
UNIPD © 2007
53
Involucri
Non si possono inserire tipi primitivi
direttamente in vettori, devono essere
trasformati in oggetti ) classi involucro
ArrayList<Double> data = new ArrayList<Double>();
data.add(29.95);
double x = data.get(0);
54
Fondamenti Informatica
UNIPD © 2007
55
Involucri
80
|
80
classi involucro per
tutti i tipi primitivi
|
Auto-impacchettamento
Auto-impacchettamento: a partire da Java
5.0, la conversione tra tipi primitivi e le
corrispondenti classi involucro è automatica
Double d = 29.95; // auto-boxing; same as
// Double d = new Double(29.95);
double x = d; // auto-unboxing; same as
// double x = d.doubleValue();
Fondamenti Informatica
56
Auto-impacchettamento
80
|
UNIPD © 2007
Fondamenti Informatica
80
L’ auto-impacchettamento lavora anche
all’interno di espressioni aritmetiche
z
Converti d in un valore di tipo double
Aggiungi 1
z Impacchetta il risultato in un nuovo oggetto di tipo
Double
z Memorizza in e il riferimento all’oggetto involucro
appena creato
z
Fondamenti Informatica
UNIPD © 2007
58
57
Verifica
5.
Qual è la differenza fra i tipi double e
Double?
6.
Se data è un esemplare di
ArrayList<Double> con dimensione
maggiore di zero, come si aggiunge
un’unità al valore memorizzato
nell’elemento di indice zero?
Double e = d + 1;
Significati:
UNIPD © 2007
Fondamenti Informatica
UNIPD © 2007
59
Risposte
80
5.
6.
double è uno degli otto tipi primitivi.
Double è un tipo di classe.
data.set(0, data.get(0) + 1);
Fondamenti Informatica
UNIPD © 2007
double[] data = . . .;
double sum = 0;
for (double e : data) {
sum = sum + e;
}
60
Il ciclo for generalizzato
80
|
double[] data = . . .;
double sum = 0;
for (int i = 0; i <
data.length; i++) {
double e = data[i];
sum = sum + e;
}
UNIPD © 2007
61
Il ciclo for generalizzato
|
ArrayList<BankAccount> accounts = . . . ;
double sum = 0;
for (BankAccount a : accounts)
{
sum = sum + a.getBalance();
}
UNIPD © 2007
Fondamenti Informatica
80
Funziona anche per ArrayLists :
Fondamenti Informatica
Il ciclo for generalizzato
80
E’ equivalente al seguente ciclo for
ordinario:
double sum = 0;
for (int i = 0; i < accounts.size(); i++)
{
BankAccount a = accounts.get(i);
sum = sum + a.getBalance();
}
62
Fondamenti Informatica
UNIPD © 2007
63
80
Sintassi 8.3: Il ciclo for
generalizzato
80
for (Type variable : collection)
statement
Esempio:
for (double e : data)
sum = sum + e;
Obiettivo:
Eseguire un ciclo avente un’iterazione per ogni elemento appartenente
ad una raccolta. All’inizio di ciascuna iterazione viene assegnato alla
variabile l’elemento successivo della raccolta, poi viene eseguito
l’enunciato.
Fondamenti Informatica
80
UNIPD © 2007
64
Risposte
7.
Scrivi un ciclo for generalizzato che
visualizzi tutti gli elementi dell’array data
8.
Perchè non è ragionevole utilizzare un ciclo
for generalizzato al posto del seguente
ciclo ordinario?
for (int i = 0; i < data.length; i++) data[i] = i * i;
Fondamenti Informatica
80
|
7.
for (double x : data) System.out.println(x);
8.
Il ciclo scrive un valore data[i]. Il ciclo
for non ha l’indice variabile i.
Fondamenti Informatica
UNIPD © 2007
66
Verifica
UNIPD © 2007
65
Semplici algoritmi per vettori:
contare occorrenze di un valore
Controlla tutti gli elementi e conta le occorrenze di
un valore fino alla fine dell’array
public class Bank
{
public int count(double atLeast)
{
int matches = 0;
for (BankAccount a : accounts)
{
if (a.getBalance() >= atLeast) matches++;
// Found a match
}
return matches;
}
. . .
private ArrayList<BankAccount> accounts;
} Informatica
Fondamenti
UNIPD © 2007
67
80
|
Semplici algoritmi per
vettori: Trovare un valore
Semplici algoritmi per vettori :
Trovare il massimo o il minimo
80
Controllate tutti gli elementi finché trovate
un valore.
Scegliete un candidato come valore
massimo
| Confrontate il candidato con gli altri
elementi
| Sostituitelo se trovate un valore maggiore o
minore
|
public class Bank {
public BankAccount find(int accountNumber){
for (BankAccount a : accounts)
{ // Found a match
if (a.getAccountNumber() == accountNumber)
return a;
}
return null; // No match in the entire array list
}
…
private ArrayList<BankAccount> accounts;
Segue…
}
Fondamenti Informatica
80
|
UNIPD © 2007
68
Semplici algoritmi per vettori :
Trovare il massimo o il minimo
UNIPD © 2007
69
Semplici algoritmi per vettori :
Trovare il massimo o il minimo
80
Funziona solo se c’è almeno un elemento
nella lista degli array
| Se la lista è vuota, il metodo restituisce null
|
Esempio:
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;
Fondamenti Informatica
Fondamenti Informatica
UNIPD © 2007
if (accounts.size() == 0) return null;
BankAccount largestYet = accounts.get(0);
. . .
70
Fondamenti Informatica
UNIPD © 2007
71
80
File Bank.java
80
01: import java.util.ArrayList;
02:
03: /**
04:
This bank contains a collection of bank accounts.
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:
/**
jcreator
17:
Adds an account to this bank.
18:
@param a the account to add
Segue… 72
19:Fondamenti*/
Informatica
UNIPD © 2007
80
File Bank.java
UNIPD © 2007
public void addAccount(BankAccount a)
{
accounts.add(a);
}
/**
Gets the sum of the balances of all accounts in this bank.
@return the sum of the balances
*/
public double getTotalBalance()
{
double total = 0;
for (BankAccount a : accounts)
{
total = total + a.getBalance();
}
return total;
}
Segue…
Fondamenti Informatica
80
39:
/**
40:
Counts the number of bank accounts whose balance is at
41:
least a given value.
42:
@param atLeast the balance required to count an account
43:
@return the number of accounts having least the given
// balance
44:
*/
45:
public int count(double atLeast)
46:
{
47:
int matches = 0;
48:
for (BankAccount a : accounts)
49:
{
50:
if (a.getBalance() >= atLeast) matches++; // Found
// a match
51:
}
52:
return matches;
53:
}
Segue…
54:
Fondamenti Informatica
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
74
File Bank.java
UNIPD © 2007
73
File Bank.java
55:
/**
56:
Finds a bank account with a given number.
57:
@param accountNumber the number to find
58:
@return the account with the given number, or null
59:
if there is no such account
60:
*/
61:
public BankAccount find(int accountNumber)
62:
{
63:
for (BankAccount a : accounts)
64:
{
65:
if (a.getAccountNumber() == accountNumber)
// Found a match
66:
return a;
67:
}
68:
return null; // No match in the entire array list
69:
}
70:
Segue…
Fondamenti Informatica
UNIPD © 2007
75
File Bank.java
80
71:
/**
72:
Gets the bank account with the largest balance.
73:
@return the account with the largest balance, or
74:
null if the bank has no accounts
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;
76
Fondamenti Informatica
UNIPD © 2007
90: }
File BankTester.java
80
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30: }
File BankTester.java
80
01:
02:
03:
04:
05:
06:
07:
08:
09:
10:
11:
12:
13:
14:
15:
/**
This program tests the Bank class.
*/
public class BankTester
{
public static void main(String[] args)
{
Bank firstBankOfJava = new Bank();
firstBankOfJava.addAccount(new BankAccount(1001, 20000));
firstBankOfJava.addAccount(new BankAccount(1015, 10000));
firstBankOfJava.addAccount(new BankAccount(1729, 15000));
double threshold = 15000;
int c = firstBankOfJava.count(threshold);
System.out.println(c + " accounts with balance >= "
+ threshold);
Segue…
Fondamenti Informatica
80
int accountNumber = 1015;
BankAccount a = firstBankOfJava.find(accountNumber);
if (a == null)
System.out.println("No account with number "
+ accountNumber);
else
System.out.println("Account with number "
+ accountNumber
+ " has balance " + a.getBalance());
UNIPD © 2007
77
File BankTester.java
Output
2 accounts with balance >= 15000.0
Account with number 1015 has balance 10000.0
Account with number 1001 has the largest balance.
BankAccount max = firstBankOfJava.getMaximum();
System.out.println("Account with number "
+ max.getAccountNumber()
+ " has the largest balance.");
}
Fondamenti Informatica
UNIPD © 2007
Segue…
78
Fondamenti Informatica
UNIPD © 2007
79
80
9.
10.
Verifica
80
Come si comporta il metodo find se
esistono due conti bancari con il numero
di conto uguale al numero cercato?
Si potrebbe usare il ciclo "for"
generalizzato nel metodo getMaximum?
Fondamenti Informatica
UNIPD © 2007
9.
10.
80
Risposte
Restituisce il primo che trova
Sì, ma il primo confronto fallirà sempre
Fondamenti Informatica
UNIPD © 2007
81