1

ArrayList

Starring: Purse, Sr.

Co-Starring: Purse, Jr.

Poe

Numbers

2

Purpose:

In this lecture series we will introduce the concept of a LIST.

We will take a look at Java’s ArrayList class that implements Java’s List interface.

The AP subset includes the ArrayList as part of the testable material on the AB exam.

3

Resources:

Barrons Chapter 6, Chapter 11 p.362 & 368-370Java.util.ArrayList

Java Essentials Chapter 13 p.521

Java Essentials Study Guide Chapter 11 p.163 & Chapter 16 p.263

4

Resources:

Java Methods Data Structures Chapter 2 p.33

APCS Course Description p.27 Paragraphs 2 & 3

5

Intro:

In Computer Science II we discussed Arrays as well as Java’s Arrays class.

With Arrays, we learned to use 1 and 2 dimensional arrays of primitives and objects, passing arrays as parameters, Bubble Sorting an array.

6

Intro:

With the Arrays Java class (it is really a Static utility class) , java.util.Arrays, we used it’s methods to sort & search (Binary Search) & compare its elements which can contain primitives or objects. This class works with existing user defined arrays.

7

Now we will take one step forward by discussing the Java ArrayList.

This class introduces the concept of a List.

The List is an ADT and will be discussed in greater detail when we learn about ADT’s & Data Structures.

8

AP AB Subset: Lets read the Course Description regarding ArrayList on

page 22 (last 2 paragraphs) & page 24 (top)

..\AP Student Reference Material\2006 AP Course

Description.pdf

9

What we will Cover in this Lecture:

You will initially create YOUR OWN ArrayList and use it in a test application.

Elements of a List A First look at the List interface java.util.List Arraylist:

Where it fits in the Collections Hierarchy

A Look at java.util.ArrayListWorking with the ArrayList

adding an element Get the SizeRetrieve (Get) an ElementModify (Set) the State of an

Element Remove an element

10

What we will Cover in this Lecture:

Arraylist and Generics

Big-O of ArrayList

Best Use for this type of Data Structure

Wrapping Numbers

What is critical for the AP Exam

11

TPS: Use the following files, located on the

APCompSci WebPage, to create your ownimplementation of an ArrayList:

MyArrayList.java Is a class shell containing the methods you need to code

UseMyArrayList.java Is a sample Driver program (SPVM) that utilizes your ArrayList. It should execute as is.

Download your COPY of these files, implement and test your version of MyArrayList

12

Elements of a List:

A Look at the following diagram, one we will see MANY times throughout the year, shows a class Hierarchy.

Lets focus on the List Interface

Then we will look at a class, ArrayList, that implements the List interface.

13

14

On an ABSTRACT Level, a generic List contains a number of elements (values or objects) arranged in sequence from which we can locate a specific list element, add elements to the list and remove elements from the list.

This is the framework or definition of an Abstract List Data Structure

A List is an Abstract Data Type (ADT)

15

We could further define the List to be in some ordered sequence and include a behavior that permits an element to be placed “in order” onto the List

This would be called an Ordered List

This is merely a structure or a set of criteria that can be implemented different ways

16

We can have an Array implementation of the Abstract List Structure. All we need to do is make sure we provide for the BEHAVIORS as specified in the Criteria for a List (add, remove, get, size, modify)

As we will see later in the year, we can provide other implementations such as a Linked List implementation

17

The specific implementation of an Abstract Structure depends on the needs of the system or problem you are attempting to resolve.

18

As we will see, we can evaluate the effectiveness of a specific implementation by evaluating its order of growth or Big-O. Each behavior of the List Structure that is implemented will carry a “COST” that is specific to the type of implementation.

For example, Suppose we are asked to develop a system that requires us to maintain a list of students and the list was ordered by Last Name.

19

Now, in this system the Dominant behavior will be Searching for a specific student in the list. The list , once built , will not change much but it will be accessed frequently for student info.

20

In this case we need to implement a list with a Data Structure that minimizes the “cost” of searches. In this case we COULD design an ArrayList implementation because it has a low cost for finding a specific element (binary search or hash implementation).

21

The “cost” of a find behavior against an Ordered ArrayList would be Log N (Binary Search) or O( 1 ) (hash)

That is much better than a “cost” of N (linear) if we used a Linked List implementation for this system.

We will soon see that there are other options such as a Binary Tree implementation.

22

At this point, make sure you keep clear that we have a Concept that is an Abstract Data Structure (ADT) such as a List

An Implementation of that ADT such as an ArrayList

Each implementation must be evaluated against their relative “costs” when deciding which one to use for a particular system

23

