Chapter 10 Arrays and ArrayLists

1
Chapter 10 Arrays and ArrayLists

• Array Basics
• Array Declaration
• Array Creation
• Array Element Initialization
• Array Default Values
• Array length Property
• Partially Filled Arrays
• Copying an Array
• Searching an Array
• Sorting an Array
• Selection Sort

2
Chapter 10 Arrays and ArrayLists

• 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

3
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.
• 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.

first speed-dial phone number
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.

5 elements
5
Array Basics

• Here's how you can change the first phone number
  to 2013434
• phoneList0 2013434
• And here's how you can print the second phone
  number
• System.out.println(phoneList1)

6
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

7
Array Basics

• for (int i0 i
• System.out.print("Enter phone number ")
• phoneNum stdIn.nextLong()
• phoneListi phoneNum
• // end for
• System.out.println("\nSpeed Dial List")
• for (int i0 i
• System.out.println((i 1) ". "
  phoneListi)
• // end for
• // end main
• // end class SpeedDialList

8
Array Declaration

• An array is a variable and, as such, it must be
  declared before you can use it.
• Array declaration syntax
• Array declaration examples
• int ids
• double workHours
• String names

9
Array Creation

• 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
• new
  
• Example
• long phoneList
• phoneList new long10

indicates the type of each element
in the array
indicates the number of elements in
the array
array creation
10
Array Creation

• It's legal to combine an array's declaration,
  creation, and assignment operations. Here's an
  example
• long phoneList new long10
• 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
• 
  
• 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
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)

• For example, what are the default values below?
• float gpas new float1000
• String states new String50

13
Array length Property

• 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 i0 i
• System.out.println(colorsi)
• To obtain an array's length, specify array name,
  dot, and then length.
• Note that length is used in two different ways
• 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)

Note how an array object's length property gets
the array's size.
14
Array length Property and Partially Filled Arrays

• import java.util.Scanner
• public class SpeedDialList2
• public static void main(String args)
• Scanner stdIn new Scanner(System.in)
• String phoneList new String100 //
  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()
