Arrays
1
Background
 Programmer often need the ability to represent a group of
values as a list
 List may be one-dimensional or multidimensional
 Java provides arrays and the collection classes
 The Vector class is an example of a collection class
 Consider arrays first
2
Array variable definition styles
 Without initialization
ElementType [ ] id;
Brackets
Name of
Type of
list
values in indicate array
variable being
list
defined
int [] a;
int a[];
3
Array variable definition styles
 With initialization
Nonnegative integer expression specifying the
number of elements in the array
ElementType [ ] id = new ElementType [n];
Reference to a new array of n
elements
4
Example
 Definitions
char[] c;
int[] value = new int[10];
 Causes
 Array object variable c is un-initialized
 Array object variable v references a new ten element list
of integers
 Each of the integers is default initialized to 0
c
value
0
0
0
0
…
0
5
Basic terminology
 List is composed of elements
 Elements in a list have a common name
 The list as a whole is referenced through the common name
 List elements are of the same type — the base type
 Elements of a list are referenced by subscripting (indexing) the
common name
6
Java array features
 Subscripts are denoted as expressions within brackets: [ ]
 Base (element) type can be any type
 Size of array can be specified at run time
 This is different that pure C! (for the most part, at least)
 Index type is integer and the index range must be 0 ... n-1
 Where n is the number of elements
 Automatic bounds checking
 Ensures any reference to an array element is valid
 Data field length specifies the number of elements in the list
 Array is an object
 Has features common to all other objects
7
Consider
int[] v = new int[10];
int i = 7;
int j = 2;
int k = 4;
v[0] = 1;
v[i] = 5;
v[j] = v[i] + 3;
v[j+1] = v[i] + v[0];
v[v[j]] = 12;
System.out.println(v[2]);
v[k] = stdin.nextInt();
v
8 is displayed
Suppose
3 is extracted
0
1
0
0
8
0
6
0
3
0
0
0
5
12
0
0
v[0]
v[1]
v[2]
v[3]
v[4]
v[5]
v[6]
v[7]
v[8]
v[9]
8
Consider
 Segment
int[] b = new int[100];
b[-1] = 0;
b[100] = 0;
 Causes
 Array variable to reference a new list of 100 integers
 Each element is initialized to 0
 Two exceptions to be thrown
 -1 is not a valid index – too small
 100 is not a valid index – too large
 IndexOutOfBoundsException
9
Today’s demotivators
10
Consider
Point[] p = new Point[3];
p[0] = new Point(0, 0);
p[1] = new Point(1, 1);
p[2] = new Point(2, 2);
p[0].setX(1);
p[1].setY(p[2].getY());
Point vertex = new Point(4,4);
p[1] = p[0];
vertex
p[2] = vertex;
p
p[0]
p[1]
p[2]
null
null
null
Point: (1,
(0, 0)
Point: (4, 4)
Point: (1, 2)
1)
Point: (2, 2)
11
Explicit initialization
 Syntax
id references an array of n elements. id[0] has
value exp0, id[1] has value exp1, and so on.
ElementType []
id = {
exp0 , exp1 , ... expn-1 } ;
Each expi is an expression that
evaluates to type ElementType
12
Explicit initialization
 Example