A First look at the List interface interface java.util.List <E> interface:

boolean add(E o) int size() E get(int index) E set(int index, E element)

/* replaces the element at index with element returns the element formerly at the specified position */

Iterator E iterator() ListIterator E listIterator()

24

The actual Java List interface includes many more methods, but for AP purposes, these are the ones we need to be able to work with although we are adding the Remove method

As you can see, this interface merely identifies the behaviors that MUST exist in a List

25

The actual implementation of which is left to the specific data structure (ArrayList for example)

For now, ignore the Iterator and ListIterator behaviors as we will discuss these at a later time.

26

NOTE: The List Interface is Typed with <E>

As we have already discussed, This indicates that ALL classes that implement the

List interface will be designed to be instantiated to be used with a specific class (or class hierarchy) at design time.

27

The benefit here is there will not be a need to cast to the desired object.

In previous versions of Java, the List was designed to work with the Object

Class SO any methods of List accepted and/or returned a generic Object

Reference that had to be CAST into the desired class.

Example:

28

BEFORE:

Runner myRunner = new Runner();

List L = new ArrayList();

L.add( myRunner);

// Retrieve from List

Runner r ;

r = (Runner) L.get(0);

r.getHoursTrained();

29

NOW:Runner myRunner = new Runner(); List<Runner> L = new ArrayList<Runner>();L.add( myRunner); // Retrieve from Listi = (L.get(0)).getHoursTrained();

See how the Generic Version will return the TYPE of object declared in the < >

Therefore, there is no need to cast

30

However, you can still generate an Arraylist WITHOUT Generics

31

Why is such an Interface Important ?

What benefits, if any, does it provide ?

What does a List limit its elements to be ?

32

Objects, You can only have a List that contains Objects, you CAN NOT have a List of primitive data types

What can you do if your list needs to maintain integers or doubles ?

Since, all classes extends from Object, you may fill in a List with any kind of object like Strings, arrays or instances of your own defined class

33

The List interface, as with other interfaces, does not define any Constructors that is left up to the class that implements this interface

For the methods that remove or find a specific element they need to handle situations where the INDEX being sought is not in the range of the list

In these instances, you need to throw an IndexOutOfBoundsException

34

Arraylist:

Where it fits in the Collections Hierarchy:

ArrayList implements the List interface therefore it MUST provide for behaviors

for all of the methods in the interface

A Look at java.util.ArrayList:

public class ArrayList extends AbstractList

implements List

35

class java.util.ArrayList Notes:

AP Computer Science AB students need to know that ArrayList implements List & which methods from ArrayList  implement those specified by List.

Required methods specified by interface java.util.List ListIterator listIterator() (AB only) int size() boolean add(Object x)

Required methods not part of interface java.util.List E get(int n) void set(int n, E element) boolean add(int n, E element) E remove(int n)

36

Lets look at the java.util.ArrayList in the Java API (javadocs)

Notice the Constructors and overloaded methods as well as the Generic Type <E>

37

Working with the ArrayList:

In the previous lecture, Advanced Classes, we used the Coin and Purse example. The Purse had a Add method that simply accumulated the total value of coins in the purse

However, it did NOT keep track of each individual Coin or Traveler Check

38

Suppose we were to modify the requirements of the Purse class to maintain information on EACH separate Coin in the Purse.

How could we accomplish this ?

39

One way would be to maintain an Array of coins

The limitation of this would be that, unless we knew how many Coins we would have the array would be too big or too small

40

We might have to repeatedly have to resize the array (reallocate new space) to handle a large number of Coins.

Also, if we needed to obtain a specific Coin in the array or modify a specific Coin we would need to write that code from scratch

This is where the ArrayList comes in

41

We could maintain an ArrayList of objects that implement the Top Interface

In the Purse class we would add a new class level attribute and modify the constructor:

private ArrayList myArray;

public Purse ()

{

myArray = new ArrayList(100);

// initial capacity of 100 objects

}

42

This array list can hold any type of object but we will limit it to any object that implements the Top interface

We then would need to maintain the elements every time the user added a new coin or travelers check to the purse:

43

Adding an element: We are adding an instance of a class that implements

the Top interface to the ArrayListpublic void add(Top ci)

{ // code here if (count == 0 || max.getTop() < ci.getTop() ){

max = ci;}count++;sum += ci.getTop();// added for arraylist// add new "coin" or "TC" superobject to listmyArray.add(ci);

}

44

There is also an overloaded add method that adds an object at a specified index, sliding all elements at that index and higher up one element --- TRY THIS ONE ON YOUR OWN

45

Get the Size:Instead of using the count attribute, we

