© M. Winter COSC 3P91 – Advanced Object-Oriented Programming 1.11.1 COSC 3P91 Advanced...

© M. Winter

COSC 3P91 – Advanced Object-Oriented Programming

1.1

COSC 3P91Advanced Object-Oriented

ProgrammingSuper Course

• Instructor: Michael Winter– Office J323– email: [email protected]

• Webpage: www.cosc.brocku.ca/~mwinter/Courses/3P91

© M. Winter


1.2

• Course Description (Brock Calendar): Advanced object-oriented programming techniques such as graphical user interfaces, animation, sound, music, networking, parallelism, client-server and XML using game design as an example. Topics in object-oriented program design including UML and design patterns. Introduction to advanced Java APIs such as awt, swing, io, nio, sound, net and xml.

• Prerequisites: two COSC credits or permission of the instructor.

• Java: Java 1.6 or greater and NetBeans

© M. Winter


1.3

Textbooks

• Main Course Material– SLIDES and NOTES (available through the webpage)

• Supplemental Texts– Developing Games in Java, D. Brackeen, New Riders

(2003), ISBN 1-5927-3005-1– Object-Oriented Software Development Using Java,

second edition, Xiaoping Jia, Addison Wesley (2002), ISBN 0-201-73733-7

© M. Winter


1.4

Course Work

• Marking Scheme– Project = 4 Programming parts 60% (done in class/lab, 4x15%)– Final Exam 40%

(Saturday May 09, 09:00am - 11:00am, TH246)

• Programming parts 1-4 due by the end of each day (05:00pm) starting on Tuesday, May 06.

© M. Winter


1.5

Course Outline

Day

Date Book/Chapt.

Topics

1 May 04 [2]/4,5,6.7,8

Introduction, review of OO concepts, basic UML, Utility classes, collection classes

2 May 05 [2]/7,8 I/O, Design patterns

3 May 06 [1]/1,[2]/7,8,11

XML, Threads, multitasking, Concurrency design patterns

4 May 07 [1]/2,[2]/8 GUI (AWT, Swing), 2D graphics, animation

5 May 08 [1]/3,4,6 Sound effects & music, Network programming

© M. Winter


1.6

Design principles

Design principles in this course and used by the design patterns

• Use abstraction whenever possible– introduce (abstract) superclass (or interfaces) in order to

implement or define common behavior– nothing should be implemented twice

• Program to an interface, not an implementation• Favor composition over inheritance

– delegation• Design for change and extension

© M. Winter


1.7

Classes

[ClassModifiers] class ClassName

[extends SuperClass]

[implements Interface1, Interface2, …] {

ClassMemberDeclarations

}

• Class modifiers– visibility: package versus public– abstract– final

• extends clause specifies the superclass• implements clause specifies the interfaces being implemented

© M. Winter


1.8

Class members

• Class (static) members– one occurrence for entire class– shared access by all instances– if visible, accessed via class name– public static void main(String[] args) {…}

• Member modifiers– public versus protected versus package versus private– abstract– final– synchronized (method)– native (method)– volatile (field)– transient (field)

© M. Winter


1.9

Inheritance

• Parent/child, superclass/subclass• Instances of child inherit data and behaviour of parent• implements

– inheritance of specification• extends

– subclassing– inheritance of code and specification– overriding

• polymorphism• Subclass versus subtype

– substitutability• Subclass as an extension of behavior (specialization)• Subtype as a contraction of value space (specialization)

© M. Winter


1.10

Subtypes

• a subclass extends the capability of its superclass; the subclass inherits features from its superclass and adds more features

• every instance of a subclass is an instance of the superclass• each class defines a type

Definition: SubtypeType T1 is a subtype of type T2 if every legitimate value of T1 is also a legitimate value of T2. In this case, T2 is a supertype of T1.

Substitutability of subtypes:A value of a subtype can appear wherever a value of its supertype is expected.