String[] puppy = { “pika“, “arlo“, “schuyler",
“nikki" };
int[] unit = { 1 };
 Equivalent to
String[] puppy = new String[4];
puppy[0] = “pika";
puppy[1] = “arlo";
puppy[2] = “schuyler";
puppy[3] = “nikki";
int[] unit = new int[1];
unit[0] = 1;
13
Array members
 Member length
 Size of the array
for (int i = 0; i < puppy.length; ++i) {
System.out.println(puppy[i]);
}
14
Array members
 Member clone()
 Produces a shallow copy
Point[] u = { new Point(0, 0), new Point(1, 1)};
Point[] v = u.clone();
v[1] = new Point(4, 30);
u[0]
u[1]
u
Point: (0, 0)
v
Point: (1, 1)
Point: (4, 30)
15
v[0]
v[1]
Making a deep copy
 Example
Point[] w = new Point[u.length];
for (int i = 0; i < u.length; ++i) {
w[i] = (Point) u[i].clone();
}
16
Making a deep copy
u[0]
u[1]
u[2]
u
Point: (0, 0)
w[0]
w[1]
Point: (2, 1)
Point: (2, 2)
Point: (2, 1)
Point: (2, 2)
w[2]
w
Point: (0, 0)
17
Review of last time
 Creating an array:
int[] foo = new int[10];
 Accessing an array:
foo[3] = 7;
System.out.print (foo[1]);
 Creating an array:
String[] bar = new String[10];
 Accessing an array:
bar[3] = “qux”;
System.out.println (bar[1]);
19
How Java represents arrays
 Consider
int[] a = { 1, 2, 3, 4, 5 };
Array
- length = 5
a
- data =
1
1
2
2
3
4
3
5
4
5
+…
20
More about how Java represents Arrays
 Consider
int[] a;
int[] b = null;
int[] c = new int[5];
int[] d = { 1, 2, 3, 4, 5 };
a = c;
d = c;
a
-
b
null
c
0
0
0
0
0
d
1
2
3
4
5
21
Searching for a value
System.out.println("Enter search value (number): ");
int key = stdin.nextInt();
int i;
for (i
i = 0
0; i < data.length
data.length; ++i
++i) {
if (key == data[i]) {
break;
}
}
0
1
2
data
4
9
5
key
5
i
0
1
2
if (i != data.length) {
System.out.println(key + " is the " + i
+ "-th element");
}
else {
System.out.println(key + " is not in the list");22
}
Searching for the minimum value
 Segment
int minimumSoFar = sample[0];
for (int i = 1; i < sample.length; ++i) {
if (sample[i] < minimumSoFar) {
minimumSoFar = sample[i];
}
}
23
ArrayTools.java – outline
public class ArrayTools {
// class constant
private static final int MAX_LIST_SIZE = 1000;
// sequentialSearch(): examine unsorted list for key
public static int sequentialSearch[] data, int key) { ...
// putList (): prints list to screen
public static void putList(int[] data) { ...
// getList(): extract and return up to MAX_LIST_SIZE values
public static int[] getList() throws IOException { ...
// reverse(): reverses the order of the element values
public static void reverse(int[] list) { ...
// binarySearch(): examine sorted list for a key
public static int binarySearch(char[] data, char key) { ...
}
24
ArrayTools.java method putList()
public static void putList(int[] data) {
for (int i = 0; i < data.length; ++i) {
System.out.println(data[i]);
}
}
 Consider
int[] score = { 6, 9, 82, 11, 29, 85, 11, 28, 91 };
putList(score);
25
ArrayTools.java method getList()
public static int[] getList() {
Scanner stdin = new Scanner (System.in);
int[] buffer = new int[MAX_LIST_SIZE];
int listSize = 0;
for (int i = 0; (i < MAX_LIST_SIZE) &&
stdin.hasNext(); ++i) {
buffer[i] = stdin.nextInt();
++listSize;
}
int[] data = new int[listSize];
for (int i = 0; i < listSize; ++i) {
data[i] = buffer[i];
}
return data;
}
26
ArrayTools.java method reverse()
public static void reverse(int[] data) {
int[] clone = data.clone();
for ( int i = 0; i < clone.length; ++i ) {
data[i] = clone[clone.length-1-i];
}
}
 Consider
int[] foo = { 1, 2, 3, 4, 5 };
reverse (foo);
putList (foo);
27
Demo.java
public class Demo {
// main(): application entry point
public static void main(String[] args) {
System.out.println("");
System.out.println("Enter list of integers:");
int[] numbers = ArrayTools.getList();
System.out.println("");
System.out.println("Your list");
ArrayTools.putList(numbers);
ArrayTools.reverse(numbers);
System.out.println("");
System.out.println("Your list in reverse");
ArrayTools.putList(numbers);
System.out.println();
}
}
28
ArrayTools.java method sequentialSearch()
public static int sequentialSearch(int[] data, int key) {
for (int i = 0; i < data.length; ++i) {
if (data[i] == key) {
return i;
}
}
key
11
return -1;
}
data
0
1
2
3
4
5
6
7
8
6
9
82
11
29
85
11
29
91
 Consider
int[] score = { 6, 9, 82, 11, 29, 85, 11, 28, 91 };
int i1 = sequentialSearch(score, 11);
30
int i2 = sequentialSearch(score, 30);
Yale vs. Harvard

Web references: http://www.harvardsucks.org/,
http://www.yaledailynews.com/article.asp?AID=27506
31
Sorting
 Problem
 Arranging elements so that they are ordered according to
some desired scheme
 Standard is non-decreasing order
 Why don't we say increasing order?
 Major tasks
 Comparisons of elements
 Updates or element movement
32
Selection sorting
 Algorithm basis
 On iteration i, a selection sorting method:
 Finds the element containing the ith smallest value of
its list v and exchanges that element with v[i]
 Example – iteration 0
 Swaps smallest element with v[0]
 This results in smallest element being in the correct place
for a sorted result
v
0
1
2
3
4
5
6
‘Q'
'W'
‘E'
'R'
'T'
'Y'
'U'
7
'I'
8
9
'O'
'P'
33
Selection sorting
 Algorithm basis
 On iteration i, a selection sorting method:
 Finds the element containing the ith smallest value of
its list v and exchanges that element with v[i]
 Example – iteration 0
 Swaps smallest element with v[0]
 This results in smallest element being in the correct place
for a sorted result
v
0
1
2
3
4
5
6
‘Q'
'W'
‘E'
'R'
'T'
'Y'
'U'
7
'I'
8
9
'O'
'P'
34
Selection sorting
 Algorithm basis
 On iteration i, a selection sorting method:
 Finds the element containing the ith smallest value of
its list v and exchanges that element with v[i]
 Example – iteration 0
 Swaps smallest element with v[0]
 This results in smallest element being in the correct place
for a sorted result
v
0
1
2
3
4
5
6
'E'
'W'
'Q'
'R'
'T'
'Y'
'U'
7
'I'
8
9
'O'
'P'
35
Selection sorting
 Algorithm basis
 On iteration i, a selection sorting method:
 Finds the element containing the ith smallest value of
its list v and exchanges that element with v[i]
 Example – iteration 1
 Swaps second smallest element with v[1]
 This results in second smallest element being in the
correct place for a sorted result
v
0
1
2
3
4
5
6
'E'
'W'
'Q'
'R'
'T'
'Y'
'U'
7
'I'
8
9
'O'
'P'
36
Selection sorting
 Algorithm basis
 On iteration i, a selection sorting method:
 Finds the element containing the ith smallest value of
its list v and exchanges that element with v[i]
 Example – iteration 1
 Swaps second smallest element with v[1]
 This results in second smallest element being in the
correct place for a sorted result
0
v
'E'
1
'I'
2
3
4
5
6
7
8
9
'Q'
'R'
'T'
'Y'
'U'
'W'
'O'
'P'
37
ArrayTools.java selection sorting
public static void selectionSort(int[] v) {
for (int i = 0; i < v.length-1; ++i) {
// find the location of the ith smallest element
int spot = i;
for (int j = i+1; j < v.length; ++j) {
if (v[j] < v[spot]) { // is current location ok?
// update spot to index of smaller element
spot = j;
}
}
// spot is now correct, so swap elements
int rmbr = v[i];
v[i] = v[spot];
v[spot] = rmbr;
}
}
38
Iteration i
// find the location of the ith smallest element
int spot = i;
for (int j = i+1; j < v.length; ++j) {
if (v[j] < v[spot]) // is spot ok?
// update spot with index of smaller element
spot = j;
}
// spot is now correct, swap elements v[spot] and v[i]
39
Quick survey

a)
b)
c)
d)
How are we doing with arrays?
Very well
With some review, I’ll be good
Not really
Not at all
40
April Fools Day Jokes

Privacy policy
From time to time, in order to improve Google Gulp's
usefulness for our users, Google Gulp will send packets
of data related to your usage of this product from a
wireless transmitter embedded in the base of your
Google Gulp
bottle to the GulpPlex™, a heavily guarded,
http://www.google.com/googlegulp/
massively parallel server farm whose location is known
(orSchmidt,
do a Google
search
only to Eric
who carries
its for
GPS‘gulp’)
coordinates on
a 64-bit-encrypted smart card locked in a stainless-steel
briefcase handcuffed to his right wrist. No personally
identifiable information of any kind related to your
consumption of Google Gulp or any other current or
future Google Foods product will ever be given, sold,
bartered, auctioned off, tossed into a late-night poker
pot, or otherwise transferred in any way to any
untrustworthy third party, ever, we swear. See our
41
Privacy Policy.
Google Maps…
43
Binary search
 Given a list, find a specific element in the list
 List MUST be sorted!
 Each time it iterates through, it cuts the list in half
 A binary search is MUCH faster than a sequential
search
44
Binary search use

The ‘BS’ in BSDemo is for Binary Search, mind you
public class BSDemo {
public static void main(String[] args) {
int[] numbers = { 9, 3, 1, 8, 4, 6, 10, 2 };
System.out.println ("The original list of numbers:");
ArrayTools.putList(numbers);
System.out.println();
ArrayTools.selectionSort(numbers);
System.out.println ("The sorted list of numbers:");
ArrayTools.putList(numbers);
System.out.println();
System.out.println
System.out.println
System.out.println
System.out.println
System.out.println
System.out.println
System.out.println
("Searching
("Searching
("Searching
("Searching
("Searching
("Searching
("Searching
for
for
for
for
for
for
for
0: " + ArrayTools.binarySearch(numbers, 0));
1: " + ArrayTools.binarySearch(numbers, 1));
4: " + ArrayTools.binarySearch(numbers, 4));
5: " + ArrayTools.binarySearch(numbers, 5));
6: " + ArrayTools.binarySearch(numbers, 6));
10: " + ArrayTools.binarySearch(numbers, 10));
11: " + ArrayTools.binarySearch(numbers, 11));
}
}
45
Binary search use demo…
46
Binary search
public static int binarySearch (int[] data, int key) {
int i = 0;
// left endpoint of search interval
int j = data.length-1; // right endpoint of search interval
while ( i < j ) {
int m = (i+j)/2;
if ( key > data[m] ) {
i = m+1;
} else {
j = m;
}
}
if ( key == data[i] ) {
return i;
} else {
return -1;
}
47
}
Binary search, take 1
public static int binarySearch (int[] data, int key) {
int i = 0;
int j = data.length-1;
data
i
while ( i < j ) {
int m = (i+j)/2;
if ( key > data[m] ) {
i = m+1;
} else {
j = m;
}
}
if ( key == data[i] ) {
return i;
} else {
return -1;
}
key
returns:
a0
a1
a2
a3
a4
a5
a6
a7
a8
a9
2
4
6
8
10
12
14
16
18
20
0
5
6
m
4
7
6
5
j
9
7
6
14
6
48
Binary search, take 2
public static int binarySearch (int[] data, int key) {
int i = 0;
int j = data.length-1;
data
i
while ( i < j ) {
int m = (i+j)/2;
if ( key > data[m] ) {
i = m+1;
} else {
j = m;
}
}
if ( key == data[i] ) {
return i;
} else {
return -1;
}
key
returns:
a0
a1
a2
a3
a4
a5
a6
a7
a8
a9
2
4
6
8
10
12
14
16
18
20
0
5
m
4
7
6
j
9
7
15
-1
49
Binary search
 A somewhat alternative view of what a binary search does…
50
How long does a binary search take?
 Given a array of 64 elements
 1st iteration cuts the array to 32
 2nd iteration cuts the array to 16
 3rd to 8
 4th to 4
 5th to 2
 6th to 1
 Given a array of 1024 elements
 1st iteration cuts the array to 512
 ...
 10th iteration cuts the list to 1 element
 Thus, the binary search takes log2 n iterations!
 Where n is the size of the array
51
Binary search vs. sequential search
 Assume the array has n elements
 Sequential search can take (in the worst-case) n iterations to
find the element
 Binary search can take (in the worst case) log2 n iterations to
find the element
 Consider a list of 1 million elements
 Binary search takes about 20 iterations
 Sequential search takes 1,000,000 iterations
 Consider a list of 1 trillion elements
 Binary search takes about 40 iterations
 Sequential search takes 1,000,000,000,000 iterations52
Quick survey

a)
b)
c)
d)
How are we doing with binary searches?
Very well
With some review, I’ll be good
Not really
Not at all
53
Becoming an IEEE author
54
55
Multidimensional arrays
 Many problems require information be organized as a twodimensional or multidimensional list
 Examples
 Matrices
 Graphical animation
 Economic forecast models
 Map representation
 Time studies of population change
 Microprocessor design
56
Example
 Segment
int[][] m = new int[3][];
m[0] = new int[4];
m[1] = new int[4];
m[2] = new int[4];
 Produces
m[0]
m
m[1]
m[2]
m[2][0]
m
0
m[0][0]
0
m[0][1]
When an array is
created, each
value is initialized!
0
m[0][2]
0
m[0][3]
m[2][1]
m[2][2]
m[2][3]
0
0
0
0
0
0
0
0
m[1][0]
m[1][1]
m[1][2]
m[1][3]
57
Example
 Alternative
int[][] m = new int[3][4];
 Produces
m[0]
m[1]
m[2]
m[2][0]
m
0
m[0][0]
0
m[0][1]
0
m[0][2]
0
m[0][3]
m[2][1]
m[2][2]
m[2][3]
0
0
0
0
0
0
0
0
m[1][0]
m[1][1]
m[1][2]
m[1][3]
58
Multidimensional array visualization
 A multi-dimensional array declaration (either one):
int[][] m = new int[3][4];
 How we visualize it:
0
0
0
0
0
0
0
0
0
0
0
0
or
0
0
0
0
0
0
0
0
0
0
0
0
59
Example
 Segment
for (int r = 0; r < m.length; ++r) {
for (int c = 0; c < m[r].length; ++c) {
System.out.print("Enter a value: ");
m[r][c] = stdin.nextInt();
}
}
60
Example
 Segment
String[][]
s[0] = new
s[1] = new
s[2] = new
s[3] = new
 Produces
s[0]
s = new String[4][];
String[2];
String[2];
String[4];
String[3];
s[1]
s[2]
s[3]
null
null null
s[3][0] s[3][1] s[3][2]
s
null
null null
null
s[2][0] s[2][1] s[2][2] s[2][3]
null null
s[0][0] s[0][1]
null
null
61
s[1][0] s[1][1]
Multidimensional array visualization
 Segment
String[][]
s[0] = new
s[1] = new
s[2] = new
s[3] = new
 Produces
s = new String[4][];
String[2];
String[2];
String[4];
String[3];
0
0
0
0
0
0
0
0
0
0
or
0
0
0
0
0
0
0
0
0
0
0
 Called a “ragged”
array
0
62
Example
 Segment
int c[][] = {{1, 2}, {3, 4}, {5, 6}, {7, 8, 9}};
 Produces
c[0]
c[1]
c[2]
7
c[3]
8
9
c[3][0] c[3][1] c[3][2]
c
5
6
c[2][0] c[2][1]
1
2
c[0][0] c[0][1]
3
4
c[1][0] c[1][1]
63
Matrices
 A two-dimensional array is sometimes known as a matrix
because it resembles that mathematical concept
 A matrix a with m rows and n columns is represented
mathematically in the following manner
a1  1 a 1 2  a 1 n
a2  1 a 2 2  a 2 n


am  1 a m 2  a m n
64
Matrix addition
 Definition C = A + B
 cij = aij + bij
 cij is sum of the elements in the same row and column of
A and B
65
Matrix addition
public static double[][] add(double[][] a, double[][] b) {
// determine number of rows in solution
int m = a.length;
// determine number of columns in solution
int n = a[0].length;
// create the array to hold the sum
double[][] c = new double[m][n];
// compute the matrix sum row by row
for (int i = 0; i < m; ++i) {
// produce the current row
for (int j = 0; j < n; ++j) {
c[i][j] = a[i][j] + b[i][j];
}
}
return c;
}
66
Quick survey

a)
b)
c)
d)
I felt I understood the material in this slide set…
Very well
With some review, I’ll be good
Not really
Not at all
67
Quick survey

a)
b)
c)
d)
The pace of the lecture for this slide set was…
Fast
About right
A little slow
Too slow
68
Quick survey

a)
b)
c)
d)
How interesting was the material in this slide
set? Be honest!
Wow! That was SOOOOOOO cool!
Somewhat interesting
Rather boring
Zzzzzzzzzzz
69
Today’s demotivators
70
Descargar

Quiz About [Your topic] - University of Virginia