5-1

• Data types: values, operations, and data representation.

• Abstract data type: values and operations only.

• Requirements, contract, implementation(s).

• (Design of abstract data types.)

• String abstract data types.

• Abstract data types in the Java class library.

5Abstract Data Types

© 2001, D.A. Watt and D.F. Brown

5-2

Data types

• We classify all data into data types, such as: Booleans

integers

objects of various classes.

• Each data type is characterized by: a set of values

a data representation(which is common to all these values)

a set of operations(which can be applied uniformly to all these values).

5-3

Java data types

Type Values Data representation

Operations

boolean false, true 1 byte || && !

char Unicode characters 2 bytes (as for int)

int negative, zero, positive whole numbers

32-bit twos-complement

+ - * / %< > == etc.

float negative, zero, positive floating-point numbers

IEEE 32-bit floating-point

String sequences of characters array of characters + length charAt etc.

5-4

Introducing new data type

• To introduce a new data type, we must define its values, data representation, and operations.

• In Java, use a class declaration: The class’s instance variables determine the values and data

representation.

The class’s constructors and methods are the operations.

• Each object of the class: has those instance variables

is created by one of those constructors

may be inspected and/or updated by any of those methods.

5-5

Example 1 (2)

• Possible application code:

Person p1 = new Person("Curie", "Pierre", 1859);

Person p2 = new Person("Sklodowska", "Marie", 1867);

…p2.changeName(p1.surname);

5-6

Example 2: Date data type (1)

• Class declaration:

public class Date {// Each Date value is a past, present, or future date.

// This date is represented by a year number y, a month number

// m (1…12), and a day-in-month number d (1…31):public int y, m, d;

public Date (int y, int m, int d) {// Construct a date with year y, month m, and day-in-month d.

if (m < 1 || … ) throw …;this.y = y; this.m = m; this.d = d;

}

5-7

Example 2 (2)

• Class declaration (continued):

public void advance (int n) {// Advance this date by n days (where n ≥ 0).

int y = this.y, m = this.m,d = this.d + n;

for (;;) {int last = …; // no. of days in m, yif (d <= last) break;d -= last;if (m < 12) m++;else { m = 1; y++; }

}this.y = y; this.m = m; this.d = d;

}

}

5-8

Example 2 (3)

• Possible application code:

Date today = new Date(2001, 2, 14);today.advance(16);System.out.println(today.y + '-' + today.m

+ '-' + today.d);

This should print “2001-3-2”.

5-9

Example 2 (4)

• Problem: This data representation admits improper values (e.g., m = 0; or m = 2 and d = 30).

• Constructors and methods can (should) be coded to avoid improper values. E.g.:

Date today = new Date(2001, 2, 30);

will throw an exception.

• But what if the data representation is accessed directly?

Date today = new Date(2001, 2, 14);today.d += 16;

5-10

Example 3: Date data type again (1)

• A different data representation is possible:

public class Date {// Each Date value is a past, present, or future date.

// This date is represented by a day-in-epoch number d // (where 0 represents 1 January 2000):public int d;

public Date (int y, int m, int d) { … }

public void advance (int n) { … }

}

• This makes advance faster, but Date() slower.

5-11

Example 3 (2)

• Recall existing application code:

Date today = new Date(2001, 2, 14);today.advance(16);System.out.println(today.y + '-' + today.m

+ '-' + today.d);

fails to compileyields wrong value fails to compile

5-12

Public vs. private data representation

• If the data representation is public:

– Application code might make improper values.

– Existing application code might be invalidated by change of representation.

• If the data representation is private:

+ Application code cannot make improper values.

+ Existing application code cannot be invalidated by change of representation.

5-13

Abstract data types

• An abstract data type (ADT) is characterized by: a set of values

a set of operations.

It is not characterized by its data representation.

• The data representation is private, so application code cannot access it. (Only the operations can.)

• The data representation is changeable, with no effect on application code. (Only the operations must be recoded.)

5-14

ADT specification (1)

• Each ADT should have a contract that: specifies the set of values of the ADT

specifies each operation of the ADT(i.e., the operation’s name, parameter type(s), result type, and observable behavior).

• The contract does not specify the data representation, nor the algorithms used to implement the operations.

• The observable behavior of an operation is its effect as ‘observed’ by the application code. Example of observable behavior: search an array.

Examples of algorithms with that behavior: linear search, binary search.

5-15

ADT specification (2)

• The ADT programmer undertakes to provide an implementation of the ADT that respects the contract.

• The application programmer undertakes to process values of the ADT using only the operations specified in the contract.

• Separation of concerns: The ADT programmer is not concerned with what applications the

ADT is used for.

