Object-Oriented

Programming

Collection of Data
Acknowledgement
 The contents of these slides have origin from
School of Computing, National University of
Singapore.
 We greatly appreciate support from Mr. Aaron
Tan Tuck Choy, and Dr. Low Kok Lim for
kindly sharing these materials.

2
Policies for students
 These contents are only used for students
PERSONALLY.
 Students are NOT allowed to modify or
deliver these contents to anywhere or anyone
for any purpose.

3
Objectives

Using arrays

Generics: Allowing operations not

tired to a specific data type

Classes: Vector and ArrayList

[503005 Lecture 10: Collection of Data]

4
References

Book
• Array: Chapter 1, Section
1.1, pages 35 to 38
• Generics: Chapter 9, Section
9.4, pages 499 to 507

[503005 Lecture 10: Collection of Data]

5
Outline (1/2)
0. Recapitulation 2. Generics
2.1 Motivation
1. Array
2.2 Example: The IntPair
1.1 Introduction
Class (non-generic)
1.2 Array in C
2.3 The Generic Pair Class
1.3 Array in Java
2.4 Autoboxing/unboxing
1.4 Array as a Parameter
2.5 The Generic NewPair
1.5 Detour: String[] in Class
main() method
2.6 Using the Generic
1.6 Returning an Array NewPair Class
1.7 Common Mistakes 2.7 Summary
1.8 2D Array
1.9 Drawback

[503005 Lecture 10: Collection of Data]

6
Outline (2/2)
3. Vector
3.1 Motivation
3.2 API Documentation
3.3 Example
4. ArrayList
4.1 Introduction
4.2 API Documentation
4.3 Example

[503005 Lecture 10: Collection of Data]

7
0. Recapitulation
 We explored OOP concepts learned in week 2 in
more details (constructors, overloading methods,
class and instance methods).
 In week 3, we learned some new OOP concepts
(encapsulation, accessors, mutators, “this”
reference, overriding methods)
 UML was introduced to represent OO
components

[503005 Lecture 10: Collection of Data]

8
1 Array

A collection of homogeneous data

 Introduction
Array
 Array is the simplest way to store a collection
1.

of data of the same type (homogeneous)

 It stores its elements in contiguous memory
 Array index begins from zero
 Example of a 5-element integer array A with
elements filled
A
24 7 -3 15 9

A[0] A[1] A[2] A[3] A[4]

[503005 Lecture 10: Collection of Data]

10
 Array in C (1/2)
Array
1.

#include <stdio.h> // To read values into arr and return

#define MAX 6 // the number of elements read.
int scanArray(double arr[], int max_size) {
int scanArray(double [], int); int size, i;
void printArray(double [], int);
double sumArray(double [], int); printf("How many elements? ");
scanf("%d", &size);
int main(void) { if (size > max_size) {
double list[MAX]; printf("Exceeded max; you may only enter");
int size; printf(" %d values.\n", max_size);
size = max_size;
size = scanArray(list, MAX); }
printArray(list, size); printf("Enter %d values: ", size);
printf("Sum = %f\n", for (i=0; i<size; i++) {
sumArray(list, size)); scanf("%lf", &arr[i]);
}
return 0; return size;
} }
sum_array.c

[503005 Lecture 10: Collection of Data]

11
 Array in C (2/2)
Array
sum_array.c
// To print values of arr
1.

void printArray(double arr[], int size) {

int i;

for (i=0; i<size; i++)

printf("%f ", arr[i]);
printf("\n");
}

// To compute sum of all elements in arr

double sumArray(double arr[], int size) {
int i;
double sum = 0.0;

for (i=0; i<size; i++)

sum += arr[i];
return sum;
}

[503005 Lecture 10: Collection of Data]

12
 Array in Java (1/2)
Array
 In Java, array is an object.
1.

 Every array has a public length attribute (it is not a method!)

