Objects for Organizing Data --

1
Objects for Organizing Data --

• As our programs get more sophisticated, we need
  assistance organizing large amounts of data.
  Chapter 6 focuses on
• array declaration and use
• arrays of objects
• parameters and arrays
• multidimensional arrays
• the ArrayList class
• additional techniques for managing strings

2
Static Variables - Details

• Normally, each object has its own data space.
• If a variable is declared as static, only one
  copy of the variable exists for all objects of
  the class
• private static int count
• Changing the value of a static variable in one
  object changes it for all others.
• Static variables are sometimes called class
  variables.

3
The static Modifier

• Unless otherwise specified, a member declared
  within a class is an instance variable. In the
  following Numbers class, there are
• Two instance variables,
• an integer - num1
• an integer - count
• plus one accessor method - ReturnNum().

4

• In this version , there are two instance
  variables.
• class Number
• 
  
  private int count 0
• private int num1
• public Number(int value) // constructor
  
  
  num1 value
• count
  
  
  
• public int returnNum() // service method
  
  
  
  return num1
  
  
  
  
  

5
Static Variables

• Each object that it is created in the Numbers
  class contains a
• copy of the num1 and count variables
• and has access to the ReturnNum method.
• Each object has unique values for the num1
  instance variable and count.
  
  

6

• In the main method of the Driver class, class
  Test
• class Test
• public static void main(String args)
• Number num1 new Number(17)
• Number num2 new Number(12)
• In memory, number has
• a copy of num1 and count

Number 58 Number 2 60
58 num1 17 count 1 60 num2 12
count 1
7
Static Variables

• copy of the variable or method is created.
• class Number
• 
  
  static int count 0 // one
  copy for all instances
• private int num1
• public Number(int value)
  
  count
  
• num1 value
  
  
• 
  
• public int returnNum()
  
  
  return
  num1
  
  
  
  
  

8
Class Numbers
num1 57 num2 60 57 num1 17
60 num1 20 62 count 2
class Test public static void main(String
args) Number num1 new
Number(17) Number num2 new
Number(20) In memory, number1 and Number2,
and two copies of num1 are stored but there is
one copy of count for the class
9
Static Variables

• Memory space for a static variable is created
  when the class is first starts to execute
• All objects instantiated from the class share its
  static variables only copy exists for all
  objects
• Changing the value of a static variable in one
  object changes it for all others

10
Static Variables

• When used properly, static variables are very
  effective.
• There is only one copy of the static variables
  named in a class for all objects.
• This means that all the objects created from that
  class do not receive a copy of the static
  variables.
• They just have access to their value they share
  them.

11
Class Student

• class Student
• private static int count 0 // a static
  variable
  
  
• private int SocSecNum
• private String name
• 
  
• public Student () //CONSTRUCTOR
• count count 1
  
• // constructor Student
  
• public int ReturnCount()
• return count
• // method ReturnCount

12
Instance Variable and Methods

• Every time you instantiate a new object from a
  class, you get a new copy of each of the classs
  instance variables.
• E.g. with every new Student object, you get a
  new name variable associated with the new Student
  object but it shares the static variable count
• All instances of the same class share the same
  implementation of the ReturnCount method.

13
The static Modifier

• The static modifier can be applied to variables
  or methods.
• It associates a variable or method with the class
  rather than an object.
• We have already seen the static modifier used
  with variables. It can also be used with methods.

14
Static Methods

• Static methods are invoked using the class name
  and are sometimes called class methods.
• Sometimes it is convenient to have methods that
  can be used without creating an object.
• For instance, every time you want to use the
  factorial method or the method that we used to
  uppercase a character you dont want to create an
  instance of the class.

15
The static Modifier

• So, you create static methods. To invoke these
  methods, you simply use the class name, where you
  would otherwise use the object name. E.g.
• For example, the Math class and the Character
  classes in the java.lang.package contains several
  static method operations
• Math.abs (num) // absolute value
• Character.toUppercase (c) // uppercases
  a char
• y Math.sqrt.(x)
• We used the methods in the character class
  without instantiating an instance of the class.

16
Static Methods

• Normally, we invoke a method through an instance
  (an object) of a class. We create an object and
  then call the methods in the class
• If a method is declared as static, it can be
  invoked through the class name no object needs
  to exist.

17
Static Methods
class Helper public static int cube (int
num) return num num num
Because it is declared as static, the method can
be invoked as value Helper.cube(5)
18
Static Class Members