The application programmer is not concerned with how the ADT is implemented.

• Separation of concerns is essential for designing and implementing large systems.

5-16

Example 4: contract for Date ADT (1)

• Assumed application requirements:

1) *** The values must be all past, present, and future dates.

2) *** It must be possible to construct a date from year number y, month number m, and day-in-month number d.

3) It must be possible to compare dates.

4) It must be possible to render a date in ISO format “y-m-d”.

5) It must be possible to advance a date by n days.

5-17

En Java - généralité

• Spécifier un contrat comme une interface Méthodes exigées

• Déclarer une clase conforme à cette interface Choix des structures de données et définition des attributs

Implantation de toutes les méthodes exigées

• Utilisation de la classe dans une application

5-18

Spécifier un contrat en Java

• Interface: Constante

Méthode abstraite

• Mécanisme idéal en Java pour définir un ADT

• (Un autre mécanisme possible est la classe abstraite)

• Note: les spécifications présentées ici sont modifiées par rapport au livre (class -> interface)

5-19

Example 4 (2)

• Possible contract, expressed as an interface:

public interface DateADT {// Each Date value is a past, present, or future date.

public int compareTo (Date that);// Return –1 if this date is earlier than that, // or 0 if this date is equal to that, // or +1 if this date is later than that.

public String toString ();// Return this date rendered in ISO format.

public void advance (int n);// Advance this date by n days (where n ≥ 0).

}

5-20

Définir une classe conforme à une interface

• Utiliser ‘implements’

• Exemple

class <nom_classe> implements <interface> {

<attributs>

<constructeurs>

<implantation de toutes les méthodes exigées dans l’interface>

<autres méthodes>

}

5-21

Exemple 4class Date implements DateADT {

private … // les attributs de la classe

public Date(int y, int m, int d) { ... }

//constructeur

public int compareTo (Date that) { ... }

public String toString () {...}

public void advance (int n) {...}

...

}

5-22

Example 4 (4)

• Possible application code:

Date today = …;Date easter = new Date(2001, 4, 15);today.advance(16);if (today.compareTo(easter) < 0)

System.out.println(today.toString());

• Impossible application code:

today.d += 16;System.out.println(today.y + '-' + today.m

+ '-' + today.d);

fails to compilefails to compile

5-23

ADT implementation (in a class)

• An implementation of an ADT entails: choosing a data representation

choosing an algorithm for each operation.

• The data representation must be private.

• The data representation must cover all possible values.

• The algorithms must be consistent with the data representation.

5-24

Example 5: first implementation of Date ADT (1)

• Class declaration:

public class Date implements DateADT {// Each Date value is a past, present, or future date.

// This date is represented by a year number y, a month number

// m, and a day-in-month number d:private int y, m, d;

public Date (int y, int m, int d) {// Construct a date with year y, month m, and day-in-month

d.this.y = y; this.m = m; this.d = d;

}

5-25

Example 5 (2)

• Class declaration (continued) – implementation of the required methods:

public int compareTo (Date that) {// Return –1 if this date is earlier than that, // or 0 if this date is equal to that, // or +1 if this date is later than that.

return (this.y < that.y ? -1 : this.y > that.y ? +1 :

this.m < that.m ? -1 : this.m > that.m ? +1 : this.d < that.d ? -1 : this.d > that.d ? +1 : 0);

}

5-26

Example 5 (3)

• Class declaration (continued):

public String toString () {// Return this date rendered in ISO format.

return (this.y + '-' + this.m + '-'+ this.d);

}

public void advance (int n) {// Advance this date by n days (where n ≥ 0).

…}

}

complicated

5-27

Example 6: second implementationof Date ADT (1)

• Class declaration:

public class Date implements DateADT{// Each Date value is a past, present, or future date.

// This date is represented by a day-in-epoch number d // (where 0 represents 1 January 2000):private int d;

public Date (int y, int m, int d) {// Construct a date with year y, month m, and day-in-month

d.…;this.d = …;

}

complicated

5-28

Example 6 (2)

• Class declaration (continued):

public int compareTo (Date that) {// Return –1 if this date is earlier than that, // or 0 if this date is equal to that, // or +1 if this date is later than that.

return (this.d < that.d ? -1 : this.d > that.d ? +1 : 0);

}

5-29

Example 6 (3)

• Class declaration (continued):

public String toString () {// Return this date rendered in ISO format.

int y, m, d;…;return (y + '-' + m + '-' + d);

}

public void advance (int n) {// Advance this date by n days (where n ≥ 0).

this.d += n;}

}

complicated

5-30

ADT design (1)

• A constructor is an operation that creates a value of the ADT (dans une classe qui implante cet ADT)