public class TestArray1 { TestArray1.java

public static void main(String[] args) {

Declaring an array:
int[] arr; // arr is a reference datatype[] array_name
// create a new integer array with 3 elements
// arr now refers (points) to this new array
arr = new int[3]; Constructing an array:
array_name = new datatype[size]
// using the length attribute
System.out.println("Length = " + arr.length);
Length = ?
arr[0] = 100; Accessing individual arr[0] = ?
arr[1] = arr[0] - 37; array elements.
arr[2] = arr[1] / 2;
arr[1] = ?
for (int i=0; i<arr.length; i++) arr[2] = ?
System.out.println("arr[" + i + "] = " + arr[i]);
}
}
 [503005 Lecture 10: Collection of Data]
13
 Array in Java (2/2)
Array  Alternative loop syntax for accessing array elements
1.

 Illustrate toString() method in Arrays class to print an array

public class TestArray2 { TestArray2.java
public static void main(String[] args) {
// Construct and initialise array
double[] arr = { 35.1, 21, 57.7, 18.3 };
// using the length attribute
System.out.println("Length = " + arr.length);
Length = 4
for (int i=0; i<arr.length; i++) {
35.1 21.0 57.7 18.3
System.out.print(arr[i] + " ");
35.1 21.0 57.7 18.3
}
[35.1, 21.0, 57.7, 18.3]
System.out.println();
Syntax (enhanced for-loop):
// Alternative way for (datatype e: array_name)
for (double element: arr) {
System.out.print(element + " "); Go through all elements in the array. “e”
} automatically refers to the array element
sequentially in each iteration
System.out.println();
System.out.println(Arrays.toString(arr));
} Using toString()
} method in Arrays class
[503005 Lecture 10: Collection of Data]
14
 Array as a Parameter
Array
 The reference to the array is passed into a method
1.

 Any modification of the elements in the method will affect the

actual array
public class TestArray3 { TestArray3.java
public static void main(String[] args) {
int[] list = { 22, 55, 33 };
swap(list, 0, 2);
for (int element: list)
System.out.print(element + " ");
System.out.println();
}
// To swap arr[i] with arr[j]
public static void swap(int[] arr, int i, int j) {
int temp = arr[i]; arr[i] = arr[j]; arr[j] = temp;
}
}

 [503005 Lecture 10: Collection of Data]

15
 Detour: String[] in main() method
Array
 The main() method contains a parameter which is an array of
1.

String objects
 We can use this for command-line arguments
public class TestCommandLineArgs { TestCommandLineArgs.java
public static void main(String[] args) {
for (int i=0; i<args.length; i++)
System.out.println("args[" + i + "] = " + args[i]);
}
}

java TestCommandLineArgs The "Harry Potter" series has 7 books.

args[0] = The
args[1] = Harry Potter
args[2] = series
args[3] = has
args[4] = 7
args[5] = books.
[503005 Lecture 10: Collection of Data]
16
 Returning an Array
Array
 Array can be returned from a method
1.

public class TestArray4 { TestArray4.java

public static void main(String[] args) {
double[] values;
values = makeArray(5, 999.0); 999.0
499.5
for (double value: values) {
333.0
System.out.println(value + " ");
} 249.75
} Return type: 199.8
datatype[]
// To create an array and return it to caller
public static double[] makeArray(int size, double limit) {
double[] arr = new double[size];
for (int i=0; i < arr.length; i++)
arr[i] = limit/(i+1);
return arr;
}
}

[503005 Lecture 10: Collection of Data]

17
 Common Mistakes (1/3)
Array
 length versus length()
1.

 To obtain length of a String object str, we use the

length() method
 Example: str.length()
 To obtain length (size) of an array arr, we use the
length attribute
 Example: arr.length
 Array index out of range
 Beware of ArrayIndexOutOfBoundsException
public static void main(String[] args) {
int[] numbers = new int[10];
. . .
for (int i = 1; i <= numbers.length; i++)
System.out.println(numbers[i]);
}
[503005 Lecture 10: Collection of Data]
18
 Common Mistakes (2/3)
Array
 When you have an array of objects, it’s very
1.

common to forget to instantiate the array’s

objects.
 Programmers often instantiate the array itself
and then think they’re done – that leads to
java.lang.NullPointerException
 Example on next slide
 It uses the Point class in the API
 Refer to the API documentation for details

[503005 Lecture 10: Collection of Data]

19
 Common Mistakes (3/3)
Array
Point[] array = new Point[3]; array
1.

