1. 1 Objects for Organizing Data -- b As our programs get more sophisticated, we need assistance organizing large amounts of data. Chapter 6 focuses on: array declaration and usearray declaration and use arrays of objectsarrays of objects parameters and arraysparameters and arrays multidimensional arraysmultidimensional arrays the ArrayList classthe ArrayList class additional techniques for managing stringsadditional techniques for managing strings

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

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

4. 4 Class Numbers b 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 ++; } count ++; } public int returnNum() { // service method return num1; }

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

6. 6 Class Numbers In the main method of the Driver class, class Test class Test { public static void main(String args[]) public static void main(String args[]) { Number num1 = new Number(17); Number num1 = new Number(17); Number num2 = new Number(12); 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. 7 b When declaring a static variable or method, only one copy of the variable or method is created. All instances of the class share the same copy. class Number { static int count = 0; // one copy for all instances private int num1; private int num1; public Number(int value) { count++; public Number(int value) { count++; num1 = value ; num1 = value ; } public int returnNum() { return num1; } public int returnNum() { return num1; } } Static Variables

8. 8 Class Numbers class Test { public static void main(String args[]) public static void main(String args[]) { Number num1 = new Number(17); Number num1 = new Number(17); Number num2 = new Number(20); 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 num1 57 num2 60 57 num117 60 num1 20 62 count 2

9. 9 Static Variables b Memory space for a static variable is created when the class is first referenced b All objects instantiated from the class share its static variables b Changing the value of a static variable in one object changes it for all others

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

11. 11 Class Student class Student { private static int count = 0; // a static variable private static int count = 0; // a static variable private int SocSecNum; private int SocSecNum; private String name; private String name; public Student () {//CONSTRUCTOR count = count + 1; count = count + 1; } // constructor Student } // constructor Student public int ReturnCount() { return count; } // method ReturnCount

12. 12 b Every time you instantiate a new object from a class, you get a new copy of each of the class’s instance variables.  With every new Student object, you get a new name variable associated with the new Student object. b All instances of the same class share the same implementation of the ReturnCount method.  Objects outside the Student class can only access the static variable count through the ReturnCount method. b Instance Variable and Methods

13. Chap6 13 The static Modifier  The static modifier can be applied to variables or methods. b It associates a variable or method with the class rather than an object. b This approach is a distinct departure from the normal way of thinking about objects. b We have already seen the static modifier used with variables. It can also be used with methods.

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

15. 15 The static Modifier b 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 Math.abs (num) // absolute value Character.toUppercase (c) // uppercases a char Character.toUppercase (c) // uppercases a char y = Math.sqrt.(x) y = Math.sqrt.(x) b We used the methods in the character class without instantiating an instance of the class.

16. Chap6 16 Static Methods b Normally, we invoke a method through an instance (an object) of a class. b If a method is declared as static, it can be invoked through the class name; no object needs to exist.

17. 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. 18 Static Class Members b 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 b See SloganCounter.java (page 294) SloganCounter.java b See Slogan.java (page 295) Slogan.java

19. 19 Arrays b An array is an ordered list of values each of which has their own position within the array. b It is a collection of variables that share the same name. b Each value/variable has a numeric index or subscript to refer to a particular element in the array. 0 1 2 3 4 5 6 7 8 9 scores 79 87 94 82 67 98 87 81 74 91

20. 20Arrays  For example, an array element can be assigned a value, printed, or used in a calculation : scores[2] = 89; scores[first] = scores[first] + 2; mean = (scores[0] + scores[1])/2; System.out.println ("Top = " + scores[5]);

21. 21Arrays b An array of size N is indexed from zero to N-1 b The following array of integers has a size of 10 and is indexed from 0 to 9 0 1 2 3 4 5 6 7 8 9 scores 79 87 94 82 67 98 87 81 74 91

22. 22 Arrays b A particular value is referenced using the array name followed by the index in brackets For example, the expression: scores[4]; scores[4]; refers to the value 67 (which is the 5th value in the array). refers to the value 67 (which is the 5th value in the array). Scores[0] is first element in the array - all indexes start at 0. The value stored in the 3rd index is the 4th element. Scores[0] is first element in the array - all indexes start at 0. The value stored in the 3rd index is the 4th element. b Scores[4] 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.

23. 23 ARRAYS b 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: 1 Location 23 90 40 60 70 75 80 90 scores 012345678012345678 View of Memory

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

25. 25Arrays b 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.

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

27. 27 Declaring Arrays b 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 int[10]; int[] scores = new int[10]; b 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.

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

29. 29 Declaring Arrays b Some examples of array declarations: float[] prices = new float[500]; boolean[] flags; flags = new boolean[20]; flags = new boolean[20]; char[] codes = new char[1750]; char[] codes = new char[1750]; int[] intArray ; //allocates no memory int[] intArray ; //allocates no memory

30. 30Arrays You cannot access an index of an array until it is instantiated. int[] grades; // grades Array has no memory allotted int[] grades; // grades Array has no memory allotted grades[3] = 7; // ERROR - grades[3] does not yet exist grades[3] = 7; // ERROR - grades[3] does not yet exist

31. 31 class Basic_Array { final static int LIMIT = 10; // value will not change as final static int INCREMENT = 10; // only one copy needed 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[]){ int[]list = new int[LIMIT]; for(int index = 0; index < LIMIT; index++) list[index] = index * INCREMENT; public static void main (String args[]){ int[]list = new int[LIMIT]; for(int index = 0; index < LIMIT; index++) list[index] = index * INCREMENT; list[5] = 999; list[5] = 999; for (int value : list) // forEach value in list System.out.print (value + " "); } // method main // stores increments of 10 in each element System.out.print (value + " "); } // method main // stores increments of 10 in each element Creates an array with 10 elements

32. 32 0 10 20 30 40 50 60 70 80 90 01234567890123456789 LIST LIST 0 10 20 30 40 999 60 70 80 90 01234567890123456789 Element index 5 is change to 999, which is the 6th element in the array.

33. 33 Arrays b 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. b 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. b Both constants in the previous example were declared static because only copy of the size of the array is needed. b

34. 34 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 (codes[count]); b It’s common to introduce off-by-one errors when using arrays for (int index=0; index <= 100; index++) codes[index] = index*50 + epsilon; problem

35. 35 Bounds Checking b Once an array is created, it has a fixed size. An index used in an array reference must specify a valid element. b That is, they must be in bounds (0 to N-1). b 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: list[11] an exception called ArrayIndexOutofBoundsException would result. The java index operator performs automatic bounds checking.

36. 36 Bounds Checking  Each array object has a public constant called length that stores the size of the array. b It is referenced through the array name (just like any other object):

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

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

39. 39 Array Declarations Revisited b The brackets of the array type can be associated with the element type or with the name of the array.Therefore float[] prices; float[] prices; and and float prices[]; float prices[]; are essentially equivalent. The first format is usually more readable as most variables are declared as: int sum, total, num // which is closer to int[] sum, total, num // versus int sum[], total, num // which is confusing

40. 40 Initializer Lists b An initializer list can be used to instantiate and initialize an array in one step. b The values are delimited by braces and separated by commas. Examples: int[] units = {147, 323, 89, 933, 540, int[] units = {147, 323, 89, 933, 540, 269, 97, 114, 298, 476}; 269, 97, 114, 298, 476}; char[] letter_grades = {'A', 'B', 'C',’D’}; 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.

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

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

43. 43 Array Examples int Numbers[] = new int[100] Numbers[0] = 0; for(int i = 1; i < Numbers.length; i++) Numbers[i] = i + Numbers(i-1]; b 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. b 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.

44. 44 class Evens { final int SIZE = 10; public static void main(String[] args ) { int [] intArray = new int [SIZE]; public static void main(String[] args ) { int [] intArray = new int [SIZE]; for (j = 0; j < SIZE ; j++) intArray[j] = 2 + 2 * j; for (j = 0; j < SIZE ; j++) intArray[j] = 2 + 2 * j; System.out.println(“ Element Value “); for (j = 0; j <= SIZE -1; j++) System.out.println(“ “ + j + “ “ intArray[j]); } // method main } class evens System.out.println(“ Element Value “); for (j = 0; j <= SIZE -1; j++) System.out.println(“ “ + j + “ “ intArray[j]); } // method main } class evens

45. 45 class Sum { public static void main(String[] args ) { 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 < intArray.length; j++) total = total + intArray[j]; // print results System.out.println(“ Total array elements is “, total); } // method main } // class Sum } // method main } // class Sum output : Total of array elements is 287 output : Total of array elements is 287 CLASS SUM

46. 46 Command-Line Arguments  The main method has a parameter that it takes an array of String objects as a parameter b These values come from command-line arguments that are provided when the interpreter is invoked  For example, the following invocation of the interpreter passes three String objects into main : > java StateEval pennsylvania texas arizona  These strings are stored at indexes 0-2 of the array parameter of the main method  See NameTag.java (page 393) NameTag.java

47. 47 Examples of Arrays class Echo { public static void main(String[] args ) { public static void main(String[] args ) { for (int j = 0; j < args.length; j++) for (int j = 0; j < args.length; j++) System.out.print( arg[j] + “ “); System.out.print( arg[j] + “ “); System.out.println (“ “); System.out.println (“ “); } // method main } // class Echo output: prints out the contents of String[] args which is the values the user specified: java Echo Mary Sam Bill prints java Echo Mary Sam Bill prints Mary Sam Bill Mary Sam Bill

48. 48ArrayCopy b It is possible to copy one array to another array with the arraycopy method: b public static void arraycopy(Object sourceArray, int srcIndex, Object destination, int destIndex, int length). b 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. 49 Copying Arrays public static void main(String args[]){ char[] copyFrom = { ‘d’,’e’,’c’,’a’, ‘f’, ‘f’,’e’,’i’ ‘n’}; char[] copyTo = new char[7]; System.arraycopy(copyFrom, 2, copyTo, 0,7); } b 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. d e c a f f e i n c a f f e i n copyFrom copyTO 0 1 2 3 4 5 6 2

50. 50 Arrays of Objects b Objects can have arrays as instance variables. Therefore, fairly complex structures can be created simply with arrays and objects b The software designer must carefully determine an organization for each application.

51. 51 b The elements of an array can be object references. The declaration: String[] words = new String[25]; String[] words = new String[25]; reserves space to store 25 references to String objects. reserves space to store 25 references to String objects.  It does NOT create the String objects themselves: ARRAYS

52. 52 Arrays of Objects  The words array when initially declared: words - - - - -  At this point, the following reference would throw a NullPointerException : System.out.println (words[0]);

53. 53 Arrays of Objects  After some String objects are created and stored in the array: “friendship” words - - “loyalty” “honor” Address of string

54. 54 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"};

55. 55 Initializing Arrays // initializes the array String[] name_list = {“Paul”, “Newman”, “Jessica”, “Ten”); b 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 < name_list.length; name++) System.out.printl(name_list[name] + “ “); for(int name = 0; name < name_list.length; name++) System.out.printl(name_list[name] + “ “); OUTPUT = Paul Newman Jessica Ten OUTPUT = Paul Newman Jessica Ten

56. 56 Array of Strings b Each object stored in an array can also be instantiated separately. e.g. String[] phrase = new String[5]; phrase[0] = “Good Morning”; phrase[1] = “How are you”; phrase[1] = “How are you”; phrase[2] = “Have a Good Day”; phrase[2] = “Have a Good Day”; b It is also possible to read in the elements of an array from the user. In the Presidents.java program, the string elements in the array are instantiated by the readLine method. After reading the elements in, the names are printed out in reverse order.

57. 57 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 GradeRange.java  See Grade.java Grade.java  Now let's look at an example that manages a collection of CD objects  See Tunes.java Tunes.java  See CDCollection.java CDCollection.java  See CD.java CD.java

58. 58 Arrays of Objects  A UML diagram for the Tunes program: Tunes + main (args : String[]) : void CDCollection - collection : CD[] - count : int - totalCost : double + addCD (title : String, artist : String, cost : double, tracks : int) : void + toString() : String - increaseSize() : void CD - title : String - artist : String - cost : double - tracks : int + toString() : String * 1

59. 59Outline 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

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

61. 61 Two Dimensional Arrays b Actually Java does not support 2d arrays in the traditional sense. What it does allow are one-dimensional arrays that hold arrays as values. b In an initializer list, the first values represent the first element in the array. b 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.

62. 62 Multi-dimensional Arrays. b 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. b For instance in the Multi_Arrays_Test program, the array is initialized as:

63. 63 Two-Dimensional Arrays b A one-dimensional array stores a list of elements b A two-dimensional array can be thought of as a table of elements, with rows and columns one dimension two dimensions

64. 64 Two-Dimensional Arrays b To be precise, in Java a two-dimensional array is an array of arrays b A two-dimensional array is declared by specifying the size of each dimension separately: int[][] scores = new int[12][50]; b A array element is referenced using two index values: value = scores[3][6] b The array stored in one row can be specified using one index

65. 65 Two-Dimensional Arrays ExpressionTypeDescription tableint[][] 2D array of integers, or array of integer arrays table[5]int[] array of integers table[5][12]intinteger  See TwoDArray.java (page 399) TwoDArray.java  See SodaSurvey.java (page 400) SodaSurvey.java

66. 66 Multidimensional Arrays int[][] table = { {28, 84, 47, 72}, {69, 26}, {91, 40, 28}, {42, 34, 37}, {13, 26, 57, 35} }; b 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

67. 67 import java.io.*; public class PassArrays{ public static void main(String args[]){ int grades[][] = { { 100, 79, 83 }, { 44, 56, 67 }, { 95, 88, 99 } }; printStudentScores( grades[1] ); printTestScores( grades, 1 ); } public static void printStudentScores( int[] row { System.out.print("Scores for student: "); for (int i = 0; i < row.length; i++) System.out.println(""); } public static void printTestScores( int [][] gradebook, int testNo{ System.out.print("Scores for test " + testNo + " : "); for (int row = 0; row < gradebook.length; row++ ) System.out.print(" " + gradebook[row][testNo]); System.out.println(""); } // method printTestScores } // class PassArrays

68. 68 Variable Length Parameter Lists b Suppose we wanted to create a method that processed a different amount of data from one invocation to the next  For example, let's define a method called average that returns the average of a set of integer parameters // one call to average three values mean1 = average (42, 69, 37); // another call to average seven values mean2 = average (35, 43, 93, 23, 40, 21, 75);

69. 69 Variable Length Parameter Lists  We could define overloaded versions of the average method Downside: we'd need a separate version of the method for each parameter countDownside: we'd need a separate version of the method for each parameter count b We could define the method to accept an array of integers Downside: we'd have to create the array and store the integers prior to calling the method each timeDownside: we'd have to create the array and store the integers prior to calling the method each time b Instead, Java provides a convenient way to create variable length parameter lists

70. 70 Variable Length Parameter Lists b Using special syntax in the formal parameter list, we can define a method to accept any number of parameters of the same type b For each call, the parameters are automatically put into an array for easy processing in the method public double average (int... list) { // whatever } element type array name Indicates a variable length parameter list

71. 71 Variable Length Parameter Lists public double average (int... list) { double result = 0.0; if (list.length != 0) { int sum = 0; for (int num : list) sum += num; result = (double)num / list.length; } return result; }

72. 72 Variable Length Parameter Lists b The type of the parameter can be any primitive or object type public void printGrades (Grade... grades) { for (Grade letterGrade : grades) System.out.println (letterGrade); }

73. 73 Variable Length Parameter Lists b A method that accepts a variable number of parameters can also accept other parameters  The following method accepts an int, a String object, and a variable number of double values into an array called nums public void test (int count, String name, double... nums) { // whatever }

74. 74 Variable Length Parameter Lists b The varying number of parameters must come last in the formal arguments b A single method cannot accept two sets of varying parameters b Constructors can also be set up to accept a variable number of parameters  See VariableParameters.java (page 396) VariableParameters.java  See Family.java (page 397) Family.java

75. 75Sorting b Sorting is the process of arranging a list of items into a well- defined order. b If you want to alphabetize a list of name or put a list of survey results into descending numeric order, there are several well-defined techniques to accomplish this task. b In fact, sorting is a classic area of Computer Science. b We will examine two types of sorts: the Selections Sort and Insertion Sort in a later lecture.

76. 76 Arrays as Parameters b 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. b 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.

77. 77 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.only stores objects. can grow and shrink in sizecan grow and shrink in size  Service methods provided by the ArrayList t class are used to interact with a ArrayList..

78. 78 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. b 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.

79. 79 ArrayList Class b If an element is added that doesn't fit in the existing space, more room is automatically acquired. b It accomplishes this by creating and destroying arrays. This is not really efficient except for representing linear relationships.

80. 80 The ArrayList Class  An ArrayList is implemented using an array. b Whenever new space is required, a new, larger array is created, and the values are copied from the original to the new array. b To insert an element, existing elements are first copied, one by one, to another position in the array.  Therefore, the implementation of ArrayList in the API is not very efficient

81. 81 The ArrayList Class b Elements can be inserted or removed with a single method invocation b When an element is inserted, the other elements "move aside" to make room b Likewise, when an element is removed, the list "collapses" to close the gap b The indexes of the elements adjust accordingly

82. 82 ArrayLists  The major advantage of an ArrayList that we can store different types of objects in it. b 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. b NOTE that if a primitive type is passed, it must be passed as an object using the Integer, or Double wrapper classes.

83. 83 ArrayList Class  Thus to put an integer into an ArrayList you would have to first create an integer object: Integer num = new Integer(2); Double doublenum = new Double(2.98); b The benefits of this are that different kinds of objects can be stored in the same data structure.  You must inport the java.util package to use an ArrayList

84. 84 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. The ArrayList class Service methods:

85. 85 The ArrayList Class  An ArrayList stores references to the Object class, which allows it to store any kind of object  See Beatles.java (page 405) Beatles.java  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 reunion = new ArrayList ArrayList reunion = new ArrayList  This is an example of generics, which are discussed further in Chapter 12