can use the ArrayList’s size method

public int getCount()

{

// return count;

return myArray.size();

}

46

Retrieve (Get) an Element:

public Object getElement(int i)

{

return myArray.get(i);

}

Realize that the get method of ArrayList returns a generic Object reference

You must cast this return type to the appropriate child / sub class before using it

47

SPVM…Object o = myPurse.getElement(1);

if (o instanceof Coin){

System.out.println("the 2nd element in the Purse is a Coin");

}

o = myPurse.getElement(2);

if (o instanceof TravelerCheck){

System.out.println("the 3rd element in the Purse is a TC");

}

}

The output results in both out messages being displayed

48

Modify (Set) the State of an Element :

This method mutates an existing object in the ArrayList

It accepts an index and an Object and returns the object that was replaced

Set can only overwrite existing values and NOT create new elements in the List

49

public Object setElement(int e, Object o)

{

return myArray.set(e, o);

} SPVM…

// modify an element -- replace a Coin with a TC

o = myPurse.setElement(0, myStuff[2]);

if (o instanceof Coin)

{

System.out.println("the 1st element was a Coin");

}

50

Remove an element:

This method will remove a given element from the list and return it

It will move all elements from the index removed forward up one place and reduce the logical size of the List by 1

51

public Object RemoveElement(int i)

{

return myArray.remove(i);

}

SPVM…

52

// remove an elemento = myPurse.RemoveElement(1);if (o instanceof Coin) // TRUE

{System.out.println("the 2nd element Coin

is removed");}

System.out.println("There are " + myPurse.getCount() + " Objects in the Purse");

o = myPurse.getElement(2); // the result is an IndexOutOfBoundsException// as there are now only 2 elements in the // ArrayList

53

TPS: How Can we display the contents of the Purse ?

54

ANS:// Add to SuperObject:

public String toString(){

return myName;}Add to Purse:public String toString(){

String s = " ";

for(int x = 0; x < myArray.size(); x++){

s += ((SuperObject)myArray.get(x)).toString();s += " ";

} return s;

}

55

Call in SPVM:

// display the types of objects in the purse

String ss = myPurse.toString();

System.out.println("the elements in the purse are now " + ss);

56

As one of your projects, you will convert this old style use of ArrayList into a Generic, TYPED version

This version of the code is ONLINE in the newpurse.zip file in the code examples section

57

Big-O of ArrayList:

The “cost” of an operation

Big-o of different options (AVERAGE CASE):

add contains remove size constructor

N N N 1 1

Arraylist(uniqueness)

1 N or N*M N N 1

ArrayList(all dups)

58

N LogN

8 3

1024 10

1M 20

Be aware that there are “hidden” details that occur on an ArrayList that are Abstracted from the user of this type of list implementation.

The overloaded Add method requires the ArrayList to MOVE many elements down the list when a new item is added somewhere inside the list. This effects efficiency

59

The same can be said for the Remove method

In the worst case almost ALL of the elements need to be shifted

The get and set methods operate in constant time O (1) as regardless of the list size, they require one step and are, therefore, extremely efficient

60

Best Use for this type of Data Structure:

This data structure is excellent in situations where the actual size of the elements is not known until the program executes, but once established remains stable

This structure is also best used in cases where specific elements are frequently modified

61

When finding the value of a specific element index is frequently performed

When you add objects to the end of the list

When removing a specific object (index) is frequently performed

62

TPS: How would you store Numbers in an ArrayList ?

Java Essentials chapter 13 Section 3 p.530

63

Wrapping Numbers:

ArrayLists MUST contain objects

What if we need to maintain a list of simple numbers ?

You must “wrap” these primitives in a child of the Number class, HOWEVER…

64

Java Provides AUTO BOXING (barrons p.181) where the primitive will automatically be converted into the appropriate class

Example:

ArrayList<Integer> x = new ArrayList<Integer> ();

x.add(55);55 is wrapped into an Integer instance

before the argument is passed to the add method

65

There is also AUTO UNBOXING where a returned number class is converted to its primitive

Example:

int c = x.get(2);

The Integer object returned by get is converted to its primitive version before being assigned to the int variable c

66

Tips for the AP Exam:

Elements of a list start at index 0

Make sure any iteration on a list does not go out of bounds by USING THE FOR EACH LOOP

ArrayLists store Objects and you need to TYPE the ArrayList to work with your specific Object or Object Hierarchy using Generics

67

Using equals with Array Lists uses the TYPED Classes’ overloaded equals method

68

Projects:

NewPurse

ListOfNumbers

69

TEST FOLLOWS THE PROJECT DUE

DATE !!!