for (int i=0; i<array.length; i++) {

array[i].setLocation(1,2);
null
}
null

There are no objects referred to by null

array[0], array[1], and array[2], so how to

call setLocation() on them?!
x 01
Corrected code: array y 02
Point[] array = new Point[3];
x 01
for (int i=0; i<array.length; i++) {
array[i] = new Point(); y 02
array[i].setLocation(1,2);
} x 01
y 02

[503005 Lecture 10: Collection of Data]

20
 2D Array (1/2)
Array
 A two-dimensional (2D) array is an array of array.
1.

 This allows for rows of different lengths.

// an array of 12 arrays of int
int[][] products = new int[12][];

int[][] array2D = { {4,5,2}, {1,3},

{7,1,5,6} };
4
array2D
5
2
1
3
7
1
5
6

[503005 Lecture 10: Collection of Data]

21
 2D Array (2/2)
array2D 4

Array
5
2
1
1.

7 3
1
5
public class Test2DArray {
6
public static void main(String[] args) {
int[][] array2D = { {4, 5, 2}, {1, 3}, {7, 1, 5, 6} };
System.out.println("array2D.length = " + array2D.length);
for (int i = 0; i < array2D.length; i++)
System.out.println("array2D[" + i + "].length = "
+ array2D[i].length);
for (int row = 0; row < array2D.length; row++) {
for (int col = 0; col < array2D[row].length; col++)
System.out.print(array2D[row][col] + " ");
System.out.println(); array2D.length = 3
}
array2D[0].length = ?
}
}
array2D[1].length = ?
Test2DArray.java array2D[2].length = ?
?
?
?
 [503005 Lecture 10: Collection of Data]
22
 Drawback
Array
 Array has one major drawback:
1.

 Once initialized, the array size is fixed

 Reconstruction is required if the array size changes
 To overcome such limitation, we can use some classes related
to array
 Java has an Array class
 Check API documentation and explore it yourself
 However, we will not be using this Array class much;
we will be using some other classes such as Vector or
ArrayList
 Differences between Vector and ArrayList are in slide 41
 Before doing Vector/ArrayList, we will introduce
another concept called Generics
[503005 Lecture 10: Collection of Data]
23
2 Generics

Allowing operation on objects of

various types
 Motivation
Generics
 There are programming solutions that are
applicable to a wide range of different data types
The code is exactly the same other than the data
2.

type declarations
 In C, there is no easy way to exploit the similarity:
 You need a separate implementation for each data
type
 In Java, you can make use of generic
programming:
 A mechanism to specify solution without tying it
down to a specific data type

[503005 Lecture 10: Collection of Data]

25
 Eg: The IntPair Class (non-
Generics
generic)
Let’s define a class to:
 Store a pair of integers, e.g. (74, -123)
 Many usages, can represent 2D coordinates, range (min to
2.

max), height and weight, etc.

IntPair.java
class IntPair {
private int first, second;
public IntPair(int a, int b) {
first = a;
second = b;
}
public int getFirst() { return first; }
public int getSecond() { return second; }
}

[503005 Lecture 10: Collection of Data]

26
 Using the IntPair Class (non-
Generics
generic)
// This program uses the IntPair class to create an object
// containing the lower and upper limits of a range.
// We then use it to check that the input data fall within
// that range. Enter a number in (-5 to 20): -10
2.

import java.util.Scanner; Enter a number in (-5 to 20): 21

public class TestIntPair {
Enter a number in (-5 to 20): 12
public static void main(String[] args) {

IntPair range = new IntPair(-5, 20);

Scanner sc = new Scanner(System.in);
int input;

do {
System.out.printf("Enter a number in (%d to %d): ",
range.getFirst(), range.getSecond());

input = sc.nextInt();

} while( input < range.getFirst() ||

input > range.getSecond() );
}
} TestIntPair.java

[503005 Lecture 10: Collection of Data]

27
 Observation
Generics
 The IntPair class idea can be easily extended to
other data types:
2.

 double, String, etc.

 The resultant code would be almost the same!
