Alice in Action with Java Chapter 12 Arrays and Lists in Java

Alice in Action with Java

Chapter 12Arrays and Lists in Java

Alice in Action with Java 2

Objectives

• Understand Java’s array data structure

• Solve problems using Java’s LinkedList data structure

• Solve problems using Java’s ArrayList data structure


Arrays and Lists in Java

• Features common to arrays and lists– Used to define variables that store groups of items– Provide access to a given item using an index

• Differences between arrays and lists– Array’s size is fixed at runtime, a list’s size can change– Array stores items using less memory than a list– Array provides direct item access faster than a list


Introductory Example: Air Pollution Reporting

• Review of AirPollutionIndex.java– Read air pollution level readings from five points– Compute and display the average reading (the index)

• Additional requirements of the enhanced program– Display the five readings used to compute the average

• High-level algorithm for AirPollutionReport– Build an array named readings with length = 5 – Read the air pollution readings into readings– Compute and display average of values in readings– Display the individual values in readings


Java Arrays

• General pattern for defining (declaring) an array– Item[] anArray = new Item[N];

• Item: specifies the items type

• Brackets tell compiler that anArray is an array handle• new operator: allocates memory for the array• N: an integer that specifies the array length (size)

• An example of an array definition: double[] readings = new double [NUM_READINGS];– NUM_READINGS is an integer constant = 5– readings is a handle to a 5 unit double type array


Java Arrays (continued)

• Element: indexed unit variable in an array

• Item: value stored in an array element

• Items are initialized to default values for array’s type– Example: default value for item in double type is 0.0

• Creating an array parameter– Place brackets between parameter’s type and its name– General form: public ReturnType methodName( Item[] parameterName ){…

– Example: public static double average(double [] anArray)





• Components needed to access an array’s elements– Array’s handle, item’s index, subscript operator ([])

• Pattern for accessing an element: anArray[i]– anArray is the handle to the array – i: index value, which must be a non-negative integer– An index value out of bounds throws an exception

• Example of an array access: readings[0]– Accesses the first element of the readings array– Note: index is off by one relative to item’s cardinal order

• length property: returns number of items in an array



• for loop provides convenient access to an array

• Example of an array traversal using a for loop– for (int i = 0; i < arr.length; i++){

System.out.println("Reading #" + (i+1) + ": " + arr[i]);}

• for each loop – Special loop used to read each item in an array– Limitation: cannot be used to write to array’s elements

• Example of array traversal using a for each loop– for (double item : anArray){sum += item;}


Example 2: Month Names From Numbers

• Essential elements of user story – Randomly generate a month number– Query user for a month name matching the number– Read the user’s response– Display a message appropriate to the response– Let the user keep playing as long as he or she wants

• Instance variables declared in the Month class– An integer myNumber and a string myName

• Role of the Month()constructor– Construct a Month object given a month number


Example 2: Month Names From Numbers (continued)

• MONTHS will be used to store the month names– The array is declared as a constant class variable– Declaration also includes an initialization values list– The array functions as a lookup table for the constructor

• Other Month members– Accessors for the instance variables– A toString()method

• Other classes used in MonthTester– Random (to generate a random number)– Scanner (to read in the month’s name)


Example 2: Month Names From Numbers (continued)


Arrays and Memory

• An array is a random access data structure– Contiguous elements are accessed in constant time

• Subscript operation computes an element’s address

• How to compute the address of an array element– Multiply the index i by the size of an item– Add the resulting product to the starting address– Example: anArray[4]= (anArray+4*itemSize)

• Insertion and removal are linear time operations– Up to length–1 items are shifted in each operation– Many of these operations can slow down a program


Arrays and Memory (continued)


Arrays and Memory (continued)


Multidimensional Arrays

• Dimension: axis used to specify element’s location • length determines space for one-dimensional array

• You can create arrays with multiple dimensions– Example: two-dimensional array to model a table

• How to declare an N-dimensional array handle– Use N pairs of brackets to declare

• Example of declaring a two-dimensional array– private double [][] myTable = null;


Multidimensional Arrays (continued)

• Defining a multidimensional array with default values – Use the new operator and specify dimensions– Ex: myTable = new double[rows][columns];

• Defining multidimensional array with non-default values– Use an initialization list

• Accessing a multidimensional array element– Use N subscript operators for N dimensions– Example: myTable[row][col] = item;

• Processing multidimensional arrays – Use N for loops to traverse array with N dimensions


Lists in Java

• Interface: a structure that only declares methods

• A class implementing an interface defines methods

• Example: String implements CharSequence• Java’s List is an interface

• Two classes implementing List– LinkedList: similar to Alice’s list data structure– ArrayList: dynamic container offering fast access


Lists in Java (continued)


Lists in Java (continued)


Using ArrayLists

• ArrayList implements the List interface• Features of an ArrayList

– Reference type data structure– Can increase in size during execution– set()and get()access items in constant time

• Patterns for declaring and defining an ArrayList

• Insert items in an ArrayList using add()


Using ArrayLists

• Rules for declaring an array list– The type of an array list must be a reference type– Use a wrapper class when a primitive type is needed

• Wrapper class contains primitive type plus operations

• Pattern for declaring an ArrayList– ArrayList<ItemType> handleName = null;

• Example of a ArrayList declaration– ArrayList<Double> listOfNumbers = null;

• Produces a handle called listOfNumbers• listOfNumbers is capable of storing an arbitrary

number of Double objects


Using ArrayLists (continued)


Using ArrayLists (continued)


Summary

• Array: fixed-size container used to store items of the same type

• Items: values stored in an array’s elements

• Accessing an array element is a constant time operation

• Inserting and removing items in an array are linear time operations

• Arrays can have an arbitrary number of dimensions• ArrayList includes the random access capability of

arrays and the ability to change size

Documents

Alice in Action with Java Chapter 12 Arrays and Lists in Java