• Static methods and static variables often work
  together
• The following example keeps track of how many
  Slogan objects have been created using a static
  variable, and makes that information available
  using a static method
• See SloganCounter.java (page 294)
• See Slogan.java (page 295)

19
public class Slogan private String phrase
private static int count 0
//------------------------------------------------
----------------- // Constructor Sets up the
slogan and counts the number of // instances
created. //------------------------------------
----------------------------- public Slogan
(String str) phrase str
count
20
//-----------------------------------------------
------------------ // Returns this slogan as
a string. //-----------------------------------
------------------------------ public String
toString() return phrase
//------------------------------------------------
----------------- // Returns the number of
instances of this class that have //been
created. //------------------------------------
----------------------------- public static
int getCount () return count
21
// Demonstrates the use of the static
modifier.public class SloganCounter public
static void main (String args)
Slogan obj obj new Slogan ("Remember the
Alamo.") System.out.println (obj)
obj new Slogan ("Don't Worry. Be Happy.")
System.out.println (obj) obj new
Slogan ("Live Free or Die.")
System.out.println (obj) obj new Slogan
("Talk is Cheap.") System.out.println
(obj) System.out.println ("Slogans
created " Slogan.getCount()) //
Output prints out all the slogans and the count
which is 4
22
Arrays

• An array is an ordered list of values each of
  which has their own position within the array.
• It is a collection of variables that share the
  same name.
• Each value/variable has a numeric index or
  subscript to refer to a particular element in the
  array.

23
Arrays

• For example, an array element can be assigned a
  value, printed, or used in a calculation
• scores2 89
• scoresfirst scoresfirst 2
• mean (scores0 scores1)/2
• System.out.println ("Top " scores5)

24
Arrays

• An array of size N is indexed from zero to N-1
• The following array of integers has a size of 10
  and is indexed from 0 to 9

25
Arrays

• A particular value is referenced using the array
  name followed by the index in brackets For
  example, the expression
• scores4
• refers to the value 67 (which is the 5th value
  in the array).
• Scores0 is first element in the array - all
  indexes start at 0. The value stored in the 3rd
  index is the 4th element.
• Scores4 is a place to store a single integer,
  and can be used wherever an integer variable can.
  For example, it can be assigned a value, printed,
  used in a calculation.

26
ARRAYS

• When an array is declared, the name of the array
  is the address in memory of the first value in
  the array. For instance, an array of 9 integers
  (indexed 0-8) called intArray would be located in
  memory like this

View of Memory
1 Location 23


90


40

60 70
75 80 90
scores
01

2


3

4


5


6


7 8
27
Arrays

• An array stores multiple values of the same data
  type.
• So if an array of integers is declared, only
  integers may be stored in that array, no strings
  or characters.
• The type can be primitive types or objects.
• Primitive types include arrays of integers,
  doubles, chars, longints etc.
• Therefore, we can create an array of integers, or
  an array of characters, or an array of String
  objects, etc.

28
Arrays

• In Java, the array itself is an object.
  Therefore
• Any of the methods that can be used on an object
  can be used on an array.
• The name of the array is a reference variable,
  and the array itself is instantiated separately.

29
Arrays

• The chess object Bishop points to the place in
  memory where all the variables and methods
  associated with the Bishop object are located,
• So the name of the array points to the place in
  memory where the individual values of the array
  are stored.

30
Declaring Arrays

• Since arrays are objects, the reference must
  first be declared and then the array can be
  instantiated.
• The scores array could be declared as follows
• int scores new int10
• Note that the type of the array (int) does not
  specify its size, but the new operator reserves
  memory locations to store 10 integers indexed
  from 0 to 9.

31
Arrays

• The type of the variable scores is int (an
  array of integers)
• It is set to a newly instantiated array of 10
  integers. Only integers may be stored in this
  array.
• If we declared an array of strings, only strings
  may be stored in that array.

32
Declaring Arrays

• Some examples of array declarations
• float prices new float500
• boolean flags
• flags new boolean20
• char codes new char1750
• int intArray //allocates no memory
  

33
Arrays

• You cannot access an index of an array until it
  is instantiated.
• 
  
• int grades // grades Array has no memory
  allotted
• grades3 7 // ERROR - grades3 does not
  yet exist

34
Creates an array with 10 elements

• class Basic_Array
  
• final static int LIMIT 10 // value will
  not change as
  final static int INCREMENT 10 // only
  one copy needed
• public static void main (String args)
• intlist new intLIMIT
• for(int index 0 index lt LIMIT index)
• listindex index INCREMENT
• list5 999
• for (int value list) // forEach value in list
• System.out.print (value " ")
  
  
  
  
  
  
  
  // method main // stores increments of 10
  in each element

35

• LIST

0 10


20


30

40 50
60 70
80 90




01

2


3

4


5


6


7


89
0 10


20


30

40 999
60 70
80 90




01

2


3

4


5


6


7


89
Element index 5 is change to 999, which is the
6th element in the array.
36
Arrays

• The constant LIMIT holds the size of the array.
  This is a good programming technique because it
  allows you to change the size of the array in one
  place - at the beginning of the program.
• The square brackets in the array declaration are
  an operator in Java. They have a precedence
  relative to other operators i.e. the highest
  precedence.
• Both constants in the previous example were
  declared static because only copy of the size of
  the array is needed.

37
Bounds Checking

• If the array codes can hold 100 values, it can
  only be indexed using the numbers 0 to 99
• If count has the value 100, then the following
  reference will cause an ArrayOutOfBoundsException
  
• System.out.println (codescount)
• Its common to introduce off-by-one errors when
  using arrays

for (int index0 index lt 100
index) codesindex index50 epsilon
38
Bounds Checking

• Once an array is created, it has a fixed size. An
  index used in an array reference must specify a
  valid element.
• That is, they must be in bounds (0 to N-1).
• The Java interpreter will throw an exception if
  an array index is out of bounds. So that in our
  list array of 10 elements, if you tried to
  access
  list11
  
  
• an exception called ArrayIndexOutofBoundsExcepti
  on would result. The java index operator
  performs automatic bounds checking.

39
Bounds Checking

• Each array object has a public constant called
  length that stores the size of the array.
• It is referenced through the array name (just
  like any other object)

40
Length of an Array

• scores.length
• Length is a constant defined in the array class.
• scores. length holds the number of elements
  allocated, not the largest index.
• That is, it holds the number of items you
  allocated for the array when you declared it..
• In the program Reverse_Numbers, an array is
  constructed to store numbers which are printed
  out in reverse.

41
ARRAYS

• Arrays are considered to be a static structure
  because they have a fixed size. They cannot
  shrink or grow in size.
• Data structures like arrays are good when we
  know ahead of time how many elements are needed.
  
• Other data structures like ArrayLists and linked
  lists can be used when it is necessary to
  dynamically build a structure to hold elements.
• This is necessary when the number of elements is
  not known ahead of time.

42
Initializer Lists

• An initializer list can be used to instantiate
  and initialize an array in one step.
• The values are delimited by braces and separated
  by commas. Examples
• int units 147, 323, 89, 933, 540,
• 269, 97, 114, 298, 476
• char letter_grades 'A', 'B', 'C',D
• 
  The array units is instantiated
  as an array of 10 ints, indexed from 0 to 9.
• The letter_grades array consists of an array of 4
  characters.

43
Initializer Lists

• Note that when an initializer list is used
• the new operator is not used
• no size value is specified
• the type of each value in the list must be the
  same as the data type of the array.
• The size of the array is determined by the number
  of items in the initializer list. An initializer
  list can only be used in the declaration of an
  array.
• The array size is set to the number of elements
  in the initializer list.

44
INITIALIZING ARRAYS

• When an array object is instantiated, the
  elements in the array are initialized to the
  default value of the indicated data type.
• That is, it you declare an array of integers,
  each element is initialized to 0.
• However, it is always better to do your own
  initialization.

45
Array Examples

• int Numbers new int100
  Numbers0
  0
• for(int i 1 i lt Numbers.length i)
  Numbersi i Numbers(i-1
• We used the length field, which is the field
  provided in the array class to contain the length
  of the array. This field is read-only.
• Though arrays are objects and can access all the
  methods that objects can, the syntax associated
  with them is somewhat different from that of
  other objects.

46

• class Evens
• final int SIZE 10
• public static void main(String args )
  int
  intArray new int SIZE
• for (j 0 j lt SIZE j)
  intArrayj 2 2 j
• System.out.println( Element
  Value )
  for (j 0 j lt SIZE -1 j)
  System.out.println( j
  intArrayj)
  // method main
  
  
  class evens

47

• class Sum
• public static void main(String args )
• // initialize the array with ints
  
• int intArray 1, 3, 5, 4, 7, 2, 16, 99,
  45, 67
• int total 0
  // accumulate the total of the elements
  in the array
• for (int j 0 j lt intArray.length j)
  
  total total intArrayj
  
  //
  print results System.out.println( Total
  array elements is , total)
• // method main // class Sum
• output Total of array elements is 287

48
ArrayCopy

• It is possible to copy one array to another array
  with the arraycopy method
• 
  
• public static void arraycopy(Object sourceArray,
  int srcIndex, Object destination, int destIndex,
  int length).
• The two objects are the source and destination
  arrays, the srcIndex and destIndex are the
  starting points in the source and destination
  arrays, and length is the number of elements to
  copy. E.g.

49
Copying Arrays

• public static void main(String args)
  
  char copyFrom d,e,c,a, f,
  f,e,i n char
  copyTo new char7
  System.arraycopy(copyFrom, 2, copyTo, 0,7)
  
  
• Arraycopy method begins the copy at element
  number 2 in the source array (copyFrom) which is
  element c. It copies it to the destination
  array (copyTO) starting at index 0. It copies 7
  elements, c to n into copyTO.
  
  

2
d e c a f f e i n
copyFrom
0 1 2 3 4 5 6
c a f f e i n
copyTO
50
ARRAYS

• The elements of an array can be object
  references. The declaration
• 
  String words new String25
• reserves space to store 25 references to String
  objects.
• It does NOT create the String objects themselves
  
  
  

51
Arrays of Objects

• The words array when initially declared

address

• At this point, the following reference would
  throw a NullPointerException
• System.out.println (words0)

52
Arrays of Objects

• After some String objects are created and stored
  in the array

Address of string
53
Arrays of Objects

• Keep in mind that String objects can be created
  using literals
• The following declaration creates an array object
  called verbs and fills it with four String
  objects created using string literals

String verbs "play", "work", "eat", "sleep"
54
Initializing Arrays

• // initializes the array
• String name_list Paul, Newman,
  Jessica, Ten)
• Since a string literal instantiates a new string
  object, each string literal in the initializer
  list creates an object for each element of the
  array. Hence
• for(int name 0 name lt name_list.length
  name) System.out.printl(name_listname
  )
• OUTPUT Paul Newman Jessica Ten
  
  

55
Array of Strings

• Each object stored in an array can also be
  instantiated separately. e.g.
  
  String phrase new
  String5
  
  phrase0 Good Morning
• phrase1 How are you
• phrase2 Have a Good Day
• It is also possible to read in the elements of an
  array from the user.

56
Arrays of Objects

• The following example creates an array of Grade
  objects, each with a string representation and a
  numeric lower bound
• See GradeRange.java
• See Grade.java

57
// Represents a school grade.//
public class
Grade private String name private int
lowerBound //--------------------------------
--------------------------------- //
Constructor Sets up this Grade object with the
specified // grade name and numeric lower
bound. //--------------------------------------
--------------------------- public Grade
(String grade, int cutoff) name
grade lowerBound cutoff
58
//-----------------------------------------------
------------------ // Returns a string
representation of this grade.
//------------------------------------------------
----------------- public String toString()
return name "\t" lowerBound
//------------------------------------------------
----------------- // Name mutator.
//------------------------------------------------
----------------- public void setName (String
grade) name grade
59
//-----------------------------------------------
------------------ // Lower bound mutator.
//------------------------------------------------
----------------- public void setLowerBound
(int cutoff) lowerBound cutoff
//-----------------------------------------
------------------------ // Lower bound
accessor. //-----------------------------------
------------------------------ public int
getLowerBound() return lowerBound

60
public class GradeRange //-------------------
----------------------------------------------
// Creates an array of Grade objects and prints
them. //---------------------------------------
-------------------------- public static void
main (String args) Grade grades
new Grade("A", 95), new
Grade("A-", 90), new Grade("B", 87),
new Grade("B", 85), new Grade("B-", 80),
new Grade("C", 77), new Grade("C", 75), new
Grade("C-", 70), new Grade("D", 67),
new Grade("D", 65), new Grade("D-", 60),
new Grade("F", 0) for (Grade
letterGrade grades) System.out.println
(letterGrade) / / which is the same as
for ( int index 0 index lt 5 index
System.out.println(gradesindex
61
// shortcut instantiations of array Grade
grades new Grade("A", 95), new
Grade("A-", 90), new Grade("B", 87),
new Grade("B", 85), new Grade("B-", 80),
new Grade("C", 77), new Grade("C", 75), new
Grade("C-", 70), new Grade("D", 67),
new Grade("D", 65), new Grade("D-", 60),
new Grade("F", 0)
If we did not do the above shortcut
instantiations, we would have to fill the array
as below grades0 new Grade(A,
95) grades1 new Grade(A-, 90) grades2
new Grade(B, 87) grades3 new Grade(B,
85) grades4 new Grade(B-, 80) .. And so
on
62
Outline
Declaring and Using Arrays Arrays of
Objects Two-Dimensional Arrays Variable Length
Parameter Lists The ArrayList Class Polygons and
Polylines Mouse Events and Key Events
63
Multidimensional Arrays

• A one-dimensional array stores a simple list of
  values.
• A two-dimensional array can be thought of as a
  table of values, with rows and columns.
• A two-dimensional array element is referenced
  using two index values.
• To be precise, a two-dimensional array in Java is
  an array of arrays, therefore each row can have a
  different length.

64
Two Dimensional Arrays

• Actually Java does not support 2d arrays in the
  traditional sense. What it does allow are
  one-dimensional arrays that hold arrays as
  values.
• In an initializer list, the first values
  represent the first element in the array.
• An initializer list can be used to create and set
  up a multidimensional array or values can be read
  into the array from a file or the keyboard.

65
Multi-dimensional Arrays.

• Each element in the list is itself an initializer
  list. It is helpful to conceive of the 2D array
  as a table and a 3D array as a cube. After that,
  it is not easy to conceive of anything.
• Note that each array dimension has its own length
  constant.

66
Two-Dimensional Arrays

• A one-dimensional array stores a list of elements
• A two-dimensional array can be thought of as a
  table of elements, with rows and columns

67
Two-Dimensional Arrays

• To be precise, in Java a two-dimensional array is
  an array of arrays
• A two-dimensional array is declared by specifying
  the size of each dimension separately
• int scores new int1250
• A array element is referenced using two index
  values
• value scores36
• The array stored in one row can be specified
  using one index

68
Two-Dimensional Arrays
Expression Type Description
table int 2D array of integers, or array of integer arrays
table5 int array of integers - A ROW IN THE TABLE
table512 int Integer an int value in a cell of the table

• See TwoDArray.java (page 399)
• See SodaSurvey.java (page 400)

69
// Class Soda_Scores stores the results of the
survey in a 2D// array of integers
representing individual respondents ratings of 4
sodas and contains the methods to perform some
basic analysis.//--------------------------------
-----------------------------------class
Soda_Scores private final int RESPONDENTS
10 private final int SODAS 4 // each row
represents one of the sodas, each column
represents one of the //respondents private
int results 3, 4, 5, 2, 1, 4, 3, 2, 4,
4, // soda 1 2,
4, 3, 4, 3, 3, 2, 1, 2, 2, // soda 2
3, 5, 4, 5, 5, 3, 2, 5, 5,
5, // soda 3 1,
1, 1, 3, 1, 2, 1, 3, 2, 4 // soda 4
//
// Returns the number of sodas used in the
survey. /
public int num_sodas() return
SODAS // method num_sodas
70
//
// Determines if the specified soda is worthy
of future // development by seeing if at
least half of the survey // respondents
scored the soda at or above a particular //
level. Goes through the columns and checks
values // variable soda represents a row
/
public boolean worthy (int soda, int level)
int count 0 for (int person0
person lt resultssoda.length person)
if (resultssodaperson gt level) // scored
above level count return
(count gt RESPONDENTS/2) // method
worthy // class Soda_Scores
71
// Class Soda_Survey contains the driver of a
program that produces the results of a soda taste
test.//------------------------------------------
-------------------------class Soda_Survey
// Creates a Soda_Scores object, then determines
and prints if each tested soda is worthy of
future development. //
public static void main
(String args) Soda_Scores test new
Soda_Scores() // goes through the four
rows and calls the method worthy() in
//Soda_Scores which goes through the columns and
checks for levels //greater than 3 for
(int soda0 soda lt test.num_sodas() soda)
System.out.println ("Soda "
(soda1) " is "
(test.worthy(soda, 3) ? "worthy." "not
worthy.")) // method main // class
Soda_Survey
72
Multidimensional Arrays

• int table 28, 84, 47, 72, 69, 26,
  91, 40, 28, 42, 34, 37, 13, 26, 57, 35
• The first values - 28, 84, 47 and 72 represent
  the first row of the array. The second set of
  values are the 2nd row
• 28 84 47 72
• 69 26
• 91 40 28
• 42 34 37
• 13 26 57 35

73

• import java.io.
  
  
• public class PassArrays
• public static void main(String args)
• // initialize the array
  
• int grades 100, 79, 83 , 44,
  56, 67 , 95, 88, 99
• // call methods to print a row
• printStudentScores( grades1 )
• // represents a row in the array
• 
  
  public static void
  printStudentScores( int row)
• System.out.print("Scores for student ")
  
  for (int i 0 i lt row.length i)
  System.out.println("")
  
  

74
Arrays as Parameters

• An entire array can be passed to a method as a
  parameter. Like any other object, the reference
  to the array is passed, making the formal and
  actual parameters aliases of each other.
• Changing an array element in the method changes
  the original element. An array element can be
  passed to a method as well, and follow the
  parameter passing rules of that element's type.

75
public class PassArrays public static void
main(String args) // initialize the array

int grades 100, 79, 83 , 44,
56, 67 , 95, 88, 99 // call methods
to print row 1 grades1
printStudentScores( grades1 )
// represents a row in the array, this changes
all the values in that row


public static void printStudentScores( int
row) System.out.print("Scores
for student ")
for (int i 0 i lt
row.length i) rowi
40
Result All
values in row 1 (grades1 have been changed to 40
76
The ArrayList Class

• An object of class ArrayList is similar to an
  array in that it stores multiple values
• However, a ArrayList
• only stores objects.
• can grow and shrink in size
• Service methods provided by the ArrayList t class
  are used to interact with a ArrayList..

77
The ArrayList Class

• An important difference between an array and a
  ArrayList is that a ArrayList can be thought of
  as dynamic, that is, it is able to change its
  size as needed .
• A static structure like an array has a fixed size
  throughout its existence.
• Each ArrayList initially has a certain amount of
  memory space reserved for storing elements.

78
ArrayList Class

• If an element is added that doesn't fit in the
  existing space, more room is automatically
  acquired.
• It accomplishes this by creating and destroying
  arrays. This is not really efficient.
• However it is necessary if want the flexibility
  to enlarge arrays.

79
The ArrayList Class

• An ArrayList is implemented using an array.
• Whenever new space is required, a new, larger
  array is created, and the values are copied from
  the original to the new array.
• To insert an element, existing elements are first
  copied, one by one, to another position in the
  array.

80
The ArrayList Class

• Elements can be inserted or removed with a single
  method invocation
• When an element is inserted, the other elements
  "move up or down " to make room
• Likewise, when an element is removed, the list
  "collapses" to close the gap
• The indexes of the elements adjust accordingly

81
ArrayLists

• The major advantage of an ArrayList that we can
  store different types of objects in it.
• Since the methods are designed to accept
  references to any Object type, a reference to a
  string, an integer, a double etc. can be passed.
  
• NOTE that if a primitive type is passed, it
  must be passed as an object using the Integer, or
  Double wrapper classes.

82
ArrayList Class

• Previoiusly, to put an integer into an
  ArrayList you would have to first create an
  integer object
• ArrayList list new ArrayList()
• Integer num new Integer(10)
• list.add(num)
• But now Java will automatically change an int to
  an object for you so that you can code
• list.add(10) // java changes 10 to an
  Integer object
• You must inport the java.util package to use an
  ArrayList

83
The ArrayList class Service methods
add(Object element) adds element to end of list

remove (Object element)
removes the object from the ArrayList. The
parameter is an alias to the object to be
removed. contains (Object element)
returns true if the object is in the ArrayList.
get (int index) returns the object at the
index specified. ensureCapacity() expands
array by creating a new array. lastIndexOf(Object
element) returns the last occurrence of
element. size() returns the number of objects.

84
The ArrayList Class

• An ArrayList stores references to the Object
  class, which allows it to store any kind of
  object
• We can also define an ArrayList object to accept
  a particular type of object
• The following declaration creates an ArrayList
  object that only stores Family objects
• ArrayList ltFamilygt reunion new ArrayList
  ltFamilygt
• This is an example of generics, which are
  discussed further in Chapter 12