class StringPair { Only differences are the
private String first, second; data type declarations
public StringPair( String a, String b ) {
first = a;
second = b;
}

public String getFirst() { return first; }

public String getSecond() { return second; }

}
[503005 Lecture 10: Collection of Data]
28
 The Generic Pair Class
Generics
class Pair <T> {
private T first, second;
2.

public Pair(T a, T b) {
first = a;
second = b;
}
public T getFirst() { return first; }
public T getSecond() { return second; }
}
Pair.java

 Important restriction:
 The generic type can be substituted by reference data type only
 Hence, primitive data types are NOT allowed
 Need to use wrapper class for primitive data type

[503005 Lecture 10: Collection of Data]

29
 Using the Generic Pair Class
Generics TestGenericPair.java
public class TestGenericPair {
public static void main(String[] args) {
2.

Pair<Integer> twoInt = new Pair<Integer>(-5, 20);

Pair<String> twoStr = new Pair<String>("Turing", "Alan");
// You can have pair of any reference data types!
// Print out the integer pair
System.out.println("Integer pair: (" + twoInt.getFirst()
+ ", " + twoInt.getSecond() + ")";
// Print out the String pair
System.out.println("String pair: (" + twoStr.getFirst()
+ ", " + twoStr.getSecond() + ")";
}
}

 The formal generic type <T> is substituted with the

actual data type supplied by the user:
 The effect is similar to generating a new version of the Pair
class, where T is substituted
[503005 Lecture 10: Collection of Data]
30
 Autoboxing/unboxing (1/2)
Generics
 The following statement invokes autoboxing
Pair<Integer> twoInt = new Pair<Integer>(-5, 20);
2.

 Integer objects are expected for the constructor, but -5

and 20, of primitive type int, are accepted.
 Autoboxing is the automatic conversion that the Java
compiler makes between the primitive types and their
corresponding object wrapper classes
 The primitive values -5 and 20 are converted to objects of
Integer
 The Java compiler applies autoboxing when a primitive
value is:
 Passed as a parameter to a method that expects an object of
the corresponding wrapper class
 Assigned to a variable of the correspond wrapper class

[503005 Lecture 10: Collection of Data]

31
 Autoboxing/unboxing (2/2)
Generics
 Converting an object of a wrapper type (e.g.:
Integer) to its corresponding primitive (e.g: int)
2.

value is called unboxing.

 The Java compiler applies unboxing when an object of
a wrapper class is:
 Passed as a parameter to a method that expects a value of the
corresponding primitive type
 Assigned to a variable of the corresponding primitive type
int i = new Integer(5); // unboxing
Integer intObj = 7; // autoboxing i = 5
System.out.println("i = " + i); intObj = 7
System.out.println("intObj = " + intObj);

int a = 10;
true
Integer b = 10; // autoboxing
System.out.println(a == b);

[503005 Lecture 10: Collection of Data]

32
 The Generic NewPair Class
Generics
 We can have more than one generic type in a generic class
 Let’s modify the generic pair class such that:
2.

 Each pair can have two values of different data types

class NewPair <S,T> {

You can have multiple generic data types.
private S first; Convention: Use single uppercase
private T second; letters for generic data types.

public NewPair(S a, T b) {
first = a;
second = b;
}
public S getFirst() { return first; }
public T getSecond() { return second; }
}
NewPair.java

[503005 Lecture 10: Collection of Data]

33
 Using the Generic NewPair Class
Generics TestNewGenericPair.java
public class TestNewGenericPair {
public static void main(String[] args) {
2.

NewPair<String, Integer> someone =

new NewPair<String, Integer>("James Gosling", 55);
System.out.println("Name: " + someone.getFirst());
System.out.println("Age: " + someone.getSecond());
}
} Name: James Gosling
Age: 55

 This NewPair class is now very flexible!

 Can be used in many ways

[503005 Lecture 10: Collection of Data]

34
 Summary
Generics
 Caution:
 Generics are useful when the code remains
2.

unchanged other than differences in data types

 When you declare a generic class/method, make
sure that the code is valid for all possible data types
 Additional Java Generics topics (not covered):
 Generic methods
 Bounded generic data types
 Wildcard generic data types

[503005 Lecture 10: Collection of Data]

35
3 Vector class

Class for dynamic-size arrays

 Motivation
Vector
 Java offers a Vector class to provide:
3.

 Dynamic size
 expands or shrinks automatically
 Generic
 allows any reference data types
 Useful predefined methods
 Use array if the size is fixed; use Vector if the
size may change.

[503005 Lecture 10: Collection of Data]

37
 API documentation (1/3)
Vector
3.

[503005 Lecture 10: Collection of Data]

38
 API documentation (2/3)
Vector
PACKAGE

import java.util.Vector;
3.

//Declaration of a Vector reference

SYNTAX

Vector<E> myVector;

//Initialize a empty Vector object

myVector = new Vector<E>;

Commonly Used Method Summary

boolean isEmpty()
Tests if this vector has no components.

int size()
Returns the number of components in this vector.

[503005 Lecture 10: Collection of Data]

39
 API documentation (3/3)
Vector
Commonly Used Method Summary (continued)
boolean add(E o)
3.

Appends the specified element to the end of this Vector.

void add(int index, E element)
Inserts the specified element at the specified position in this Vector.
E remove(int index)
Removes the element at the specified position in this Vector.
boolean remove(Object o)
Removes the first occurrence of the specified element in this Vector
If the Vector does not contain the element, it is unchanged.
E get(int index)
Returns the element at the specified position in this Vector.
int indexOf(Object elem)
Searches for the first occurrence of the given argument, testing for
equality using the equals method.
boolean contains(Object elem)
Tests if the specified object is a component in this vector.
[503005 Lecture 10: Collection of Data]
40
 Example
Vectorimport java.util.Vector;
TestVector.java
public class TestVector {
Output:
3.

public static void main(String[] args) {[501042, 503005, 502043]

At index 0: 501042
Vector<String> courses; 503005 is in courses
501042
courses = new Vector<String>(); 502043
courses.add("503005");
courses.add(0, "501042");
courses.add("502043"); Vector class has a nice toString()
method that prints all elements
System.out.println(courses);
System.out.println("At index 0: " + courses.get(0));

if (courses.contains("503005"))
System.out.println("503005 is in courses");

courses.remove("503005");
for (String c: courses)
System.out.println(c); The enhanced for-loop is applicable
} to Vector objects too!
}
[503005 Lecture 10: Collection of Data]
41
4 ArrayList class

Another class for dynamic-size arrays

4. ArrayList Introduction (1/2)
 Java offers an ArrayList class to provide similar
features as Vector:
 Dynamic size
 expands or shrinks automatically
 Generic
 allows any reference data types
 Useful predefined methods
 Similarities:
 Both are index-based and use an array internally
 Both maintain insertion order of element
 So, what are the differences between Vector and
ArrayList?
 This is one of the most frequently asked questions,
and at interviews!
[503005 Lecture 10: Collection of Data]
43
4. ArrayList Introduction (2/2)
 Differences between Vector and ArrayList
Vector ArrayList
Since JDK 1.0 Since JDK 1.2
Synchronised * (thread-safe) Not synchronised
Slower (price of synchronisation) Faster (20 – 30%)
Expansion: default to double the Expansion: increases its size
size of its array (can be set) by 50%

 ArrayList is preferred if you do not need synchronisation

 Java supports multiple threads, and these threads may read from/write to the same
variables, objects and resources. Synchronisation is a mechanism to ensure that
Java thread can execute an object’s synchronised methods one at a time.
 When using Vector /ArrayList, always try to initialise to the largest
capacity that your program will need, since expanding the array is costly.
 Array expansion: allocate a larger array and copy contents of old array to the
new one
[503005 Lecture 10: Collection of Data]
44
4. ArrayList API documentation (1/3)

[503005 Lecture 10: Collection of Data]

45
4. ArrayList API documentation (2/3)
PACKAGE
import java.util.ArrayList;

//Declaration of a ArrayList reference

SYNTAX

ArrayList<E> myArrayList;

//Initialize a empty ArrayList object

myArrayList = new ArrayList<E>;

Commonly Used Method Summary

boolean isEmpty()
Returns true if this list contains no element.

int size()
Returns the number of elements in this list.

[503005 Lecture 10: Collection of Data]

46
4. ArrayList API documentation (3/3)
Commonly Used Method Summary (continued)
boolean add(E e)
Appends the specified element to the end of this list.
void add(int index, E element)
Inserts the specified element at the specified position in this list.
E remove(int index)
Removes the element at the specified position in this list.
boolean remove(Object o)
Removes the first occurrence of the specified element from this
list, if it is present.
E get(int index)
Returns the element at the specified position in this list.
int indexOf(Object o)
Returns the index of the first occurrence of the specified element
in this list, or -1 if this list does not contain the element.
boolean contains(Object elem)
Returns true if this list contains the specified element.
[503005 Lecture 10: Collection of Data]
47
4. ArrayList Example
TestArrayList.java
import java.util.ArrayList;
import java.util.Scanner;

public class TestArrayList {

public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
ArrayList<Integer> list = new ArrayList<Integer>();

System.out.println("Enter a list of integers, press ctrl-d to end.");

while (sc.hasNext()) {
Output:
list.add(sc.nextInt());
} Enter a list ... to end.
31
System.out.println(list); // using
17 ArrayList's toString()
-5
// Move first value to last 26
list.add(list.remove(0)); 50
System.out.println(list); (user pressed ctrl-d here)
} [31, 17, -5, 26, 50]
} [17, -5, 26, 50, 31]

[503005 Lecture 10: Collection of Data]

48
Summary

Array:
- Declaration and common usage
Java Elements

Generics:
- Allowing operation on objects of various types

Vector and ArrayList:

- Dynamic-size arrays
- Declaration and useful methods

[503005 Lecture 10: Collection of Data]

49
Pract. Ex. #13 Missing Digits (1/2)
 [This is adapted from a 501042 exercise in C]
Write a program MissingDigits.java to read in a
positive integer and list out all the digits that do
not appear in the input number. (Assume input value
has no leading zeroes.)
 You are to use primitive array, not Vector,
ArrayList or any other related classes.
 You should use a boolean array.
 Sample run:
Enter a number: 73015
Missing digits in 73015: 2 4 6 8 9

[503005 Lecture 10: Collection of Data]

51
Pract. Ex. #13 Missing Digits (2/2)
 What is the boolean array for? Idea?

[503005 Lecture 10: Collection of Data]

52
 Detecting Duplicates (1/4)
 Using ArrayList class and random number generation.
 You may use the Math random() method or the Random class
Additional

