ArrayList and

Wrapper Classes
COMP2396 Object-Oriented Programming and Java
Dr. Kenneth Wong
 Arrays
 In Java, arrays are objects and they live on the heap
 Unlike many other objects, arrays in Java
 Do not have any method (save for those inherited from the
Object class)
 Have one and only one instance variable (i.e., length)
 Use special array syntax (i.e., the subscript operator [])
that is not used anywhere else in Java

 Limitations
 The size of an array must be determined at the time of
creation, and cannot be changed afterwards
 Data (primitives or references) can be put into and read
from an array using array syntax, but cannot be actually
removed from the array

1
 Arrays
 Example
Dog[] myDogs = new Dog[4];
Creating a Dog array with 4 elements
for (int i = 0; i < myDogs.length; i++) {
myDogs[i] = new Dog();
} Putting a Dog reference into the array

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

Dog dog = myDogs[i];
Getting a Dog reference from the array
dog.makeNoise();
}

myDogs[2] = null; “Removing” a Dog reference from the array

for (Dog dog : myDogs) {

if (dog != null) {
The size of the array does not change
dog.makeNoise();
}
} 2
 Arrays
 Wouldn’t it be fantastic if an array
 Could grow when you add something to it?
 Could shrink when you remove something from it?
 Could tell you if it contains what you’re looking for
without having you to loop through and check each
element?
 Could let you get things out of it without having you
to know exactly which slots the things are in?

ArrayList
is the answer!

3
 ArrayList
 ArrayList is a class in the core Java library (the API)
 Can be used in your code as if you wrote it yourself
ArrayList
add(Object elem)
Adds the object parameter to the list
remove(int index)
Removes the object at the index parameter
remove(Object elem)
Removes this object (if it is in the ArrayList)
contains(Object elem)
Returns true if there is a match for the object parameter
isEmpty()
Returns true if the list has no element
indexOf(Object elem)
Returns the index of the object parameter or -1
size()
Returns the number of elements currently in the list
get(int index)
Returns the object currently at the index parameter
…
4
 ArrayList
The type parameter in the
angle-brackets specifies the
 Example type of objects that can be
// create an ArrayList stored in the ArrayList
ArrayList<Egg> myList = new ArrayList<Egg>();

// put something into it

Egg a = new Egg();
The ArrayList grows when an item is added to it
myList.add(a);

// put another thing into it

Egg b = new Egg(); The ArrayList grows when an item is added to it
myList.add(b);

// find out how many things are in it The size() method returns
int theSize = myList.size(); the number of elements
currently in the list (i.e., 2)
// find out if it contains something
boolean isIn = myList.contains(a);
The contains() method returns true as
the ArrayList does contain (a reference
to) the object referenced by a 5
 ArrayList
 Example
// find out where something is (i.e., its index)
int idx = myList.indexOf(b);
The indexOf() method returns
// find out if it is empty the (zero-based) index of the
object referenced by b (i.e., 1)
boolean empty = myList.isEmpty();

// Remove something from it The isEmpty() method returns false

myList.remove(a); as the ArrayList is not empty

// loop through it The ArrayList shrinks when

for (Egg egg : myList) { an item is removed from it
// egg.xxxx
}
The enhanced for loop can be applied
to loop through the ArrayList

6
 ArrayList vs Regular Array
ArrayList regular array
ArrayList<String> myList = new ArrayList<String>(); String[] myList = new String[2];

String a = new String("whoohoo"); String a = new String("whoohoo");

myList.add(a); myList[0] = a;

String b = new String("Frog"); String b = new String("Frog");

myList.add(b); myList[1] = b;

int theSize = myList.size(); int theSize = myList.length;

String s = myList.get(1); String s = myList[1];

myList.remove(1); myList[1] = null;

boolean isIn = myList.contains(b); boolean isIn = false;

for (String item : myList) {
if (b.equals(item)) {
isIn = true;
break;
}
}
7
 ArrayList vs Regular Array
ArrayList regular array
ArrayList<String> myList = new ArrayList<String>(); String[] myList = new String[2];

String a = new String("whoohoo"); String a = new String("whoohoo");

myList.add(a); myList[0] = a;

String b = new String("Frog"); String b = new String("Frog");

An ArrayList does not need to know its
myList.add(b); myList[1] = b;
size at the time of creation. It grows A regular array has to know its
and
int shrinks
theSize as objects are added or
= myList.size(); size at the time of creation
int theSize = myList.length;
removed from it
String s = myList.get(1); String s = myList[1];