• An accessor is an operation that uses a value of the ADT to compute a value of some other type.

• A transformer is an operation that computes a new value of the same ADT.

• A well-designed ADT provides at least one constructor, at least one accessor, and at least one transformer. The constructors and transformers together can generate all values of the ADT.

5-31

ADT design II (2)

• A transformer is: mutative if it overwrites the old value with the new value

applicative if it returns the new value, without overwriting the old value.

• The values of an ADT are: mutable if the ADT provides at least one mutative transformer

immutable if the ADT provides no mutative transformer.

• Ces caractéristiques déterminent le choix d’une structure de données.

5-32

Example 8: design of Date ADT (1)

• Recall the Date contract of Example 4:

public interface DateADT {// private …;// public Date (int y, int m, int d);public int compareTo (Date that);public String toString ();public void advance (int n);

}

constructor

mutative transformer

accessor

accessor

5-33

Example 8 (2)

• Consider another possible Date contract:

public inerface DateADT2 {// private …;// public Date (int y, int m, int d);public int compareTo (Date that);public String toString ();public Date plus (int n);

}

constructor

applicative transformer

accessor

accessor

5-34

Strings

• A string is a sequence of characters.

• The characters have consecutive indices.

• A substring of a string is a subsequence of its characters.

• The length of a (sub)string is its number of characters.

• The empty string has length zero.

5-35

String ADTs

• Assumed application requirements:

1) The values are to be strings of any length.

2) It must be possible to determine the length of a string.

3) It must be possible to obtain the character at a given index.

4) It must be possible to obtain the substring at a given range of indices.

5) It must be possible to compare strings lexicographically.

6) It must be possible to concatenate strings.

5-36

Immutable strings: contract (1)

• Possible contract expressed as an outline class declaration:

public interface StringADT {

// Each String value is an immutable string of characters, // of any length, with indices starting at 0.

// private …;

/////////////// Constructor ///////////////

// public String (char[] cs);// Construct a string consisting of all the chars in cs.

5-37

Immutable strings: contract (2)

• Possible contract (continued):

/////////////// Accessors ///////////////

public int length ();// Return the length of this string.

public char charAt (int i);// Return the character at index i in this string.

public bool equals (String that);// Return true if and only if this string is equal to that.

public int compareTo (String that);// Return –1 if this string is lexicographically less than

that, // or 0 if this string is equal to that, // or +1 if this string is lexicographically greater than that.

5-38

Immutable strings: contract (3)

• Possible contract (continued):

/////////////// Transformers ///////////////

public String substring (int i, int j);// Return the substring of this string consisting of the

characters // whose indices are i, …, j–1.

public String concat (String that);// Return the string obtained by concatenating this string and // that.

}applicative

transformers

5-39

Immutable strings: implementations

• Represent a string by its length n together with an array of exactly n characters, e.g.:

• Or represent a string by its length n together with an SLL of characters, e.g.:

• The array representation is much better. Since these strings are immutable, we never insert or delete characters.

4 ‘J’ ‘a’ ‘v’ ‘a’3210length

‘J’ ‘a’ ‘v’ ‘a’4length first

5-40

Mutable strings: contract (1)

• Possible contract expressed as an intertface declaration:

public interface MutableStringADT {

// Each MutableString value is a mutable string, of any // length, with indices starting at 0.

// private …;

/////////////// Constructor ///////////////

// public MutableString ();// Construct an empty mutable string.

5-41

Mutable strings: contract (2)

• Possible contract (continued):

/////////////// Accessors ///////////////

public int length ();// Return the length of this string.

public char charAt (int i);// Return the character at index i in this string.

public int compareTo (MutableString that);// Return –1 if this string is lexicographically less than that, // or 0 if this string is equal to that, // or +1 if this string is lexicographically greater than that.

public String substring (int i, int j);// Return the substring of this string consisting of the characters // whose indices are i, …, j–1.

5-42

Mutable strings: contract (3)

• Possible contract (continued):

/////////////// Transformers ///////////////

public void setCharAt (int i, char c);// Set the character at index i in this string to c.

public void append (String s);// Insert the characters of s after the last character of this string.

public void insert (int i, String s);// Insert the characters of s before the character at index i in // this string.

public void delete (int i, int j);// Delete the characters of this string whose indices are i, …, // j–1.

}

Question: Tableau ou liste? mutative transformers

5-43

ADTs in the Java class library

• Class java.lang.String is similar to String above.

• Class java.lang.StringBuffer is similar to MutableString above.

• Interface java.util.List supports lists.

• Interface java.util.Set supports sets.

• Interface java.util.Map supports maps (tables).

• Packages java.awt, java.io, java.util, etc., support many other ADTs.