 Write a program DetectDuplicates.java to read the

Exercise

following values:
 The number of unique random integers to generate; and
 Limit of the values: each random number generated should be in
the range from 0 (inclusive) to limit (exclusive), or [0, limit – 1].
 (Certainly, the second input value must not be smaller than the first)
 Each time a random integer is generated, you must
check if it is a duplicate of an earlier generated value. If it
is, it must be discarded. The program goes on to
generate the required number of unique random
integers.
 You are to count how many duplicates were detected.
[503005 Lecture 10: Collection of Data]
53
 Detecting Duplicates (2/4)
 Sample run
 (In testing your code, each time a random number is
Additional

generated, you may want to print it to check that the

Exercise

computation is correct)
Enter number of unique integers to generate: 10
Enter limit: 20
List: [16, 3, 15, 17, 2, 10, 18, 5, 12, 14]
Duplicates detected: 8

[503005 Lecture 10: Collection of Data]

54
 Detecting Duplicates (3/4)
DetectDuplicates.java
import java.util.*;
public class DetectDuplicates {
Additional

public static void main(String[] args) {

Exercise

Scanner sc = new Scanner(System.in);

ArrayList<Integer> list = new ArrayList<Integer>();
System.out.print("Enter number of unique ...: ");
int numUnique = sc.nextInt();

System.out.print("Enter limit: ");

int limit = sc.nextInt();

Random rnd = new Random();

int countUnique = 0;
int countDuplicates = 0;
int num; // the random number

[503005 Lecture 10: Collection of Data]

55
 Detecting Duplicates (4/4)
DetectDuplicates.java
Additional
Exercise

System.out.println("List: " + list);

System.out.println("Duplicates detected: "
+ countDuplicates);
}
}

[503005 Lecture 10: Collection of Data]

56
End of file