myList.remove(1); myList[1] = null;

boolean isIn = myList.contains(b); boolean isIn = false;

for (String item : myList) {
if (b.equals(item)) {
isIn = true;
break;
}
}
8
 ArrayList vs Regular Array
ArrayList regular array
ArrayList<String> myList = new ArrayList<String>(); String[] myList = new String[2];

String a = new String("whoohoo"); String a = new String("whoohoo");

myList.add(a); myList[0] = a;

String b = new String("Frog"); String b = new String("Frog");

myList.add(b); myList[1] = b;

int theSize = myList.size(); int theSize = myList.length;

String s = myList.get(1); An object must be assigned to a

String s = myList[1];
An object can be added without
specific location (zero-based
specifying a location (i.e., an
myList.remove(1); index) in a regular array. If the
myList[1] = null;
index) in an ArrayList. The
index is outside the boundaries of
ArrayList
boolean isIn will keep growing to
= myList.contains(b); boolean isIn = false;
the array, it blows up at runtime
make room for the new thing for (String item : myList) {
if (b.equals(item)) {
isIn = true;
break;
}
}
9
 ArrayList vs Regular Array
ArrayList regular array
ArrayList<String> myList = new ArrayList<String>(); String[] myList = new String[2];
The (dynamic) size of an
String a = new String("whoohoo");
The size of a regular array
String a = new String("whoohoo");
ArrayList can be retrieved by
myList.add(a); myList[0] = a; is stored in its (final)
calling its size() method instance variable length
String b = new String("Frog"); String b = new String("Frog");
myList.add(b); myList[1] = b;

int theSize = myList.size(); int theSize = myList.length;

String s = myList.get(1); String s = myList[1];

myList.remove(1); myList[1] = null;

boolean isIn = myList.contains(b); boolean isIn = false;

for (String item : myList) {
if (b.equals(item)) {
isIn = true;
break;
}
}
10
 ArrayList vs Regular Array
ArrayList regular array
ArrayList<String> myList = new ArrayList<String>(); String[] myList = new String[2];

String a = new String("whoohoo"); String a = new String("whoohoo");

myList.add(a); myList[0] = a;
A regular array uses array
An ArrayList is just a plain Java
String b = new String("Frog"); syntax
String b = new that is not used
String("Frog");
object, and uses no special syntax
myList.add(b); anywhere else in Java
myList[1] = b;

int theSize = myList.size(); int theSize = myList.length;

String s = myList.get(1); String s = myList[1];

myList.remove(1); myList[1] = null;

boolean isIn = myList.contains(b); boolean isIn = false;

for (String item : myList) {
if (b.equals(item)) {
isIn = true;
break;
}
}
11
 ArrayList vs Regular Array
ArrayList regular array
ArrayList<String> myList = new ArrayList<String>(); String[] myList = new String[2];

String a = new String("whoohoo"); String a = new String("whoohoo");

myList.add(a); myList[0] = a;

String b = new String("Frog"); String b = newAn object cannot be actually

String("Frog");
An object can be removed
myList.add(b); removed from a regular array
myList[1] = b;
from an ArrayList and the (assigning null to an array element
int theSize = myList.size(); int theSize = myList.length;
ArrayList shrinks accordingly does not change the array size)
String s = myList.get(1); String s = myList[1];

myList.remove(1); myList[1] = null;

boolean isIn = myList.contains(b); boolean isIn = false;

for (String item : myList) {
if (b.equals(item)) {
isIn = true;
break;
}
}
12
 ArrayList vs Regular Array
ArrayList regular array
ArrayList<String> myList = new ArrayList<String>(); String[] myList = new String[2];

String a = new String("whoohoo"); String a = new String("whoohoo");

myList.add(a); myList[0] = a;

String b = new String("Frog"); String b = new String("Frog");

myList.add(b); myList[1] = b;

An ArrayList can tell if it

int theSize = myList.size(); int theSize = There
myList.length;
is no simply way to check
contains an object by calling if an object is in a regular array
String s = myList.get(1);
its contains() method String s = myList[1];
without having to loop through
myList.remove(1); myList[1] = null; and check each element

boolean isIn = myList.contains(b); boolean isIn = false;