• while (!phoneNum.equalsIgnoreCase("q")
• filledElements
• if (phoneNum.length() phoneNum.length() 16)
• System.out.println("Invalid entry."

Array length property does not use ( )'s.
String length method uses ( )'s.
15
Array length Property and Partially Filled Arrays

• else
• phoneListfilledElements 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 i0 i
• System.out.println((i 1) ". "
  phoneListi)
• // 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 Feb
• 1.29 1.29
• 9.99 10.99
• 22.00 22.00
• 4.55 4.55
• 7.35 7.35
• 6.49 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
  doublepricesJanuary.length
• for (int i0 i
• pricesFebruaryi pricesJanuaryi
• pricesFebruary1 10.99
• System.out.printf("7s7s\n", "Jan", "Feb")
• for (int i0 i
• System.out.printf("7.2f7.2f\n",
• pricesJanuaryi, pricesFebruaryi)

20
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
• if listi equals the searched-for value
• increment i

21
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).

22
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

23
Selection Sort

• 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 (i?0 i
• find the smallest value in list from listi
• down to the bottom of the list
• swap the found value with listi

list (original)
list (sorted)
24
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.

25
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?

26
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.

27
Selection Sort

• public class Sort
• public static void sort(int list)
• int j
• for (int i0 i
• j indexOfNextSmallest(list, i)
• swap(list, i, j)
• // end sort
• private static int indexOfNextSmallest(int
  list, int startIndex)
• int min liststartIndex
• int minIndex startIndex
• for (int istartIndex1 i

28
Selection Sort

• private static void swap(int list, int i, int
  j)
• int temp
• temp listi
• listi listj
• listj 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 i0 i

29
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 one-dimensional 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

column indexes
row indexes
30
Two-Dimensional Arrays

• As with one-dimensional arrays, there are two
  ways to assign values into a two-dimensional
  arrays elements 1) an array initializer, 2)
  assignment statements.
• Heres 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
• 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.

initializer for a 2-row by 3-column array
31
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 int23
• for (int i0 i
• for (int j0 j
• System.out.print(
• "Enter value for row " i ", col " j
  " ")
• xij stdIn.nextInt()
• // end for j
• // end for i

Declare and create a 2-row by 3-column array.
Assign a value to the element at row i column j.
32
Two-Dimensional Arrays

• Bottom line To loop through the rows in a
  two-dimensional array, use .length .
  And to loop through the elements within a
  particular row, use 0.length. For
  example
• for (int i0 i
• for (int j0 j
• ...

33
Two-Dimensional Arrays

• 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 22 30 42 55
• Top 23 0 14 25 37
• KC 31 9 0 11 28
• Col 44 27 12 0 12
• StL 59 41 30 14 0
• 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.

It takes 25 minutes to fly from Topeka, KS to
Columbia, MO.
34
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")

35
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()

36
Two-Dimensional Arrays

• for (int i0 i
• System.out.println(i1 " "
  citiesi)
• 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 "
• flightTimesdeparturedestination "
  minutes.")
• // end promptForFlightTime
• //
• // This method prints a table of all flight
  times.
• // end class FlightTimes

37
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 total-sales 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.

Daniel, 6.25
Josh, 58.12
Amanda, 77.46
38
Arrays of Objects

• Show how the clerks array gets filled with the
  input shown below.

39
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()

40
Arrays of Objects

• class SalesClerks
• private SalesClerk clerks // contains
  names and sales
• private int filledElements 0 // number of
  elements filled
• //
  
• public SalesClerks(int initialSize)
• clerks new SalesClerkinitialSize
• // 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.

41
Arrays of Objects

• clerkIndex filledElements
• clerksclerkIndex new SalesClerk(name)
• filledElements
• // end if
• clerksclerkIndex.adjustSales(amount)
• // end addSale
• //
  
• // Print all the data - sales clerk names and
  sales.
• public void dumpData()
• for (int i0 i
• System.out.printf("s 6.2f\n",
• clerksi.getName(), clerksi.getSales())
  

42
Arrays of Objects

• // Search for the given name. If found, return
  the index.
• // Otherwise, return -1.
• private int findClerk(String name)
• for (int i0 i
• if (clerksi.getName().equals(name))
• return i
• // end for
• return -1
• // end findClerk
• //
  
• // Double the length of the array.

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
are to be copied.
43
Arrays of Objects

• public class SalesClerk
• private String name // sales clerk's
  name
• private double sales 0.0 // total sales for
  clerk
• //
  
• public SalesClerk(String name)
• this.name name
• //
  
• public String getName()
• return name

44
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 SalesClerkmaxClerks
• 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.

45
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.

46
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 reference-variable
• new ArrayList()
• For example, here's how to initialize an
  ArrayList reference variable named students
• ArrayList students new
  ArrayList()
• Compare the above ArrayList initialization to
  this standard-array initialization
• Student students new Student100

47
How to Create an ArrayList Object

• What are the syntax differences between the
  ArrayList example and the standard-array example?
  With the ArrayList example
• Use angled brackets to specify the type for the
  elements.
• must be a class name (not a
  primitive).
• Do not specify the number of elements (because
  ArrayList objects start out with no elements).

48
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

49
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)

50
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.

51
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 reference-variable
• new ArrayList()

52
How to Update an ArrayList Object

• The set method allows you to assign a value to an
  existing 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.

53
How to Update an ArrayList Object

• Draw a picture of the colors ArrayList after this
  code fragment executes
• String mixedColor
• ArrayList colors new ArrayList()
  
• colors.add("red")
• colors.add("green")
• colors.add("blue")
• mixedColor colors.get(0) colors.get(1)
• colors.set(2, mixedColor)

54
Additional ArrayList Methods

• public void add(int index, 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.
• public void clear()
• Remove all elements from the list.
• public int indexOf(E elem)
• 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()
• Return true if the list contains no elements.
• public E remove(int index)
• 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.

55
Example ArrayList Program

• import java.util.ArrayList
• public class Survivor
• public static void main(String args)
• int loserIndex
• String loser
• ArrayList tribe new
  ArrayList()
• 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)

56
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

57
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 behind the scenes. For
  ArrayLists, it's done automatically due to a
  wrapper class being used 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?

58
Storing Primitives in an ArrayList

• import java.util.Scanner
• import java.util.ArrayList
• public class StockAverage
• public static void main(String args)
• Scanner stdIn new Scanner(System.in)
• ArrayList stocks new
  ArrayList()
• 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)
• stocks.add(stock)
• System.out.print("Enter a stock value (-1
  to quit) ")

Must be a wrapper class, not a primitive.
Automatic boxing (autoboxing) takes place here.
59
Storing Primitives in an ArrayList

• for (int i0 i
• stock stocks.get(i)
• stockSum stock
• if (stocks.size() ! 0)
• System.out.printf("\nAverage stock value
  .2f\n",
• stockSum / stocks.size())
• // end main
• // end class StockAverage

Where does automatic unboxing take place?
60
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").

61
ArrayList Example Using Anonymous Objects and the
For-Each Loop

• import java.util.Scanner
• import java.util.ArrayList
• public class BearStore
• ArrayList bears new ArrayList()
• //
  
• // Fill store with specified number of standard
  teddy bears.
• public void addStdBears(int num)
• for (int i0 i
• bears.add(new Bear("Acme", "brown teddy"))
• // end addStdBears

anonymous object
62
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 i0 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)

anonymous object
63
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)

64
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

65
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)

66
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
• For-each loop syntax for an ArrayList
• for (
  )

Read this as "for each bear in bears, "
For each iteration through the loop, bear
accesses the next element in the bears ArrayList.
67
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 i0 i
• bears.get(i).display()
• // end displayInventory
• The for-each loop implementation is preferred
  because it is simpler.

68
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, 13
• for (int p primes)
• System.out.println(p)

69
For-Each Loop

• The for-each loop can be used only with things
  that have elements - Java API collections and
  arrays. (The ArrayList is a Java API collection.
  To learn about Javas other collections, go to
  http//java.sun.com/javase/6/docs/technotes/guides
  /collections/index.html.)

70
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
  earlier slide, which type of loop (standard or
  for-each) should you use to print the following?
• primes0 2
• primes1 3
• ...
• primes5 13
• As a practice exercise, provide a standard for
  loop that prints the above and also provide a
  for-each loop that prints the above.

71
ArrayList Objects Versus Standard Arrays