Transcript Computer Science A, 1

Computer Science A 10: 20/3
Array
• Array: Sequence of values of the same type
• Construct array:
new double[10]
• Store in variable of type double[]
double[] data = new double[10];
• When array is created, all values are initialized
depending on array type:
– Numbers: 0
– Boolean: false
– Object References: null
Array
Java
Use [] to access an element
data[2] = 29.95;
Arrays
• Using the value stored:
System.out.println("The value of this data
item is " + data[4]);
• Get array length as data.length. (Not a method!)
• Index values range from 0 to length - 1
• Accessing a nonexistent element results in a bounds
error
double[] data = new double[10];
data[10] = 29.95; // ERROR
• Limitation: Arrays have fixed length
Array Lists
• The ArrayList class manages a sequence of objects
• Can grow and shrink as needed
• ArrayList class supplies methods for many common
tasks, such as inserting and removing elements
• The ArrayList class is a generic class:
ArrayList<T> collects objects of type T:
ArrayList<BankAccount> accounts = new
ArrayList<BankAccount>();
accounts.add(new BankAccount(1001));
accounts.add(new BankAccount(1015));
accounts.add(new BankAccount(1022));
• size method yields number of elements
Retrieving Array List Elements
• Use get method
• Index starts at 0
• BankAccount anAccount = accounts.get(2);
// gets the third element of the array list
• Bounds error if index is out of range
• Most common bounds error:
int i = accounts.size();
anAccount = accounts.get(i); // Error
// legal index values are 0. . .i-1
Adding Elements
• set overwrites an existing value
BankAccount anAccount = new
BankAccount(1729);
accounts.set(2, anAccount);
• add adds a new value before the index
accounts.add(i, a)
Removing Elements
• remove removes an element at an index
accounts.remove(i)
Wrappers
• You cannot insert primitive types directly into
array lists
• To treat primitive type values as objects, you
must use wrapper classes:
ArrayList<Double> data
= new ArrayList<Double>();
data.add(29.95);
double x = data.get(0);
Wrappers
Auto-boxing
• Auto-boxing: Starting with Java 5.0, conversion between
primitive types and the corresponding wrapper classes is
automatic.
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();
• Auto-boxing even works inside arithmetic expressions
Double e = d + 1;
Means:
–
–
–
–
auto-unbox d into a double
add 1
auto-box the result into a new Double
store a reference to the newly created wrapper object in e
The Generalized for Loop
• Traverses all elements of a collection:
double[] data = . . .;
double sum = 0;
for (double e : data) {//for each e in data
sum = sum + e;
}
• Traditional alternative:
double[] data = . . .;
double sum = 0;
for (int i = 0; i < data.length; i++){
double e = data[i];
sum = sum + e;
}
The Generalized for Loop
• Works for ArrayLists too:
ArrayList<BankAccount> accounts = . . . ;
double sum = 0;
for (BankAccount a : accounts){
sum = sum + a.getBalance();
}
• Equivalent to the following ordinary for loop:
double sum = 0;
for (int i = 0; i < accounts.size(); i++){
BankAccount a = accounts.get(i);
sum = sum + a.getBalance();
}
Simple Array Algorithms: Counting Matches
• Check all elements and count the matches until you reach the
end of the array list.
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;
}
Two-Dimensional Arrays
• When constructing a two-dimensional array, you
specify how many rows and columns you need:
final int ROWS = 3;
final int COLUMNS = 3;
String[][] board = new String[ROWS][COLUMNS];
• You access elements with an index pair a[i][j]
board[i][j] = "x";
Copying Arrays: Copying Array References
Copying an array variable yields a second reference to the same array
double[] data = new double[10];
// fill array . . .
double[] prices = data;
Partially Filled Arrays
•
•
•
•
Array length = maximum number of elements in array
Usually, array is partially filled
Need companion variable to keep track of current size
Uniform naming convention:
final int DATA_LENGTH = 100;
double[] data = new double[DATA_LENGTH];
int dataSize = 0;
• Update dataSize as array is filled:
data[dataSize] = x;
dataSize++;
Partially Filled Arrays
Maps and sets
• HashMap – like an array with Objects (Strings as index
HashMap<String,String> job =
new HashMap<String,String>();
job.put(”John”,”Carpenter”);
job.put(”Paul”,”Painter”);
System.out.println(job.get(”John”));
if(!job.containsKey(”Mads”))
job.put(”Mads”,”Teacher”);
Sets
• HashSet – like an array with fast lookup
HashSet<String> guests =
new HashSet<String>();
guests.add(”John”);
guests.add(”Paul”);
if(!guests.contains (”Mads”))
job.put(”Sorry, Mads”);
Little Exercise
• A simple sorting algorithm works on an array by
finding the biggest number and put it in swop it
with the number in position n-1, The find the
biggest number in 0..n-2 and swop it with the
number in position n-2.
• Write the algorithm
• Fill an array with 10000 random numbers
• Compare running time with the function
java.utils.Arrays.sort