for (String item : myList) {
if (b.equals(item)) {
isIn = true;
break;
}
}
13
 Packages
 In the Java API, classes are grouped into packages
(e.g., ArrayList is in the package java.util which
holds a pile of utility classes)
 Packages are important for 3 main reasons
 Help the overall organization (classes are grouped
into packages for specific kinds of functionality, e.g.,
GUI, data structures, etc.)
 Provide a name-scoping that helps to prevent
collisions of names
 Provide a level of security (allowing placing
restrictions on code such that only other classes in
the same package can access it)

14
 Packages
 A class has a full name which is a combination of the
package name and the class name
e.g.,
java.util.ArrayList

package name class name

 To use a class in a package other than java.lang, the full
name of the class must be specified
e.g.,
java.util.ArrayList<Dog> list = new java.util.ArrayList<Dog>();

public void go(java.util.ArrayList<Dog> list) { … }

parameter type
public java.util.ArrayList<Dog> foo() { … }
return type
15
 Packages
 Alternatively, include an import statement at the top of the
source code to avoid typing the full name everywhere, e.g.,
import java.util.ArrayList;

public MyClass {
ArrayList<Dog> list;
// ...
}

 It is also possible to import all classes in a package using a

wildcard character *, e.g.,
import java.util.*;

 Note that an import statement simply saves you from typing

the full name of a class, it will not make your code bloated or
slower

16
 How to Play with the API
 Use the HTML API docs
 Java comes with a fabulous set of online docs
http://docs.oracle.com/javase/8/docs/api/index.html

 The API docs are the best

reference for
 Finding out what are in the
Java library
 Getting details about a class
and its methods

17
 Wrapper Classes
 The type parameter of an ArrayList supports classes only
(i.e., it is not possible to create ArrayLists of primitive types)
 There is a wrapper class for Primitive Type Wrapper
every primitive type such that a Class
primitive can be treated like an
boolean Boolean
object
char Character
 Each wrapper class is named byte Byte
after the primitive type (save for
char and int), but with the first short Short
letter capitalized int Integer
long Long
 The wrapper classes are in the
java.lang package (i.e., no float Float
import statement is needed) double Double

Watch out! The names

are not mapped exactly
to the primitive types
18
 Wrapper Classes
 Examples: wrapping a value
boolean b = true;
Boolean bWrap = new Boolean(b);
char c = 'K';
Character cWrap = new Character(c);
int i = 288;
Integer iWrap = new Integer(i); Simply give the primitive to the
double d = 1.234567; constructor of the wrapper class
Double dWrap = new Double(d);

 Examples: unwrapping a value

boolean bUnWrap = bWrap.booleanValue();
char cUnWrap = cWrap.charValue();
int iUnWrap = iWrap.intValue();
All the wrapper classes work
double dUnWrap = dWrap.doubleValue();
like this. E.g., Byte has a
byteValue() method, Short has
a shortValue() method, etc.
19
An ArrayList of a Primitive Type
 Example
import java.util.*;

public class WithoutAutoBoxing {

public static void main(String[] args) {
ArrayList<Integer> listOfNumbers = new ArrayList<Integer>();
listOfNumbers.add(new Integer(3));
Wrap an int value 3 into
Integer num = listOfNumbers.get(0);
an Integer object and
int intNum = num.intValue();
add it to the ArrayList
}
}
Unwrap an int value
from an Integer object

 The wrapping and unwrapping of primitives sound

rather tedious

20
 Autoboxing
 The autoboxing feature in Java blurs the line between
primitives and wrapper objects
 Autoboxing performs the conversion from primitives to
wrapper objects, and vice versa, automatically
 Example
import java.util.*;

public class WithAutoBoxing {

public static void main(String[] args) {
ArrayList<Integer> listOfNumbers = new ArrayList<Integer>();
listOfNumbers.add(3);
The compiler does all the
int intNum = listOfNumbers.get(0);
wrapping (boxing) for you
}
}
The compiler unwraps (unboxes)
the Integer object automatically

21
 Autoboxing
 Autoboxing works almost everywhere
 Assignments
 One can assign either a wrapper or primitive to a
variable declared as a matching wrapper or primitive
type, e.g.,
int p = new Integer(42);
Integer q = p;

22
 Autoboxing
 Method arguments
 If a method takes a primitive, one can pass in either a
