CompSci 230 S2 2017

Programming Techniques
ArrayLists
 Agenda & Reading
 Topics:
 Introduction to Collections and Class ArrayList
 ArrayLists
 ArrayList with Generics
 Wrapper Classes
 ArrayLists Vs Arrays
 Reading
 Java how to program Late objects version (D & D)
 Chapter 6
 The Java Tutorial
 ArrayLists
 http://www.tutorialspoint.com/java/java_arraylist_class.htm

2 Lecture07
 1.Introduction
 Introduction to Collections and Class ArrayList
 Collections provide efficient methods that organize, store
and retrieve your data without requiring knowledge of how
the data is being stored.
 ArrayLists:
 Everything stored must be an Object (non-primitive data types)
 Objects can be different types
 provides methods for adding and removing
 keeps track of the list capacity (the length of the allocated array)
and list size (the number of elements currently in the list)
 Example: capacity
import java.util.ArrayList; size
...
ArrayList list = new ArrayList(); "Cat" "Hat" "Bat"
... ...
3 Old Lecture07
version
 2.ArrayLists
Advantages & Disadvantages
 Advantages:
 Size is dynamic, rather than fixed.
 Disadvantages:
 Less efficient than arrays
 Lacks familiar [ ] syntax (Java limitation, supported by C+
+)
 Base type must be an object (not primitive) type

4 Lecture07
 2.ArrayLists
Methods

5 Lecture07
 2.ArrayLists
Methods to add elements
 Only objects can be added to an ArrayList.
 public boolean add(Object x)
list.add( "One" ); One Two Three
list.add( "Two" );
list.add( "Three" );

 Adds an object to the end of the list, adjusts the size of the list; returns
true
 Objects can be added to a specific position in an ArralyList:
 public void "One"
list.add( add(int
); index, Object o)
One Fred Two Thre
list.add( "Two" ); e
list.add( "Three" );
list.add( 1, "Fred" );

 Inserts x at position index, sliding elements at position index and higher to

the right (adds 1 to their indices) and adjusts size.
 Capacity increases if necessary
6 Lecture07
 2.ArrayLists
Search methods
 public boolean contains (Object target )
 True if ArrayList contains target; false otherwise.
true
System.out.println(list.contains("Three" ));

 public int indexOf (Object target )

 Returns index of first occurrence of target in ArrayList; -1
otherwise.
int i = list.indexOf("Fred" ); 1

 public int lastIndexOf (Object target )

 Same as above except index of last occurrence is returned.

7 Lecture07
 2.ArrayLists
Size & Capacity
 public boolean isEmpty ( )
 True if empty; false otherwise.
System.out.println(list.isEmpty()); false

 public int size ( )

 Returns number of elements in ArrayList
System.out.println(list.size());

4
 public void clear ( )
 Removes all elements; size() becomes 0
list.clear();

8 Lecture07
 2.ArrayLists
Methods to remove elements
 Object remove(int index) One Fred Two Thre
e
 where 0<=index<size() (or exception) Fred Two Thre
e
 Removes element at index; shifts to the left remaining
elements at index+1 … size()-1.
list.remove( 0 ); String s = (String) list.remove( 0 );
System.out.println(s); One

 boolean remove(Object theElement)

 if found then removes the first occurrence of theElement;
shifts the remaining elements to the left; size() becomes
size()-1; returns true. One Fred Two Thre
e
 ifboolean
not found then returns false.
n = list.remove("Three");
System.out.println(n);
One Fred Two
true
9 Lecture07
 2.ArrayLists
Array-like methods
 public Object set ( int index, Object newElement )
 where 0<=index<size() (or exception)
 Replaces the element at index with a newElement and
returns the element formerly at the specified
One position.
Fred Two

System.out.println(list.set(0, "Hello"));
One
Hello Fred Two

System.out.println(list.set(4, "Good"));
Exception in thread "main"
 public Object get ( int index ) java.lang.IndexOutOfBoundsException:

 where 0<=index<size() (or exception)

 Returns the element at index.
Hello Fred Two

Hello
System.out.println(list.get(0));

System.out.println(list.get(4)); Exception in thread "main"

10 java.lang.IndexOutOfBoundsException: Lecture07
 2.ArrayLists
Methods to print the list
 public String toString() Hello Fred Two

 Returns a String which contains all the object in the

ArrayList
System.out.println(list.toString()); [Hello, Fred, Two]

Hello
 Using
for( int a For
i=0; loop
i<list.size(); i++ ) { Fred
System.out.println(list.get(i).toString()); Two
}

