Survey
* Your assessment is very important for improving the workof artificial intelligence, which forms the content of this project
Download element-type
Document related concepts
no text concepts found
Transcript
Chapter 10 – Arrays and ArrayLists
Array
Array
Array
Array
Array
Array
Basics
Declaration
Creation
Element Initialization
Default Values
length Property
Partially Filled Arrays
Copying an Array
Histograms
Searching an Array
Sorting an Array
1
Chapter 10 – Arrays and ArrayLists
Selection Sort
Two-Dimensional Arrays
Arrays of Objects
The ArrayList Class
How to Create an ArrayList Object
Adding Elements to an ArrayList Object
How to Access an Element Within an ArrayList
How to Update an ArrayList Object
Additional ArrayList Methods
Printing or Concatenating an ArrayList
Storing Primitives in an ArrayList
ArrayList Example Using Anonymous Objects and
the For-Each Loop
ArrayList Objects Versus Standard Arrays
2
Array Basics
A class stores a group of related data, and it stores the methods that operate on
that data.
An array is a limited version of a class.
3
Like a class, an array also stores a group of related data, but an array does not store
methods.
Another difference between an array and a class is that an array's data must all be of the
same type.
Here's a picture of an array that holds a list of speed-dial phone numbers. Each of
the five boxes is called an array element and each box stores one phone number.
phoneList
8167412000
first speed-dial phone number
2024561111
7852963232
8008675309
0035318842133
last speed-dial phone number
4
Array Basics
A class uses dot notation to access one of its members.
On the other hand, an array uses square brackets around an index to
access one of its elements.
The rightmost column shows how to access each of the 5 elements in
the phoneList array.
Note that the index values start at 0 instead of 1 and the last index
value is one less than the number of elements in the array.
index
phoneList
how to access
each element
0
8167412000
phoneList[0]
1
2024561111
phoneList[1]
2
7852963232
phoneList[2]
3
8008675309
phoneList[3]
4
0035318842133
phoneList[4]
5 elements
Array Basics
Here's how you can change the first phone number to
2013434:
phoneList[0] = 2013434;
And here's how you can print the second phone
number:
System.out.println(phoneList[1]);
5
Array Basics
/*************************************************************
* SpeedDialList.java
* Dean & Dean
*
* This program creates a cell phone speed-dial phone number
* list and prints the created list.
*************************************************************/
import java.util.Scanner;
public class SpeedDialList
{
public static void main(String[] args)
{
Scanner stdIn = new Scanner(System.in);
long[] phoneList; // list of phone numbers
int sizeOfList;
// number of phone numbers
long phoneNum;
// an entered phone number
System.out.print(
"How many speed-dial numbers would you like to enter? ");
sizeOfList = stdIn.nextInt();
phoneList = new long[sizeOfList];
6
Array Basics
for (int i=0; i<sizeOfList; i++)
{
System.out.print("Enter phone number: ");
phoneNum = stdIn.nextLong();
phoneList[i] = phoneNum;
} // end for
System.out.println("\nSpeed Dial List:");
for (int i=0; i<sizeOfList; i++)
{
System.out.println((i + 1) + ". " + phoneList[i]);
} // end for
} // end main
} // end class SpeedDialList
7
Array Declaration
An array is a variable and, as such, it must be declared
before you can use it.
Array declaration syntax:
<element-type>[] <array-variable>;
Array declaration examples:
int[] ids;
double[] workHours;
String[] names;
9
Array Creation
10
In Java, arrays are objects.
As with all objects, arrays are created/instantiated with
the new operator.
Syntax for creating and assigning an array object:
<array-variable> = new <element-type>[<array-size>];
<element-type> indicates the type of
each element in the array
Example:
long[] phoneList;
phoneList = new long[10];
array creation
<array-size> indicates the
number of elements in the array
Array Creation
It's legal to combine an array's declaration, creation,
and assignment operations. Here's an example:
long[] phoneList = new long[10];
Provide a single statement that declares, creates, and
assigns a 100-element array that stores book titles.
11
Array Element Initialization
An array initializer is a single statement made up of an
array declaration, creation, and {} assignment.
Array element initialization syntax:
<element-type>[] <array-name> = {<element-values-list>};
Array element initialization example:
String[] students = {"Christopher", "TJ", "Ellie"};
When an array initializer is used, the size of the array
equals the number of elements in the initialization list.
Note that with an array initializer, you creating an
array object without using the new operator.
12
13
Array Default Values
An array is an object and an array's elements are the instance
variables for an array object. As such, an array's elements get
default values when the array is instantiated, the same as any
other instance variables get default values.
Here are the default values for array elements (they're also the
default values for all instance variables):
Array element's type
Default value
integer
0
floating point
0.0
boolean
false
reference
null
Array length Property
14
Suppose you have a five-element colors array that's been
initialized like this:
String[] colors = {"blue", "gray", "lime", "teal", "yellow"};
Here's how to print such an array:
for (int i=0; i<colors.length; i++)
{
System.out.println(colors[i]);
}
To obtain an array's length, specify array name, dot, and then
length.
Note that length is used in two different ways:
Note how an array object's length
property gets the array's size.
length is a String method
length is an array property
Mnemonic acronym to help you remember when to use
parentheses with length:
ANSY (arrays no, strings yes)
Array length Property and Partially Filled Arrays
import java.util.Scanner;
public class SpeedDialList2
{
Array length property
public static void main(String[] args) does not use ( )'s.
{
Scanner stdIn = new Scanner(System.in);
String[] phoneList = new String[100]; // phone numbers
int filledElements = 0;
// number of phone numbers
String phoneNum;
// an entered phone number
System.out.print("Enter phone number (or q to quit): ");
phoneNum = stdIn.nextLine();
String length
while (!phoneNum.equalsIgnoreCase("q") &&
method uses ( )'s.
filledElements < phoneList.length)
{
if (phoneNum.length() < 1 || phoneNum.length() > 16)
{
System.out.println("Invalid entry." +
" Must enter between 1 and 16 characters.");
}
15
Array length Property and Partially Filled Arrays
else
{
phoneList[filledElements] = phoneNum;
filledElements++;
}
System.out.print("Enter phone number (or q to quit): ");
phoneNum = stdIn.nextLine();
} // end while
System.out.println("\nSpeed Dial List:");
for (int i=0; i<filledElements; i++)
{
System.out.println((i + 1) + ". " + phoneList[i]);
} // end for
} // end main
} // end class SpeedDialList2
16
Partially Filled Arrays
A partially filled array is when you use some of an
array's elements, but not all.
If you have a partially filled array, you have to keep
track of the number of filled elements in the array so
you can process the filled elements differently from
the non-filled elements.
In the SpeedDialList2 program, note how the
filledElements variable keeps track of the
number of phone numbers in the array.
17
Copying an Array
As with all objects and their associated reference
variables, if you assign one array reference variable to
another array reference variable, both array reference
variables then point to the same single array object.
What's the problem with that scenario? More
specifically, what's wrong with the following code if the
goal is to make a copy of arr1?
arr2 = arr1;
18
Copying an Array
Usually when you make a copy of an array, you'll want the copy
and the original to point to different array objects. To do that,
assign array elements one at a time.
For example, suppose you use arrays to hold a store's prices, one
array for each month's prices. And you'd like to copy January's
price array into February's price array and make a change in
February's second price. The program on the next slide does that
by assigning array elements one at a time. Here's the program's
output:
Jan
1.29
9.99
22.00
4.55
7.35
6.49
Feb
1.29
10.99
22.00
4.55
7.35
6.49
19
Copying an Array
public class ArrayCopy
{
public static void main(String[] args)
{
double[] pricesJanuary =
{1.29, 9.99, 22.50, 4.55, 7.35, 6.49};
double[] pricesFebruary = new double[pricesJanuary.length];
for (int i=0; i<pricesJanuary.length; i++)
{
pricesFebruary[i] = pricesJanuary[i];
}
pricesFebruary[1] = 10.99;
System.out.printf("%7s%7s\n", "Jan", "Feb");
for (int i=0; i<pricesJanuary.length; i++)
{
System.out.printf("%7.2f%7.2f\n",
pricesJanuary[i], pricesFebruary[i]);
}
} // end main
} // end class ArrayCopy
20
Histograms
A histogram is a graph that displays quantities for a
set of categories. It indicates category quantities with
bars - shorter bars equate to smaller quantities, longer
bars equate to larger quantities.
For example, the histogram on the next slide shows
quantities of frozen desserts produced in the United
States in 2003.
21
Histograms
22
Histograms
Problem Description:
Suppose you have three coins. When you flip all three, you're
curious how likely it is you'll get zero heads, how likely it is
you'll get one head, how likely it is you'll get two heads, and
how likely it is you'll get three heads. In other words, you're
curious about the frequency distribution for the number of
heads.
Solution:
Write a main method that simulates throwing the three coins
a million times.
Print the simulation results in the form of a histogram:
For each of the four cases (zero heads, one head, etc.), print a
bar that represents the number of times the case occurred.
To mimic a bar, print a certain number of *'s where each *
represents 1% of the total number of simulation iterations.
23
Histograms
Output for the coin-flip program:
Number of times each head count occurred:
0 124685 ************
1 374759 *************************************
2 375420 **************************************
3 125136 *************
Program implementation tips:
Use a four-element frequency array to keep track of the number
of times each head-count value occurs. The frequency[0]
element holds the number of times none of the three coins lands
heads up. The frequency[1] element holds the number of times
one of the three coins lands heads up.
Each element in the frequency array is called a "bin."
After each simulation iteration, add 1 to the appropriate bin. For
example, increment the frequency[3] bin if all three of the coins
land heads up.
24
Histograms
public class CoinFlips
{
public static void main(String[] args)
{
final int NUM_OF_COINS = 3;
// number of coins that are flipped
final int NUM_OF_REPS = 1000000; // total number of repetitions
// The frequency array holds the number of times a particular number
// of heads occurred.
int[] frequency;
int heads;
// number of heads in the current group of flips
float fractionOfReps; // Number of times a particular head count occurred
// divided by total number of repetitions.
int numOfAsterisks;
// Number of asterisks in histogram for a
// particular head count.
frequency = new int[NUM_OF_COINS + 1];
for (int rep=0; rep<NUM_OF_REPS; rep++)
{
// perform a group of flips
heads = 0;
for (int i=0; i<NUM_OF_COINS; i++)
{
heads += (int) (Math.random() * 2);
}
frequency[heads]++;
// update appropriate bin
} // end for
25
26
Histograms
heads
1st
group of flips
2nd group of flips
0
0
0
1
1
012
0
2
01
1
3
0
2
3rd
group of flips
frequency
0
1
0
···
Histograms
System.out.println(
"Number of times each head count occurred:");
for (heads=0; heads<=NUM_OF_COINS; heads++)
{
System.out.print(
" " + heads + " " + frequency[heads] + " ");
fractionOfReps = (float) frequency[heads] / NUM_OF_REPS;
numOfAsterisks = Math.round(fractionOfReps * 100);
for (int i=0; i<numOfAsterisks; i++)
{
System.out.print("*");
}
System.out.println();
} // end for
} // end main
} // end class CoinFlips
27
Searching an array
Often, you'll need to determine whether an array
contains a particular value. Here's the pseudocode
algorithm for conducting a sequential search for a
particular value within a list array:
i←0
while i < number of filled elements
if list[i] equals the searched-for value
<do something and stop the loop>
increment i
28
Searching an array
Problem description:
Write a helper method named findStudent that searches
for an id value within an array of student id's.
The findStudent method should receive an id parameter
and return the index value of id's location within a
studentIds array instance variable.
If id's value is not found, then return -1.
As always, use appropriate access modifiers (public
vs. private, class method vs. instance method).
29
Sorting an Array
Sorting is a very common task in programming.
Examples:
Sort e-mails in an inbox – by date, by sender
Sort songs – by title, by author
Sort student records – by student ID
31
Selection Sort
32
There are many different sorting algorithms with varying degrees
of complexity and efficiency. Since this is your first exposure to
sorting, we'll cover a simple algorithm - the selection sort
algorithm. Here it is:
for (i0; i<list's_length; i++)
find the smallest value in list from list[i]
down to the bottom of the list
swap the found value with list[i]
list (original)
list (sorted)
0
5
-3
-3
-3
-3
1
10
10
2
2
2
2
-3
5
5
5
5
3
20
20
20
20
10
4
2
2
10
10
20
Sorting an Array
You could include a sorting method in every class that
needs sorting functionality.
For example, you could include:
A studentSort method in a Students class that sorts students
by student id.
A bookSort method in a Books class that sorts books by ISBN
number.
A productSort method in a Products class that sorts products
by product id.
But suppose that you want to make a generic sorting
method that receives an array as a parameter (e.g.,
studentIds, bookISBNs, or productIds) and
sorts it.
33
Sorting an Array
To make the sorting method generic so that it can be
used by multiple classes, put the sort method in a
utility class.
A utility class is a class with general-purpose methods
that other classes can easily use. To make the
methods easy to use, use class methods (as opposed
to instance methods).
Why would it be easy for other classes to use the sort
method if the sort method is implemented as a class
method?
34
Sorting an Array
If you make the sort method an instance method, then you'll be
required to instantiate the sort method's enclosing class prior to
calling the sort method. For example, assuming the sort
method's enclosing class is named Sort:
Sort s = new Sort();
s.sort(studentIds);
On the other hand, if you make the sort method a class method,
then you are not required to instantiate the sort method's
enclosing class prior to calling the sort method. Instead, you
simply need to prefix the sort method call with the class name
and then a dot. For example:
Sort.sort(studentIds);
Thus, in the interest of simplicity and elegance, let's make the
sort method a class method.
35
Selection Sort
public class Sort
{
public static void sort(int[] list)
{
int j;
for (int i=0; i<list.length-1; i++)
{
j = indexOfNextSmallest(list, i);
swap(list, i, j);
}
} // end sort
private static int indexOfNextSmallest(int[] list, int startIndex)
{
int min = list[startIndex];
int minIndex = startIndex;
for (int i=startIndex+1; i<list.length; i++)
{
if (list[i] < min)
{
min = list[i];
minIndex = i;
}
} // end for
return minIndex;
} // end indexOfNextSmallest
36
Selection Sort
private static void swap(int[] list, int i, int j)
{
int temp;
temp = list[i];
list[i] = list[j];
list[j] = temp;
} // end swap
} // end Sort
public class SortDriver
{
public static void main(String[] args)
{
int[] studentIds = {3333, 1234, 2222, 1000};
Sort.sort(studentIds);
for (int i=0; i<studentIds.length; i++)
{
System.out.print(studentIds[i] + " ");
}
} // end main
} // end SortDriver
37
Two-Dimensional Arrays
If you have a group of related data that's organized in a table
format, consider using a two-dimensional array.
Two-dimensional arrays use the same basic syntax as onedimensional arrays except for a second pair of []'s.
the first index identifies the row and the second index identifies
the column position within a row.
For example, here's a two-row by three-column array named x:
x
column
indexes
row
indexes
how to access each element
0
1
2
0
8
-2
4
x[0][0]
x[0][1] x[0][2]
1
1
0
5
x[1][0]
x[1][1] x[1][2]
38
39
Two-Dimensional Arrays
As with one-dimensional arrays, there are two ways to
assign values into a two-dimensional array’s elements:
1) an array initializer, 2) assignment statements.
Here’s how you can declare the previous slide's x
array and assign values into its elements, using an
array initializer:
int[][] x = {{8,-2,4}, {1,0,5}};
initializer for a 2-row
by 3-column array
You can use the array initializer technique only if you
know the assigned values when you first declare the
array. Otherwise, you need to provide array element
assignment statements that are separate from the
array's declaration and creation.
Two-Dimensional Arrays
The following code fragment declares and creates the
x array in one statement, and assigns values to x's
elements in a separate statement.
int[][] x = new int[2][3];
Declare and create a 2-row
by 3-column array.
for (int i=0; i<x.length; i++)
{
for (int j=0; j<x[0].length; j++)
{
System.out.print(
"Enter value for row " + i + ", col " + j);
x[i][j] = stdIn.nextInt();
Assign a value to
} // end for j
the element at
} // end for i
row i column j.
40
Two-Dimensional Arrays
Bottom line: To loop through the rows in a two-dimensional
array, use <array-name>.length . And to loop through the
elements within a particular row, use <array-name>[0].length.
For example:
for (int i=0; i<x.length; i++)
{
for (int j=0; j<x[0].length; j++)
{
...
41
Two-Dimensional Arrays
42
The upcoming FlightTimes program:
Uses a two-dimensional array to store this table of flight times
between cities:
Wch
Top
KC
Col
StL
Wch
0
23
31
44
59
Top
22
0
9
27
41
KC
30
14
0
12
30
Col
42
25
11
0
14
StL
55
37
28
12
0
It takes 25 minutes
to fly from Topeka,
KS to Columbia, MO.
Contains a promptForFlightTime method that prompts
the user for a departure city and a destination city and prints
the flight time for that flight.
Contains a displayFlightTimesTable method that prints
the table.
Two-Dimensional Arrays
public class FlightTimesDriver
{
public static void main(String[] args)
{
int[][] flightTimes =
{
{0, 22, 30, 42, 55},
{23, 0, 14, 25, 37},
{31, 9, 0, 11, 28},
{44, 27, 12, 0, 12},
{59, 41, 30, 14, 0}
};
// Define terminals in the Kansas-Missouri region.
String[] cities = {"Wch", "Top", "KC", "Col", "StL"};
FlightTimes ft = new FlightTimes(flightTimes, cities);
System.out.println("\nFlight times for KansMo Airlines:\n");
ft.displayFlightTimesTable();
System.out.println();
ft.promptForFlightTime();
} // end main
} // end class FlightTimesDriver
43
Two-Dimensional Arrays
import java.util.Scanner;
public class FlightTimes
{
private int[][] flightTimes; // table of flight times
private String[] cities;
// names of cities in flightTimes table
public FlightTimes(int[][] ft, String[] c)
{
flightTimes = ft;
cities = c;
}
//********************************************
// This method prompts the user for departure and destination cities
// and prints the associated flight time.
public void promptForFlightTime()
{
Scanner stdIn = new Scanner(System.in);
int departure;
// index for departure city
int destination; // index for destination city
44
Two-Dimensional Arrays
for (int i=0; i<cities.length; i++)
{
System.out.println(i+1 + " = " + cities[i]);
}
System.out.print("Enter departure city's number: ");
departure = stdIn.nextInt() - 1;
System.out.print("Enter destination city's number: ");
destination = stdIn.nextInt() - 1;
System.out.println("Flight time = " +
flightTimes[departure][destination] + " minutes.");
} // end promptForFlightTime
//********************************************
// This method prints a table of all flight times.
<Insert displayFlightTimesTable method here.>
} // end class FlightTimes
45
47
Arrays of Objects
Suppose you need to keep track of total sales for each sales
clerk in a department store.
In the following clerks array, each array element holds a
reference for a SalesClerk object.
Each SalesClerk object holds a sales clerk's name and a totalsales value for the sales clerk.
If sales clerk Amanda sells two items for $55.45 and $22.01,
then you'd like to store 77.46 for her total-sales value.
clerks
Daniel, 6.25
clerks[0]
clerks[1]
Josh, 58.12
clerks[2]
clerks[3]
null
Amanda, 77.46
48
Arrays of Objects
Show how the clerks array gets filled with the input
shown below.
input
filledElements
Daniel
0
6.25
Josh
58.12
clerks
null
null
Amanda
null
40
null
Daniel
-6.25
Josh
12.88
Arrays of Objects
import java.util.Scanner;
public class SalesClerksDriver
{
public static void main(String[] args)
{
Scanner stdIn = new Scanner(System.in);
SalesClerks clerks = new SalesClerks(2);
String name;
System.out.print("Enter clerk's name (q to quit): ");
name = stdIn.nextLine();
while (!name.equals("q"))
{
System.out.print("Enter sale amount: ");
clerks.addSale(name, stdIn.nextDouble());
stdIn.nextLine();
// flush newline
System.out.print("Enter clerk's name (q to quit): ");
name = stdIn.nextLine();
} // end while
clerks.dumpData();
} // end main
} // end SalesClerksDriver
49
Arrays of Objects
class SalesClerks
{
private SalesClerk[] clerks;
private int filledElements = 0;
// contains names and sales
// number of elements filled
//***********************************************************
public SalesClerks(int initialSize)
{
clerks = new SalesClerk[initialSize];
} // end SalesClerks constructor
//***********************************************************
//
//
//
//
Process a sale for the clerk whose name is passed in.
If the name is not already in the clerks array,
create a new object and insert a reference to it in the
next array element, doubling array length if necessary.
public void addSale(String name, double amount)
{
int clerkIndex = findClerk(name);
if (clerkIndex == -1) // add a new clerk
{
if (filledElements == clerks.length)
{
doubleLength();
}
50
Arrays of Objects
clerkIndex = filledElements;
clerks[clerkIndex] = new SalesClerk(name);
filledElements++;
} // end if
clerks[clerkIndex].adjustSales(amount);
} // end addSale
//**********************************************************
// Print all the data - sales clerk names and sales.
public void dumpData()
{
for (int i=0; i<filledElements; i++)
{
System.out.printf("%s: %6.2f\n",
clerks[i].getName(), clerks[i].getSales());
}
} // end dumpData
//**********************************************************
51
Arrays of Objects
// Search for the given name. If found, return the index.
// Otherwise, return -1.
The arraycopy method
copies the first argument's
array (starting at the
second argument's
position) to the third
argument's array (starting
at the fourth argument's
position). The fifth
//**********************************************************
argument specifies the
number of elements that
// Double the length of the array.
are to be copied.
private void doubleLength()
private int findClerk(String name)
{
for (int i=0; i<filledElements; i++)
{
if (clerks[i].getName().equals(name))
{
return i;
}
} // end for
return -1;
} // end findClerk
{
SalesClerk[] clerks2 = new SalesClerk[2 * clerks.length];
System.arraycopy(clerks, 0, clerks2, 0, clerks.length);
clerks = clerks2;
} // end doubleLength
} // end class SalesClerks
52
Arrays of Objects
public class SalesClerk
{
private String name;
private double sales = 0.0;
// sales clerk's name
// total sales for clerk
//*******************************************************
public SalesClerk(String name)
{
this.name = name;
}
//*******************************************************
public String getName()
{
return name;
}
public double getSales()
{
return sales;
}
//*******************************************************
// Adjust clerk's total sales by adding the passed-in sale.
public void adjustSales(double amount)
{
sales += amount;
}
} // end class SalesClerk
53
Arrays of Objects
Beware:
To create an array of objects, you must instantiate the array with
the new operator, and you must also instantiate each object that's
stored in the array with individual new operators.
For example, the SalesClerks constructor instantiates an array
of SalesClerk objects like this:
clerks = new SalesClerk[maxClerks];
You might think that since the above instantiation specifies
maxClerks number of SalesClerk objects, the JVM instantiates
all the SalesClerk objects.
On the contrary, the JVM only instantiates an array object and
each array element holds null.
To fill up the clerks array with SalesClerk objects, you need
to instantiate the SalesClerk objects individually.
54
The ArrayList Class
The ArrayList class provides the basic functionality
that comes with a standard array, plus it provides
additional functionality.
The basic functionality: An ArrayList stores an
ordered collection of values and allows access to the
values via an index.
The added functionality: An ArrayList grows and
shrinks dynamically by inserting and deleting
elements at any specified location.
55
How to Create an ArrayList Object
The ArrayList class is defined in the Java API's java.util
package, so for files that use the ArrayList class, import it
like this:
import java.util.ArrayList;
To initialize an ArrayList reference variable, use this syntax:
ArrayList<element-type> reference-variable =
new ArrayList<element-type>();
For example, here's how to initialize an ArrayList reference
variable named students:
ArrayList<Student> students = new ArrayList<Student>();
Compare the above ArrayList initialization to this standardarray initialization:
Student[] students = new Student[100];
56
How to Create an ArrayList Object
What are the syntax differences between the
ArrayList example and the standard-array
example? With the ArrayList example:
1.
2.
3.
Use angled brackets to specify the type for the elements.
<element-type> must be a class name (not a primitive).
Do not specify the number of elements (because
ArrayList objects start out with no elements).
57
Adding Elements to an ArrayList Object
To add an element to the end of an ArrayList
object, use this syntax:
ArrayList-reference-variable.add(item);
The item that's added must be the same type as the
type specified in the ArrayList's declaration.
Write a code fragment that creates this ArrayList
object:
colors
0
"red"
1
"green"
2
"blue"
58
Java API
API stands for application programming interface.
The Java API is the interface to Sun's huge library of pre-built
Java classes.
As a programmer, you don't need to know the internals of those
classes; you just need to know how to use them. Or said another
way, you just need to know how to interface with them.
To interface with them, you need to use their public methods.
To use a method, you need to know what type of argument(s) to
pass to it and what type of value it returns. A method's API
shows the method's parameters and its return type.
The standard way to show that information is to show the
method's heading. For example, here's the API heading for the
Math class's pow method:
public static double pow(double num, double power)
59
How to Access an Element Within an ArrayList
With standard arrays, you use square brackets to access and
update an element. ArrayList objects don't use square
brackets. Instead, they use a get method to access an element
and a set method to update an element.
Here's the API heading for the ArrayList's get method:
public E get(int index)
Semantics:
The index parameter specifies the position of the desired element
within the ArrayList calling object. As with standard arrays, the
first element is at position 0, the second element is at position 1, etc.
If index refers to a nonexistent element, then a runtime error
occurs.
If index is valid, then get returns the element at the specified
position.
60
How to Access an Element Within an ArrayList
Note the E return type for the ArrayList's get
method:
public E get(int index)
The E stands for element. It represents the data type
of the ArrayList's elements. It's the same as the
element-type specified in the ArrayList's
initialization:
ArrayList<element-type> reference-variable =
new ArrayList<element-type>();
61
How to Update an ArrayList Object
The set method allows you to assign a value to an
ArrayList element. Here's its API heading:
public E set(int index, E elem)
Semantics:
The index parameter specifies the position of the element
you're interested in.
If index refers to a nonexistent element, then a runtime
error occurs.
If index is valid, then set assigns the elem parameter to
the specified element, overlaying whatever was there
originally.
E represents the data type of the ArrayList's elements.
62
How to Update an ArrayList Object
Draw a picture of the colors ArrayList after this
code fragment executes:
String mixedColor;
ArrayList<String> colors = new ArrayList<String>();
colors.add("red");
colors.add("green");
colors.add("blue");
mixedColor =
colors.get(0) + colors.get(1);
colors.set(2, mixedColor);
63
Additional ArrayList Methods
public void add(int index, E elem)
public void clear()
Return true if the list contains no elements.
public E remove(int index)
Search for the first occurrence of the elem parameter within the list. If it's
found, return its index position. If it's not found, return -1.
public boolean isEmpty()
Remove all elements from the list.
public int indexOf(E elem)
Starting with the specified index position, shift the original elements to
higher-indexed positions. Then insert the elem parameter at the specified
index position.
Remove the element at the specified index position, shift all higher-indexed
elements to lower-indexed positions, and return the removed element.
public int size()
Return the number of elements in the list.
64
Example ArrayList Program
import java.util.ArrayList;
public class Survivor
{
public static void main(String[] args)
{
int loserIndex;
String loser;
ArrayList<String> tribe = new ArrayList<String>();
tribe.add("Richard");
tribe.add("Jerri");
tribe.add("Colby");
tribe.add("Amber");
tribe.add("Rupert");
loserIndex = (int) (Math.random() * 5);
loser = tribe.remove(loserIndex);
System.out.println("Sorry, " + loser +
". The tribe has spoken. You must leave immediately.");
System.out.println("Remaining: " + tribe);
} // end main
} // end Survivor
66
Printing or Concatenating an ArrayList
If you attempt to print or concatenate an ArrayList,
the ArrayList returns a comma-separated list of
ArrayList elements surrounded by square brackets
([]).
For example, in the Survivor program, if Colby is
removed, the last line prints this:
Remaining: [Richard, Jerri, Amber, Rupert]
67
Storing Primitives in an ArrayList
As mentioned previously, ArrayLists store references. For
example, in the Survivor program, tribe is an ArrayList of
strings, and strings are reference types.
If you need to store primitives in an ArrayList, you can't do it
directly, but you can do it if the primitives are wrapped up in
wrapper classes.
With the advent of Java 5.0, the "wrapping up" process is done
automatically behind the scenes. For ArrayLists, it's done
automatically as long as you use a wrapper class rather than a
primitive for your ArrayList declaration.
The StockAverage program on the next slide reads int stock
values and stores them in an ArrayList. After all stock values
are entered, the program calculates the average stock value.
Why is an ArrayList appropriate for calculating a stock
average?
68
Storing Primitives in an ArrayList
import java.util.Scanner;
import java.util.ArrayList;
public class StockAverage
Must be a
{
wrapper class,
public static void main(String[] args)
not a primitive.
{
Scanner stdIn = new Scanner(System.in);
ArrayList<Double> stocks = new ArrayList<Double>();
double stock;
// a stock value
double stockSum = 0;
// sum of stock values
System.out.print("Enter a stock value (-1 to quit): ");
stock = stdIn.nextDouble();
while (stock >= 0)
Automatic boxing
{
takes place here.
stocks.add(stock);
System.out.print("Enter a stock value (-1 to quit): ");
stock = stdIn.nextDouble();
} // end while
69
Storing Primitives in an ArrayList
for (int i=0; i<stocks.size(); i++)
{
stock = stocks.get(i);
stockSum += stock;
}
Where does
automatic
unboxing take
place?
if (stocks.size() != 0)
{
System.out.printf("\nAverage stock value = $%.2f\n",
stockSum / stocks.size());
}
} // end main
} // end class StockAverage
70
ArrayList Example Using Anonymous
Objects and the For-Each Loop
When storing objects in an ArrayList, it's common to create
an object and add it to the ArrayList all in the same
statement.
For example, the upcoming BearStore program stores Bear
objects in an ArrayList. In storing a Bear object, the
program creates a Bear object and adds it to the bears
ArrayList, all in the same statement:
bears.add(new Bear("Acme", "brown teddy"));
An anonymous object is an object that's instantiated but it's not
stored in a variable (and with no variable, there's no name for
it; thus, we say it's "anonymous").
71
ArrayList Example Using Anonymous
Objects and the For-Each Loop
import java.util.Scanner;
import java.util.ArrayList;
public class BearStore
{
ArrayList<Bear> bears = new ArrayList<Bear>();
//**********************************************************
// Fill store with specified number of standard teddy bears.
public void addStdBears(int num)
{
anonymous object
for (int i=0; i<num; i++)
{
bears.add(new Bear("Acme", "brown teddy"));
}
} // end addStdBears
72
ArrayList Example Using Anonymous
Objects and the For-Each Loop
//**********************************************************
// Fill store with specified number of customized bears.
public void addUserSpecifiedBears(int num)
{
for (int i=0; i<num; i++)
{
bears.add(getUserSpecifiedBear());
}
} // end addUserSpecifiedBears
//**********************************************************
// Prompt user for a customized bear name and return bear.
private Bear getUserSpecifiedBear()
{
Scanner stdIn = new Scanner(System.in);
String maker, type;
System.out.print("Enter bear's maker and type separated by a space: ");
maker = stdIn.next();
anonymous object
type = stdIn.next();
return new Bear(maker, type);
} // end getUserSpecifiedBear
73
ArrayList Example Using Anonymous
Objects and the For-Each Loop
//**********************************************************
// Print all the bears in the store.
public void displayInventory()
{
for (Bear bear : bears)
{
bear.display();
}
} // end displayInventory
//**********************************************************
public static void main(String[] args)
{
BearStore store = new BearStore();
store.addStdBears(3);
store.addUserSpecifiedBears(2);
store.displayInventory();
} // end main
} // end BearStore class
74
ArrayList Example Using Anonymous
Objects and the For-Each Loop
public class Bear
{
private final String MAKER; // bear's manufacturer
private final String TYPE; // type of bear
//**********************************************************
public Bear(String maker, String type)
{
MAKER = maker;
TYPE = type;
}
public void display()
{
System.out.println(MAKER + " " + TYPE);
}
} // end Bear class
75
Anonymous Objects
The bear store program contains several specific
examples of using anonymous objects. In general,
you'll see anonymous objects being used in two
circumstances:
Passing a newly created object into a method or
constructor. For example:
bears.add(new Bear("Acme", "brown teddy"));
Returning a newly created object from a method. For
example:
return new Bear(maker, type);
76
77
For-Each Loop
Note the for-each loop in the BearStore's
displayInventory method:
public void displayInventory()
{
for (Bear bear : bears)
{
bear.display();
}
} // end displayInventory
Read this as "for each
bear in bears, …"
For each iteration
through the loop,
bear accesses the
next element in the
bears ArrayList.
For-each loop syntax for an ArrayList:
for (<element-type> <element-name> : <ArrayList-reference-variable>)
For-Each Loop
Note that using the for-each loop is an option, not a
requirement. Here's an alternative
displayInventory implementation that uses a
standard for loop:
public void displayInventory()
{
for (int i=0; i<bears.size(); i++)
{
bears.get(i).display();
}
} // end displayInventory
The for-each loop implementation is preferred
because it is simpler.
78
For-Each Loop
Be aware that you can use for-each loops for more
than just ArrayLists. You can also use them with
standard arrays.
Here's a for-each loop example that prints the
numbers in a primes array:
int[] primes = {2, 3, 5, 7, 11};
for (int p : primes)
{
System.out.println(p);
}
79
For-Each Loop
For-each loop limitations:
It's new with Java 5.0, so it won't work with older compilers.
Can only be used with things that have elements - Java API
collections (the ArrayList is a Java API collection) and
arrays.
Here's a for-each loop example that prints the
numbers in a primes array:
int[] primes = {2, 3, 5, 7, 11};
for (int p : primes)
{
System.out.println(p);
}
80
For-Each Loop
Be aware of several issues when using a for-each loop:
It's new with Java 5.0, so it won't work with older compilers.
The for-each loop doesn't use an index variable to loop through its
elements. That can be a benefit in that it leads to less cluttered
code. But it's a drawback if there's a need for an index within the
loop.
For example, given the primes array in the previous slide,
which type of loop (standard or for-each) should you use to
print the following?
primes[0] = 1
primes[1] = 2
...
primes[3] = 11
As a practice exercise, provide a standard for loop that prints
the above and also provide a for-each loop that prints the
above.
81
82
ArrayList Objects Versus Standard Arrays
Benefits of an ArrayList Over Benefits of a Standard Array
Over an ArrayList
a Standard Array
1.
2.
It's easy to increase the size
of an ArrayList – just call
add.
It's easy for a programmer
to insert or remove an
element to or from the
interior of an ArrayList –
just call add or remove and
specify the element's index
position.
1.
2.
A standard array uses []'s to
access array elements
(which is easier than using
get and set methods).
A standard array is more
efficient with storing
primitive values.