compatible primitive or a reference to a wrapper of
that primitive type
public void takePrimitive(int i) { … }

 If a method takes a wrapper type, one can pass in

either a reference to a wrapper or a primitive of the
matching type
public void takeWrapper(Integer i) { … }

23
 Autoboxing
 Return values
 If a method declares a primitive return type, one can
return either a compatible primitive or a reference to
the wrapper of that primitive type
public int returnPrimitive() { … }

 If a method declares a wrapper return type, one can

return either a reference to a wrapper or a primitive
of the matching type
public Integer returnWrapper() { … }

24
 Autoboxing
 Boolean expressions
 Any place a boolean value is expected, one can use
either an expression that evaluates to a boolean, a
primitive boolean, or a reference to a Boolean
wrapper
if (bool) { … }

25
 Autoboxing
 Operations on numbers
 One can use a wrapper type as an operand in
operations where the primitive type is expected
e.g.,
Integer i = new Integer(42);
i++;

Integer j = new Integer(5);

Integer k = j + 3;

26
 Autoboxing
 Example
public class TestBox {
Integer i;
int j;

public static void main(String[] args) {

TestBox t = new TestBox();
t.go();
} Will this code compile?
Will it run?
public void go() { If it runs, what will it do?
j = i;
System.out.println(j);
System.out.println(i);
}
}

27
 Autoboxing
 Example
public class TestBox {
Integer i;
int j;

public static void main(String[] args) {

TestBox t = new TestBox();
t.go();
} Will this code compile? Yes
Will it run? Yes, but with error
public void go() { If it runs, what will it do?
j = i;
System.out.println(j);
System.out.println(i);
}
}

28
 Autoboxing
 Example
This instance variable will
public class TestBox { get a default value of null
Integer i;
int j;

public static void main(String[] args) {

TestBox t = new TestBox();
t.go();
}
Autoboxing fails as i is not
public void go() { referencing any valid Integer
j = i; object. This will result in a
System.out.println(j); NullPointerException
System.out.println(i);
}
}

29
 String to Primitive
 The wrapper classes have static parse methods that
take a string and return a primitive value

 Examples
String s = "2";
int x = Integer.parseInt(s);
double d = Double.parseDouble("420.24");

boolean b = Boolean.parseBoolean("True");

String t = "two";
int y = Integer.parseInt(t);
This compiles just fine, but at
runtime it blows up. Anything that
cannot be parsed as a number will
cause a NumberFormatException

30
 Primitive to String
 The easiest way to turn a number into a string is by
simply concatenating the number to an existing
string, e.g.,
double d = 42.5;
String doubleString = "" + d;

 Alternatively, this can be done by calling the static

toString() method of a wrapper class, e.g.,
double d = 42.5;
String doubleString = Double.toString(d);

31
 Number Formatting
 In Java, formatting numbers is a simple matter of
calling the static format() method of the String class

 The first argument to the format() method is called the

format string, and it can include characters that are
printed as-is, together with one or more format
specifiers that begin with a percentage sign (%)
e.g., format specifier

String s = String.format("This cat weights %.2fkg", 4.3333);

format string
 The rest of the arguments to the format() method are
the numbers to be formatted by the format specifiers

32
 Number Formatting
 Some common format specifiers
 "%,d" means “inserts commas and format the number as a
decimal integer”
 "%.2f" means “format the number as a floating point with a
precision of 2 decimal places”
 "%,.2f" means “inserts commas and format the number as
a floating point with a precision of 2 decimal places”
 "%,5.2f" means “insert commas and format the number as
a floating point with a precision of 2 decimal places and
with a minimum of 5 characters, padding spaces and
zeros as appropriate”
 "%h" means “format the number as a hexadecimal”
 "%c" means “format the number as a character”

33
 Number Formatting
 Example
System.out.println(String.format("Balance = %,d", 10000));
System.out.println(String.format("10000 / 3 = %.2f", 10000.0/3));
System.out.println(String.format("10000 / 3 = %,.2f", 10000.0/3));
System.out.println(String.format("10000 / 3 = %,10.2f", 10000.0/3));
System.out.println(String.format("255 = %h in hexadecimal", 255));
System.out.println(String.format("ASCII code 65 = %c", 65));

 Sample output
Balance = 10,000
10000 / 3 = 3333.33
10000 / 3 = 3,333.33
10000 / 3 = 3,333.33
255 = ff in hexadecimal
ASCII code 65 = A

34