11 Lecture07
 2.ArrayLists
Equality
 public boolean equals ( Object other )
 True only when both are of the same size, and both have
the same elements with the same order.
list.add("Hello");
list.add("Two"); false
list.add("Fred");

myList2.add("Two");
myList2.add("Hello");
myList2.add("Fred");
System.out.println(list.equals(myList2));

12 Lecture07
 2.ArrayLists
Different Types Old
version

 Stored elements may be of different types

 Example: Objects of type Integer, Character and Point
could all be stored in ArrayList. (Object is a superclass of
Integer, Character and Point.myList2.clear();
Therefore, all are of type
Object) myList2.add(new Integer(5));
myList2.add(new Character('c'));
[5, c, java.awt.Point[x=10,y=20]]
myList2.add(new Point(10,20));
System.out.println(myList2);

 Need to be concerned about type returned by

ArrayList method.
 Notice: Return type for get, set and remove are of type
Integer i = (Integer) myList2.get(0);
System.out.println(i);
Object. If the Point
returned object
p = (Point) is to be used
myList2.get(2); 5 with a particular
System.out.println(p);
class, it needs to be cast to that class type. java.awt.Point[x=10,y=20]

13 Lecture07
 Exercise 1
 What is the output of the following code fragment?
ArrayList list = new ArrayList();
Point pt1 = new Point(3, 4);
list.add( pt1 );
Point pt2 = (Point) list.get( 0 );
pt2.x = 23;
if ( pt2 == pt1 ) {
System.out.println( "Same object" );
} else {
System.out.println( "Different object" );
}
System.out.println();

14 Lecture07
 3.Generic ArrayLists
 Starting with Java 5, ArrayList<T> and other collection classes
hold objects of a specified data type.
 The T (by convention) is a placeholder—when declaring a new
ArrayList, replace it with the type of elements that you want the
ArrayList to hold.
 Classes with this kind of placeholder that can be used with any type
are called generic classes.
 The elements’ data type is shown in angle brackets and
becomes part ofwords
ArrayList<String> the =ArrayList type. For example:
new ArrayList<String>();
ArrayList<Integer> nums = new ArrayList<Integer>();

 ArrayList<String> appears in the variable declaration and in the

class instance creation expression.
 Using <> in a class instance creation expression tells the compiler to
determine what belongs in the angle brackets.
15 Lecture07
 L07Code02.jav
3.Generic ArrayLists a

Adding elements & for-each loop

 Adding elements: [One, Two, Three]

ArrayList<String> words = new ArrayList<String>();

words.add("One");
words.add("Two");
words.add("Three");
System.out.println(words);

 Enhanced for Statement

 The for-each loop is used to access each successive value
in a collection of values.
 Syntax: forStatement;
(Base_Type var :Collection_Object)

Elements are
 Example: all in the same Standard for-
type. loop
for (String str : words)
System.out.println(str); for( int i=0; i<words.size(); i++ )

System.out.println( words.get( i ));

16 Lecture07
 4.Wrapper Classes
 Each primitive data type has a corresponding
Wrapper class.
 Java’s primitive data types (boolean, int, etc.) are not
classes.
 Wrapper classes are used in situations where objects are
Data Type Wrapper
required.
boolean Boolean
 The
char wrapper class can be used to convert a primitive into
Character
an
byteobject type.
Byte
short Short
int Integer
long Long
float Float
double Double

17 Lecture07
 4.Wrapper Classes
Value => Object: Wrapper Object Creation
 Wrapper.valueOf() takes a value (or string) and
returns an object of that class:
Integer i1 = Integer.valueOf(42);
Integer i2 = Integer.valueOf("42");

Boolean b1 = Boolean .valueOf(true);

Boolean b2 = Boolean .valueOf("true");

 Using object creation:

Integer i1 = new Integer(42);

Character cC = new Character('b');

Boolean bB = new Boolean(true);

18 Lecture07
 4.Wrapper Classes
Object => Value & String => value
 Each wrapper class Type has a method typeValue to
obtain the object’s value: intValue(), doubleValue(),
charValue() etc
System.out.println(i1.intValue()); 42
System.out.println(c1.charValue()); b
System.out.println(b1.booleanValue()); true

 It also has a method parseType() to parse a string

representation & return the literal value.
Integer.parseInt("42") => 42
Boolean.parseBoolean("true") => true
Double.parseDouble("2.71") => 2.71

19 Lecture07
 4.Wrapper Classes
Auto boxing
 Since Java 5, conversion from int to Integer and from
