1. JAVA COLLECTIONS LIBRARY
COMP 103
JAVA COLLECTIONS LIBRARY
Thomas Kuehne, Marcus Frean,
Thomas Kuehne
School of Engineering and Computer Science, Victoria University of Wellington
2016-T2, Lecture 2

2. TODAY Administrivia: Libraries and code reuse2
Libraries and code reuse
Java’s Collections Library
ArrayList (our first example)
Interfaces and Classes
Administrivia:
No cap on foreign material in submitted assignments but only original parts will be marked
Register for tutorials with myAllocator by 3.00pm Friday! ( Alex Potanin in case you have problems)

3. Programming with Libraries3
Modern programs (with GUIs, databases, network access, etc.) are too big to build from scratch, so we have to reuse code written by other people....
Libraries contain code designed for reuse
Java has a huge number of standard libraries...
organised in packages, which are groups of Classes
The ecs100 library has some very useful classes (e.g. UI)
There are LOTS of other libraries as well
Learning to use libraries is ESSENTIAL
Java API

4. Libraries for COMP103 4
ecs100 Special classes for text/graphical input and output, especially for GUI
java.util Collection classes, and other utility classes
java.io Classes for input and output
javax.swing Large libraries of classes for GUI jawa.awt programs
We will use libraries in almost every program

5. Using Libraries Read the documentation to pick useful library5
Read the documentation to pick useful library
Import the package or class into your program
import java.util.*;
import ecs100.*;
Read the documentation to identify how to use
constructors for making instances
methods that you can call
interfaces that you can / need to implement
Use the classes as if they were part of your program
Java API

6. “Standard” Collections6
Common ways of organizing a collection of values:
Each of these constitutes a different type of collection
Collection
Bag
Graph
Tree
Stack
Queue
List
Map
Set

7. Java Collections Library
Standard collections (eg. Set, List, Map, etc.) are available to use
Collections specified as interfaces
Collection, Set, List, Queue – are all interfaces
Using collections implies using one of the many concrete classes that implement these interfaces. E.g. You can use:
ArrayList (a class) which implements List (an interface)

8. You have been using ArrayList8
Part of the Java Collections framework
Stores a LIST of items
a collection of items kept in a particular order
Part of the java.util package
⇒ need import java.util.*; at the head of your file
You can make a new ArrayList object, and put items in it
Don’t have to specify its size: Like an infinitely stretchable array
Need to specify the type of items
Cannot use the [...] notation
You have to call methods to access and assign

9. Using ArrayList: declaring9
List of students (assume we have a class called Student)
Array
private static final int maxStudents = 1000;
private Student[ ] students = new Student[maxStudents];
private int count = 0;
ArrayList
private ArrayList <Student> students = new ArrayList <Student>();
Type of elements in the list is between “<” and “>” after ArrayList
No initial size(!), No maximum size

10. TIP: Read Documentation from sidebar of course homepage
Using ArrayList: methods 10
ArrayList has many methods
size(): returns the number of items in the list
add(item): adds an item to the end of the list
add(index, item): inserts an item at index (moves later items up)
set(index, item): replaces the item at index with item
contains(item): true if the list contains an item that equals item
get(index): returns the item at position index
remove(item): removes an occurrence of item
remove(index): removes the item at position index (both “removes” move the later items down)
You can use the “for each” loop on an ArrayList, as well as a regular for loop
TIP: Read Documentation from sidebar of course homepage

11. Using ArrayList 11
private List <Student> students = new ArrayList <Student> ();
Student s = new Student(“Davy Jones”, );
students.add(s);
for (Student st: students)
UI.println(st.toString());
for (int i = students.size()-1; i>=0; i--)
UI.println(students.get(i).toString());
if (students.contains(currentStudent)) {
UI.println(currentStudent);
students.remove(currentStudent); }
....
....

12. Collection An object that serves as a container for other objects12
An object that serves as a container for other objects
Type of Elements (a collection of ….)
Structure (none/linear/hierarchical)
Constraints (duplicates allowed? Access: add anywhere, remove from one end only, get from top, etc…)

13. Example Bag : an example of a collection13
Bag : an example of a collection
Collection type
Element type
Type of Elements Bag of Students
Structure
No structure/order
Constraints
Duplicates allowed, add/remove anywhere (no ordering)

14. Is ArrayList a Collection type then?14
Type of Elements ArrayList of Students
Structure linear order
Constraints
Duplicates allowed, add/remove anywhere
actually no! ArrayList is not a Collection type. List is!
ArrayList is just ONE WAY to implement a List

15. extends implements interface (a specification / promise)  what it is
class (an implementation)  how it is implemented
Interfaces are organised in a hierarchy; they “extend” one another

16. Java Collections Library16
Interfaces…
Collection
most general: “a container”
List
ordered collection
Set
unordered, no duplicates
Queue
ordered collection with limited access
(add at one end, remove from other)
Map
key-value pairs
…specify the types
Classes…
List classes:
ArrayList, LinkedList, Vector
Set classes:
HashSet, TreeSet, EnumSet, LinkedHashSet,…
Map classes:
EnumMap, HashMap, TreeMap, LinkedHashMap, WeakHashMap, … …
…implement the interfaces
abstract
concrete

17. Java 8 adds “default” bodies, though
Java Interfaces 17
At the simplest level:
An interface is a bunch of method signatures with a name
At a higher level:
An interface is an abstract concept that defines:
the operations that are supported by an object of this type
(how it will behave)
No concrete details!
No constructors - can’t make an instance
No fields - doesn’t say how to store the data
No method bodies - doesn’t say how to perform the operations
Details provided by Classes that implement the Interface
Assertions & JML
Java 8 adds “default” bodies, though

18. Declaring a List Earlier, we declared a list of students like this:19
Earlier, we declared a list of students like this:
private ArrayList <Student> students = new ArrayList <Student>();
BETTER / NOW: declare as an instance of the interface List:
private List <Student> students = new ArrayList <Student>();

19. Summary Libraries Collections20
Libraries
Collections
Interfaces – correspond to ADTs. No concrete details
e.g., Collection, List, Set, …
Classes – provide implementations for interfaces
e.g., ArrayList  implements an interface (List) from the Java Collections Library