© M. Winter


1.11

Overriding versus Overloading• Overloading

– methods– same name, different signatures– same class or subclass– effect – multiple methods with same name– do not overuse (readability of programs)– overloading should be used only in two situations:

1. When there is a general, non-discriminative description of the functionality that fits all the overloaded methods.

2. When all the overloaded methods offer the same functionality, with some of them providing default arguments.

• Overriding– instance methods– same name, signature and result type– in subclass– effect – replacement implementation

• access superclass version via super

© M. Winter


1.12

Forms of inheritance

• Inheritance for specification– parent provides specification

• abstract classes• interfaces

– behaviour implemented in child– subtype

• Inheritance for extension– adding behaviour– subtype

• Inheritance for specialization– child is special case– child overrides behavior to extend– subtype

© M. Winter


1.13

• Inheritance for construction– inherit functionality– ad hoc inheritance– not a subtype– use composition

• Inheritance for limitation– restricting behaviour– not subtype– use composition

• Inheritance for combination– combining behaviours– multiple inheritance– only through interfaces in Java

© M. Winter


1.14

Inheritance for Specification: Java interface

Ch.8.4, Budd: Understanding Object-Oriented Programming with Java

interface ActionListener {public void actionPerformed (ActionEvent e);

}

class CannonWorld extends Frame {…

// a fire button listener implements the action // listener interface

private class FireButtonListener implements ActionListener { public void actionPerformed (ActionEvent e) { … // action to perform in response to button press }}

}

© M. Winter


1.15

Inheritance for Specification: abstract class

Ch.8.4, Budd: Understanding Object-Oriented Programming with Java

public abstract class Number {

public abstract int intValue();

public abstract long longValue();

public abstract float floatValue();

public abstract double doubleValue();

public byte byteValue()

{ return (byte) intValue(); }

public short shortValue()

{ return (short) intValue(); }

}

© M. Winter


1.16

Inheritance for ExtensionCh.8.4, Budd: Understanding Object-Oriented Programming with

Java

class Properties extends Hashtable {…public synchronized void load(InputStream in)

throws IOException {…}

public synchronized void save(OutputStream out, String header) {…}

public String getProperty(String key) {…}

public Enumeration propertyNames() {…}

public void list(PrintStream out) {…}}

© M. Winter


1.17

Inheritance for Specialization

public class MyCar extends Car {…public void startEngine() {

motivateCar();super.startEngine();

}…

}

© M. Winter


1.18

Inheritance for Construction Ch.8.4, Budd: Understanding Object-Oriented Programming with

Java

class Stack extends LinkedList {

public Object push(Object item){ addElement(item); return item; }

public boolean empty(){ return isEmpty(); }

public synchronized Object pop() {Object obj = peek();removeElementAt(size() - 1);return obj;

}

public synchronized Object peek(){ return elementAt(size() - 1); }

}

© M. Winter


1.19

Inheritance for LimitationCh.8.4, Budd: Understanding Object-Oriented Programming with

Java

class Set extends LinkedList {// methods addElement, removeElement, contains,// isEmpty and size are all inherited from LinkedList

public int indexOf(Object obj) { System.out.println(“Do not use Set.indexOf”); return 0;

}

public Object elementAt(int index) { return null;

}}

© M. Winter


1.20

Inheritance for Combination

public class Mouse extends Vegetarian implements Food {…protected RealAnimal getChild() {

…}…public int getFoodAmount() {

…}…

}

© M. Winter


1.21

UML Class diagrams

Vehicle

- speed : Integer

+ Vehicle(speed : Integer)

+ getSpeed() : Integer {leaf}

+ accelerate()

MyCar

{leaf}

+ MyCar(speed : Int)

+ accelerate()

1 Truck

# trailer : Trailer

+ Truck(speed : Integer, tr : Trailer)

<<interface>>

Cloneable

+ clone() : Object

Trailer

+ CAPACITY : Integer {readonly}

+ Trailer()

+ clone() : Object

0..*

1

© M. Winter


1.22

Composition

• Composition has-a relationship (strong ownership)• Inheritance is-a relationship• Inheritance versus composition

– desire to reuse existing implementation– substitutability (subtype)– subclass inherits specification and all methods and

variables– composition allows selective reuse

© M. Winter


1.23

UML Class diagramsInheritance versus Composition

LinkedList

+ addElement(obj : Object)

+ removeElement(obj : Object)

+ contains(obj : Object) : boolean

+ isEmpty() : boolean

+ size() : int

+ indexOf(obj : Object) : int

+ elementAt(index : int) : Object

Set



public int indexOf(Object obj) {

System.out.println(“Do not use Set.indexOf”);

return 0;

}

public Object elementAt(int index) {

System.out.println(“Do not use Set.elementAt”);

return null;

}

© M. Winter


1.24

UML Class diagramsInheritance versus Composition

LinkedList





+ size() : int



Set

- content : LinkedList





+ size() : int

public void addElement(Object obj) {

content.addElement(obj);

}

…

public int size(){

return content.size();

}

10..1

© M. Winter


1.25

Generics

• Up to Java 1.4 – container classes store object of class Object– storing elements in a container uses subtype polymorphism– accessing elements in a container requires type casting

Stack s = new Stack();

s.push(new Integer(3));

Integer n = (Integer) s.pop(); // cast required

s.push(”abc”); // no error

Integer second = (Integer) s.pop(); // runtime error

// (ClassCastException)

© M. Winter


1.26

Generics (cont’d)

• from Java 1.5– generic classes (similar to templates in C++)

Stack<Integer> s = new Stack<Integer>();

s.push(new Integer(3));

Integer n = s.pop(); // no cast required

s.push(”abc”); // type error

// (at compile time)

© M. Winter


1.27

Generic (cont’d)

Advantages of generics :

• Strong static type-checking – fewer ClassCastExceptions– fewer casts– no unchecked warnings

• Improved readability • Better tool support• No future deprecation

© M. Winter


1.28

Generics - UML class diagram

MyGenericClassE

MyInstantiationClass

<<bind>> E MyClass1

MyGenericClass<E MyClass2>

A class generic in E

An instantiation of the generic class using the class MyClass1.

Two short forms for an instantiation (useful if generic class is not part of the diagram.

MyGenericClass<MyClass2>

or

© M. Winter


1.29

Generics - Example

public class Pair<X,Y> {

private X first; // first component of type Xprivate Y second; // second component of type Y

public <A extends X,B extends Y> Pair(A a,B b) {first = a;second = b;

} // constructor

public Pair(Pair<? extends X, ? extends Y> p) {first = p.getFirst();second = p.getSecond();

} // constructor

© M. Winter


1.30

Generics – Example (cont’d)

public X getFirst() {

return first;

} // getFirst

public void setFirst(X x) {

first = x;

} // setFirst

public Y getSecond() {return second;

} // getSecond

public void setSecond(Y y) {second = y;

} // setSecond

public boolean equals(Object obj) {if (obj instanceof Pair<?,?>) { Pair<?,?> p = (Pair<?,?>) obj; return first == p.getFirst() && second == p.getSecond();};return false;

} // equals

© M. Winter


1.31

Auto boxing

• in Java 1.4Stack s = new Stack();

s.push(new Integer(3)); // wrapper class needed

Integer n = (Integer) s.pop();

• from Java 1.5Stack<Integer> s = new Stack<Integer>();

s.push(3); // auto boxing

int n = s.pop(); // again auto boxing

s.push(new Integer(1)); // without boxing

Integer num = s.pop(); // again without boxing

s.push(2); // any combination

num = s.pop(); // possible

© M. Winter


1.32

Iterations

• in Java 1.4

List strings;

...

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

String str = strings.elementAt(i);

System.out.println(str);

}

or better using an iterator

for(Iterator iter = strings.iterator(); iter.hasNext();) {

String str = (String) iter.next();

System.out.println(str);

}

© M. Winter


1.33

Iterations (cont’d)

• from Java 1.5

List<String> strings;

...

for(String str : strings) System.out.println(str);

int[] vector = new int[100];

...

int sum = 0;

for(int elem : vector) sum += elem;

© M. Winter


1.34

Enumeration types

• in Java 1.4– enumeration types are implemented by using the type int

public static final int RED = 0;

public static final int YELLOW = 1;

public static final int BLUE = 2;

...

switch(myColor) {

case Color.RED: System.out.println(”red”); break;

case Color.YELLOW: System.out.println(”yellow”); break;

case Color.BLUE: System.out.println(”blue”); break;

};

© M. Winter


1.35

Enumeration types (cont’d)

Advantages of explicit enumeration types:

• they are type safe (checked at compile time) – int enums don't provide any type safety at all

• they provide a proper name space for the enumerated type– with int enums you have to prefix the constants to get any

semblance of a name space• they are robust

– int enums are compiled into clients, and you have to recompile clients if you add, remove, or reorder constants

• printed values are informative– if you print an int enum you just see a number

• can be stored in collections (objects)• arbitrary fields and methods can be added

© M. Winter


1.36

Enumeration types (cont’d)

Simple example:

public enum Color {RED, YELLOW, BLUE};

...

for (Color myColor : Color.values()) System.out.println(myColor);

values() is a static method of an enumeration type returning an array containing all the values of the enum type in the order they are

declared.

© M. Winter


1.37

public enum Planet { MERCURY (3.303e+23, 2.4397e6), VENUS (4.869e+24, 6.0518e6), EARTH (5.976e+24, 6.37814e6), MARS (6.421e+23, 3.3972e6), JUPITER (1.9e+27, 7.1492e7), SATURN (5.688e+26, 6.0268e7), URANUS (8.686e+25, 2.5559e7), NEPTUNE (1.024e+26, 2.4746e7), PLUTO (1.27e+22, 1.137e6);

private final double mass; // in kilograms private final double radius; // in meters

Planet(double mass, double radius) { this.mass = mass; this.radius = radius;

}

public double mass() { return mass; } public double radius() { return radius; }

// universal gravitational constant (m3 kg-1 s-2) public static final double G = 6.67300E-11;

public double surfaceGravity() { return G * mass / (radius * radius); } public double surfaceWeight(double otherMass) {

return otherMass * surfaceGravity(); } }

© M. Winter


1.38

public enum Operation {

PLUS { double eval(double x, double y) { return x + y; } },

MINUS { double eval(double x, double y) { return x - y; } },

TIMES { double eval(double x, double y) { return x * y; } },

DIVIDE { double eval(double x, double y) { return x / y; }};

// Do arithmetic op represented by this constant abstract double eval(double x, double y);

}

public static void main(String args[]) {

double x = Double.parseDouble(args[0]);

double y = Double.parseDouble(args[1]);

for (Operation op : Operation.values()) System.out.printf("%f%s%f=%f%n",x,op,y,op.eval(x,y));

}

© M. Winter


1.39

Enum types - UML class diagram

<<enumeration>>Planet

MERCURYVENUS EARTH MARS JUPITER SATURN URANUS NEPTUNE PLUTO+ G : double { readonly }

+ mass() : double + radius() : double + surfaceGravity() : double+ surfaceWeight(double) : double

© M. Winter


1.40

Static import

Static import• in Java 1.4

double sinus = Math.sin(Math.PI/2.0);• from Java 1.5

import static java.lang.Math.*;

double sinus = sin(PI/2.0);• import of all static components of a class• usage without class prefix• different from

import java.util.*;

© M. Winter


1.41

Class Object

• Common parent (base class)• Minimal functionality• Classes may override to provide specific behaviour

– public boolean equals(Object other) {…}– public int hashCode() {…}– public String toString() {…}– public Class getClass() {…}– public Object clone() {…}

© M. Winter


1.42

Serialization

• Serialization is the process of transforming an object into a stream of bytes.

• Deserialization is the reverse process.

public interface Serializable {};

• Making an object serializable requires almost no effort (the interface Serializable is empty).

• More complex operations may be necessary if, for instance, just a portion of an object’s state is to be saved on the output stream.

© M. Winter


1.43

Serialization (cont.)

import java.io.*;

public class IntPair implements Serializable {

int x;int y;

public IntPair(int x, int y) {this.x = x;this.y = y;

}

public String toString() {return “(" + x + "," + y + ")";

}}

© M. Winter


1.44


import java.io.*;

public class inout { public static void main(String[] args) { IntPair p = new IntPair(2,3); try { ObjectOutputStream out = new ObjectOutputStream(

new FileOutputStream(Filename)); out.writeObject(p); out.close(); } catch(IOException e) { e.printStackTrace(); }}

}

© M. Winter


1.45


import java.io.*;

public class inout {

public static void main(String[] args) {

try {

ObjectInputStream in = new ObjectInputStream(

new FileInputStream(Filename));

IntPair p = (IntPair) in.readObject();

System.out.println(p);

} catch(Exception e) {

e.printStackTrace();

}

}

}

© M. Winter


1.46

Some useful interfaces• interface Serializable {}• interface Cloneable {}

– this interface does not include the clone method.– a class implements the Cloneable interface to indicate to

the Object.clone() method that it is legal for that method to make a field-for-field copy of instances of that class.

• interface Comparable<T> {

public int compareTo(T o)

}– this interface imposes a total ordering on the objects of

each class that implements it. – compareTo(T o) returns a negative integer, zero, or a

positive integer as this object is less than, equal to, or greater than the specified object.

• interface Comparator<T> {

public int compare(T o1, T o2)

}

© M. Winter


1.47

Utility Classes

The Java library provides a number of small utility classes, including:

• Point• Dimension• Date, Calendar• Math• Random• Toolkit• System• String and related classes

© M. Winter


1.48

Points

class Point implements Cloneable, Serializable {

public Point(int x, int y) //constructor

public int x //public accessible datapublic int y //fields

public void move(int x, int y) //move to a given locationpublic void translate(int x, int y) //change by offsetpublic boolean equals(Object p) //compare two pointspublic String toString() //convert to string

}

x

y

Points represent locations in a two-dimensional space.

© M. Winter


1.49

Dimension

A dimension is used to represent a rectangular size. Dimensions are characterized by a width and a height.

class Dimension implements Cloneable, Serializable {

public Dimension() //constructorspublic Dimension(int w, int h)

public Dimension(Dimension d) //make a copy (clone ?!?!)

public int width //public accessible data fieldspublic int height

public String toString() //operations}

© M. Winter


1.50

Date, Calendar The class Date is used to represent both data and time values.

class Date implements Cloneable, Comparable, Serializable {public Date() //constructorspublic Date(int year, int month, int day) //deprecated,public Date(int year, int month, int day, //replaced by

int hours, int minutes) //Calendar andpublic Date(int year, int month, int day, //the set methodint hours, int minutes, int seconds)

public int getDate()//field access methodspublic int getDay() //deprecated, replaced by Calendar and thepublic int getHours() //get methodpublic int getMinutes()public int getMonth()public int getSeconds()public int getYear()public int getTimezoneOffset()

© M. Winter


1.51

//epoch methodspublic long getTime() //returns milliseconds since epochpublic void setTime(long lval) //set time from epoch

//field setting methodspublic void setDate(int date) //deprecated, replaced bypublic void setHours(int hour) //Calendar and the get methodpublic void setMinutes(int minutes)public void setMonth(int month)public void setSeconds(int seconds)public void setYear(int year)

//comparison methodspublic boolean after(Date when)public boolean before(Date when)public boolean equals(Object when)

//outputpublic String toString()

}

© M. Winter


1.52

Date - Example

Date start = new Date();

int j = 0;

for (int i = 0; i < 100000; i++)

j = j + 1;

Date end = new Date();

System.out.println(“That took “ +

(end.getTime() – start.getTime()) +

“ milliseconds. “);

© M. Winter


1.53

MathThe class Math provides a number of constants, as well as useful mathematical functions.

final class Math {//constantspublic static final double E //2.71828…public static final double PI //3.14159…

//trigonometric operations, angles in radianspublic static double sin(double num)public static double cos(double num)public static double tan(double num)public static double asin(double num) public static double acos(double num)public static double atan(double num)public static double atan(double s, double c)

© M. Winter


1.54

//rounding operationspublic static double ceil(double num)

public static double floor(double num)

public static double rint(double num)

public static int round(float num)

public static long round(double num)

//exponential and powerspublic static double exp(double y)

public static double pow(double x, double y)

public static double log(double x)

public static double sqrt(double x)

© M. Winter


1.55

//other operationspublic static int abs(int num)

public static long abs(long num)

public static float abs(float num)

public static double abs(double num)

public static int max(int x, int y)

public static long max(long x, long y)

public static float max(float x, float y)

public static double max(double x, double y)

public static int min(int x, int y)

public static long min(long x, long y)

public static float min(float x, float y)

public static double min(double x, double y)

public static double random()

}

© M. Winter


1.56

RandomThe class Random provides more general facilities for random

numbers.

class Random implements Serializable {//constructorsRandom()Random(long seed)

//operationspublic void setSeed(long seed)public double nextDouble()public float nextFloat()public int nextInt()public int nextInt(int n)public long nextLong()

//alternative distributionpublic double nextGaussian()

}

© M. Winter


1.57

Random - Example

static public int weightedDistribution(int[] weights) {

int sum = 0;

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

sum += weights[i];

int val = (int) Math.floor(Math.random()*sum + 1);

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

val -= weights[i];

if (val < 0) return i;

}

return 0;

}

© M. Winter


1.58

Toolkit

• This class is the abstract superclass of all actual implementations of the Abstract Window Toolkit (AWT).

• Useful methods:– getFontList(): returns an array of string values,

containing the names of the fonts available on the current system.

– getImage(): takes as a parameter either a string (a file name) or a URL; returns an image as a value of type Image.

– getScreenSize(): returns the number of pixels (type Dimension) in the screen.

– getScreenResolution(): returns the number of dots per inch.

• The Toolkit class is an example of the Abstract Factory design pattern .

© M. Winter


1.59

System

• The class System gives access to several system-wide resources.– System.in: standard input– System.out: standard output– System.err: error output

• Useful methods:– exit(int): immediately halts the current running

program, yielding to the operating system the integer status given in the argument.

– currentTimeMillis(): returns the current time in milliseconds since epoch.

© M. Winter


1.60

String

• In Java a string is an immutable object; it cannot be changed.• implements CharSequence, Comparable, Serializable• String name = “John Smith“;• The addition operator, +, is overloaded:

System.out.println(“The answer is: “ + answer);– addition operator groups left to right, i.e.,

System.out.println(“Catch-“ + 2 + 2);

yields Catch-22,System.out.println(2 + 2 + “warned“);

yields 4warned• use equals(Object obj) or equalsIgnoreCase(String str)

to compare strings

© M. Winter


1.61

String (cont.)

final class String {

public static String valueOf(Object obj) {

if (obj == null)

return “null“;

else

return obj.toString();

}

}

If obj is a string valueOf returns a reference to the original, not a copy!

© M. Winter


1.62

StringBuffer

• String as an array of character symbol; similar to C.• The methods append, insert, and reverse change the

current string buffer and return a reference to the updated string buffer.

String str1 = “Hello “;

String str2 = str1 + str1;

StringBuffer strbuf1 = new StringBuffer(“Hello “);

StringBuffer strbuf2 = strbuf1.append(strbuf1);

© M. Winter


1.63

Collections• containers, data structures• kinds

– bags (multiset)• unordered with duplicates• Collection

– set• unordered without duplicates• also sorted or ordered sets• Set and SortedSet

– list (sequence)• ordered with duplicates• indexing by position• List

– map (dictionary, associative array)• unordered (key,value) pairs

– no duplicate keys– map from key to value

• also sorted or ordered map (by key)• Map and SortedMap

© M. Winter


1.64

Interfaces

• design guideline – Maximize the Uniformity of Common Aspects of Related Classes/Interfaces

Collection

Set

SortedSet

List

Map

SortedMap

E

E E

E

IterableE

K,V

K,V

© M. Winter


1.65

Interfaces• Iterable

– iterator• Collection

– common interface for non-map collections– equals

• Set– modifies semantics – no duplicates– SortedSet

• List– modified semantics – ordered

• Map– not Collection – involves keys, no duplicate keys– views

• entry set (key-value pairs)• key set• value collection

– keys• equals

– SortedMap

© M. Winter


1.66

Collection<E> interfaceadd(o) Adds an element o to this collection.

addAll(c) Adds all the elements in the collection c to this collection.

clear() Removes all elements from this collection.

contains(o) Returns true if this collection contains an element that equals o.

containsAll(c) Returns true if this collection contains all the elements in the collection c.

isEmpty() Returns true if this collection contains no elements.

iterator() Returns an Iterator over the elements in this collection.

remove(o) Removes an element that equals o from this collection.

removeAll(c) Removes from this collection all elements from c.

retainAll(c) Retains only the elements that are contained in c.

size() Returns the number of elements in this collection.

© M. Winter


1.67

Set<E> interface

add(o) Adds an element o to this set if it is not already present.

addAll(c) Adds all the elements in the collection c to this set if they are not already present.

© M. Winter


1.68

List<E> interfaceadd(i, o) Insert the element o at the i-th position in this

list.

add(o) Appends the element o to the end of this list.

addAll(c) Inserts all the elements in the collection c to the end of this list, in the order that they are returned by the iterator of c.

addAll(i, c) Inserts all the elements in the collection c into this list, starting at the i-th position.

get(i) Returns the element at the i-th position in this list.

indexOf(o) Returns the index in this list of the first occurrence of the element o, or –1 if the element is not present in this list.

lastIndexOf(o) Returns the index in this list of the last occurrence of the element o, or –1 if the element is not present in this list.

listIterator() Returns a ListIterator of the elements of this list.

© M. Winter


1.69

List<E> interface (cont.)

listIterator(i) Returns a ListIterator of the elements of this list, starting from the i-th position.

remove(i) Removes the element at the i-th position in this list and returns the removed element.

remove(o) Removes the first occurrence of the element o from this list.

set(i, o) Replaces the element at the i-th position in this list with the element o, and returns the element that was replaced.

subList(i, j) Returns a sublist of this list from the i-th position, inclusive, to the j-th position, exclusive.

© M. Winter


1.70

SortedSet<E> interface

comparator() Returns the comparator associated with this sorted set, or null if the natural order is used.

first() Returns the first (lowest) element currently in this sorted set.

headSet(o) Returns a set view of the portion of this sorted set whose elements are strictly less than o.

last() Returns the last (highest) element currently in this sorted set.

subSet(o1, o2) Returns a set view of the portion of this sorted set whose elements range from o1, inclusive, to o2, exclusive.

tailSet(o) Returns a set view of the portion of this sorted set whose elements are greater than or equal to o.

© M. Winter


1.71

Map<K,V> interfaceclear() Removes all entries from this map.

containsKey(k) Returns true if this map contains an entry for the key k.

containsValue(v) Returns true if this map contains one or more entries with the value v.

entrySet() Returns the entry view of this map.

get(k) Returns the value to which maps this map the key k.

isEmpty() Returns true if this map contains no entries.

keySet() Returns the key set view of this map.

put(k, v) Maps the key k to the value v in this map.

putAll(m) Copies all entries from the map m to this map.

remove(k) Removes the entry for key k from this map if present.

size() Returns the number of entries in this map.

values() Returns the value collection view of this map.

© M. Winter


1.72

SortedMap<K,V> interface

comparator() Returns the comparator associated with this sorted map, or null if the natural order is used.

firstKey() Returns the first (lowest) key currently in this sorted map.

headMap(k) Returns a map view of the portion of this sorted map whose keys are strictly less than k.

lastKey() Returns the last (highest) key currently in this sorted map.

subMap(k1, k2) Returns a map view of the portion of this sorted map whose keys range from k1, inclusive, to k2, exclusive.

tailMap(k) Returns a map view of the portion of this sorted map whose keys are greater than or equal to k.

© M. Winter


1.73

Concrete Classes

Important issues:• bounded versus unbounded• time and space complexity of various operations• interchangeability• concrete collection classes in Java

– all unbounded

© M. Winter


1.74

Set<E>• HashSet<E>

– hash table (efficient in insertion and membership checking)

– unpredictable iteration order– requires equals and hashCode

• LinkedHashSet<E> (similar to HashSet)– hash table with linked elements– predictable iteration order (usually insertion order)– requires equals and hashCode

• TreeSet<E>– red-black tree (a form of balanced binary trees)– SortedSet– requires ordering (Comparable or Comparator)– iteration by natural order– less efficient in insertion and membership checking

Use HashSet unless a sorted set or a predictable iteration order is required.

© M. Winter


1.75

List<E>• ArrayList<E>

– array extended when necessary– large enough to hold predicted number of elements– often, a large portion of the array is unused– large cost to increase size (copying)– more efficient access

• Vector<E>– same implementation as the ArrayList– supports additional “legacy methods”– thread-safe– significant overhead in performance

• LinkedList<E>– doubly-linked list– no additional penalty as list grows– less efficient access

LinkedList for volatile lists, ArrayList for stable lists

© M. Winter


1.76

Map<K,V>

• HashMap<K,V>– hash table (efficient in insertion and membership checking)– unpredictable iteration order– requires equals and hashCode

• Hashtable<K,V>– same implementation as the HashMap– supports additional “legacy methods”– thread-safe– significant overhead in performance

• LinkedHashMap<K,V>– hash table with linked elements– predictable iteration order (usually insertion order)– requires equals and hashCode

© M. Winter


1.77

• IdentityHashMap<K,V> (similar to HashMap)– key equality based on == (identity)– requires hashCode

• TreeMap<K,V>– red-black tree– SortedMap– iteration order by key– requires ordering for keys (Comparable or Comparator)– less efficient in insertion and membership checking

Use TreeMap if a sorted map is required otherwise use HashMap or IdentityHashMap.

© M. Winter


1.78

Abstract Collection Classes

• for building new collections• AbstractCollection<E>

– bag– must implement iterator and size

• AbstractSet<E>– must implement add

• AbstractList<E>– optimized for random access– must implement get and size

• AbstractSequentialList<E>– optimized for sequential access– must implement listIterator and size

• AbstractMap<K,V>– must implement entries

Date post:	01-Jan-2016
Category:	Documents
Upload:	christopher-perry
View:	219 times
Download:	0 times

© M. Winter COSC 3P91 – Advanced Object-Oriented Programming 1.11.1 COSC 3P91 Advanced...

Documents