double to Double is, in most cases, automatic
(autoboxing/autounboxing)
ArrayList<Integer> numbers = new ArrayList<Integer>();

numbers.add(12);
numbers.add(5); autoboxing
int sum = 0;

for (int i : numbers) {

sum += i; autounboxing
}
System.out.println("Total=" + sum);

20 Lecture07
 Exercise 2
 What is the output of the following code fragment?
ArrayList<Integer> x = new ArrayList<Integer>();
x.add(3);
x.add(5);
x.add(8);
x.add(9);

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

y.add(6);
y.add(7);
y.add(1);
y.add(2);

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

x.set(i, y.get(i));
y.set(i, x.get(i));
}

System.out.println(x);
System.out.println(y);

21 Lecture07
 5.ArrayLists Vs Arrays
 Capacity:
 Array: Once you set the array size, you cannot change it easily.
int actualSize = . . .;
Point[] points1 = new Point[actualSize];

 ArrayList: It automatically adjusts its capacity as you add and remove

Initial capacity
elements, without your needing to write any code. = 10
ArrayList<Point> points2 = new ArrayList<Point>();

 If the internal array is full, the array list automatically creates a bigger array
andArrayList<Point>
copies all the objects
points2from theArrayList<Point>(100);
= new smaller to the bigger array.
capacity = 100

 Printing the entire array/ArrayList:

System.out.println(points1); [Ljava.awt.Point;@659e0bfd
 Array : print the memory address only

 ArrayList: print the entire list [java.awt.Point[x=1,y=2],

System.out.println(points2);
22 java.awt.Point[x=3,y=4]] Lecture07
 5.ArrayLists Vs Arrays
Capacity
 Distinction between the capacity
 array: new Point[100]; // size is 100
 If you allocate an array with 100 entries, then the array has 100 slots, ready
for use. new ArrayList<Point>(100); // capacity is 100
 ArrayList:
 An array list with a capacity of 100 elements has the potential of holding
100 elements (and, in fact, more than 100, at the cost of additional
reallocations);
 At the beginning, even after its initial construction, an array list holds no
elements at all.
points1.length
 Actual number of elements inside the array/ArrayList
 array:
 returns thepoints2.size()
actual number of elements in the array

 ArrayList:
 returns the actual number of elements in the ArrayList
23 Lecture07
 5.ArrayLists Vs Arrays
Accessing Elements
 To access or change the element:
 Array: points1[i] = new Point(1,2);
Use [] syntax to access or change the element of an array


 ArrayList: points2.set(i, new Point(1,2));

 Use the get and set methods to access or change the element in the ArrayList
 Note: Do not call list.set(i, x) until the size of the ArrayList is larger than i.
 Use the add method instead of set to fill up an array, and use set only to replace a
previously added element.
 To get an element
Point p = points1[i];
 Array: After Java SE
5.0
 ArrayList: Point p = points2.get(i);
 Before Java SE 5.0, there were no generic classes, and the get method of the raw ArrayList
class had no choice but to return an Object.
 Consequently, callers of get had to cast the returned value to the desired type:
Before Java SE
Point p = (Point) points2.get(i); 5.0

 The raw ArrayList is also a bit dangerous. Its add and set methods accept objects of any
type and you run into grief only when you retrieve the object of another type and try to
cast it.
24 Lecture07
 5.ArrayLists Vs Arrays
Converting between Array and ArrayList
 Array to ArrayList java.awt.Point[x=1,y=2]
 Use the asList() method in the Arrays class java.awt.Point[x=3,y=4]
Point[] points1 = {new Point(1,2), new Point(3,4)};
ArrayList<Point> points2 = new
ArrayList<Point>(Arrays.asList(points1));
for (Point p: points2)
System.out.println(p);

 Note: The Arrays class provides static methods for common

array manipulations. For example:
 sort() - for sorting an array
 equals() for comparing arrays
 fill() for placing values into an array
 ArrayList to Array
 Use the toArray() method from the ArrayAList class
String[] copy = new String[words.size()]; One
copy = words.toArray(copy); Two
for (String i: copy) Three
System.out.println(i);
25 Lecture07
 Exercise 3
 Write a static method to get distinct elements from an
array. The method returns an ArrayList which
contains
int[] distinct
numbers = {25, 2, 5, 9,elements.
10, 15, 8, 2, 5, 9}; [25, 2, 5, 9, 10, 15, 8]
System.out.println(getUnique(numbers));

public static ArrayList<Integer> getUnique(int[] source) {

//create ...

for (int value: source) {

}
return uniqueList;
}

26 Lecture06