Comparable Interface
Site: | Saylor Academy |
Course: | CS101: Introduction to Computer Science I |
Book: | Comparable Interface |
Printed by: | Guest user |
Date: | Saturday, May 27, 2023, 8:54 PM |
Description
Objects that have an ordering are compared using the compareTo() method.
Table of contents
- 1. Comparable Interface
- 2. Comparable <T> Interface
- 3. This is enough to put a collection in order.
- 4. Integer
- 5. Natural Order
- 6. Rules for compareTo()
- 7. Consistency with equals()
- 8. Comparing Strings
- 9. Nearly Same Strings, but Different Lengths
- 10. First Differing Pair of Characters
- 11. All the Rules
- 12. Collating Sequence
- 13. Ordered Array
- 14. Integer Sorting Program
- 15. Integer Sorting Program
- 16. String Sorting Program
- 17. Dictionary Entry
- 18. Entry Testing Program
- 19. Binary Search
- 20. Tiny Dictionary
- 21. Monster Object
- 22. Use only some Instance Variables
- 23. End of Chapter
1. Comparable Interface
Objects of a class that implements the Comparable
interface can be arranged into a particular order. For example, objects of class String
, which implements Comparable
, can be arranged into
alphabetical order. Numeric classes such as Integer
or Double
implement Comparable
and their objects can be arranged into numeric order.
Objects of a class that implements Comparable
can be compared to each other to determine which comes first when the objects are arranged in order.
Chapter Topics:
- The Comparable Interface
compareTo()
method- natural order
- collating sequence
- sorting
- binary search
Question 1:
Arrange these strings in order: "orange", "apple", "plum".
Source: Bradley Kjell, https://chortle.ccsu.edu/Java5/Notes/chap53B/ch53B_1.html This work is licensed under a Creative Commons Attribution-NonCommercial 4.0 License.
2. Comparable <T> Interface
Answer:
"apple", "orange", "plum".
This is the order that compareTo()
would place the strings.
Comparable<T>
Interface
Comparable<T>
Interface
An interface consists of constants and method declarations. The Comparable<T>
interface consists of just one method (and no constants):
int compareTo( T obj )Compare the object running |
T
stands for the type of the objects. If the objects are String
s, then T
is String
. String
s implement the Comparable<String>
interface.
If an object is of a class that implements Comparable
, then that object is less than, equal, or greater than any object of that class. compareTo()
returns an integer
to show which of these three relations hold.
Relation | objectA.compareTo( objectB ) | ||
---|---|---|---|
objectA | Less Than | objectB | Negative Integer |
objectA | Equal | objectB | Zero |
objectA | Greater Than | objectB | Positive Integer |
Question 2:
Does compartTo()
tell us enough?
If any two objects can be compared, and the result is less than, equal, or greater
than is this enough to put a collection of objects in order?
3. This is enough to put a collection in order.
Answer:
"apple", "orange", "plum".
This is the order that compareTo()
would place the strings.
Comparable<String>
Interface
Comparable<String>
Interface
StringA is regarded as less than StringB if StringA would be proceed StringB in a dictionary. For example,
Expression |
Evaluates to |
---|---|
"apple".compareTo("orange") |
Negative Integer |
"apple".compareTo("plum") |
Negative Integer |
"apple".compareTo("apple") |
Zero |
"orange".compareTo("orange") |
Zero |
"orange".compareTo("apple") |
Positive Integer |
Only the sign of the returned integer matters if the return value is not zero. The magnitude of a returned integer does not signify anything.
Memory Aide: think of this as subtraction.
apple - orange
will be negative.apple - apple
will be zero.orange - apple
will be positive.
Question 3:
Examine the following:
String myPet = "Fido" ;
String stray = "Rex" ;
if ( myPet.compareTo( stray ) < 0 )
System.out.println( "Good Dog" );
else
System.out.println( "Bad Dog" );
What is printed?
4. Integer
Answer:
Good Dog
Integer
Examine the following declarations. They use the wrapper class Integer
. An Integer
object holds an integer as its data and provides several useful methods for working with integers. Class Integer
implements
the Comparable<Integer>
interface so two Integer
s can be compared.
Integer minusTen = new Integer( -10 );
Integer minusFive = new Integer( -5 );
Integer five = new Integer( 5 );
Integer ten = new Integer( 10 );
Integer fifteen = new Integer( 15 );
Mentally replace "compareTo" with subtraction and do the arithmetic. For example, five.compareTo( ten )
works like five-ten
. (But recall that is only the sign of the result that matters.)
What is the result of each of the following?
Question 4:
Examine the following:
Integer five = 5 ;
Integer ten = 10 ;
What is the value of:
five.compareTo( ten )
5. Natural Order
Answer:
five.compareTo( ten )
is negative.
The declaration of the two Integer
variables looks wrong, but they are actually correct.
Autoboxing automatically constructs Integer
objects for the two primitive integers.
Natural Order
Objects that implement compareTo()
can be arranged into a natural order. This order can be visualized as an arrangement of objects from left to right as on a number line.
The strings in the picture are arranged left to right in dictionary order.
If an object A is left of another object B, then
objectA.compareTo(objectB)
is negative. For example, X.compareTo("orange")
is negative for all the fruit X left of "orange".
Question 5:
What is "grape".compareTo( "banana" );
6. Rules for compareTo()
Answer:
positive
Rules for compareTo()
compareTo()
compareTo()
works the way number comparisons work in ordinary arithmetic. Here are a few rules. Most of these are sensible if you think about numbers. Say that A
, B
, and C
are Integer
s.If A.compareTo(B) > 0
and B.compareTo(C) > 0
then A.compareTo(C) > 0
.
If A.compareTo(B) == 0
then A.compareTo(Z)
and B.compareTo(Z)
gives the same result, no matter what Z is.
Comparable
, you need to follow these rules. This is not hard to do because most sensible compareTo()
methods will do this naturally.Question 6:
Say that X.compareTo(Y)==0
.
Is it then true that X.equals(Y)
?
7. Consistency with equals()
Answer:
For most classes that implement both methods this is true. But it is possible that it is
not true, so check the documentation.
The compareTo()
method might look only at some instance variables of an
object and ignore others. The equals()
method might look at different instance variables.
Consistency with equals()
equals()
compareTo()
.Here is a program that tests some of these ideas:
class TestCompareTo { public static void main ( String[] args ) { String appleA = new String("apple"); // these are two distinct objects String appleB = new String("apple"); // these are two distinct objects String berry = new String("berry"); String cherry = new String("cherry"); String A, B; A = appleA; B = appleB; System.out.print( A + ".compareTo(" + B + ") returns "); if ( A.compareTo(B) == 0) System.out.println("Zero"); if ( A.compareTo(B) < 0 ) System.out.println("Negative"); if ( A.compareTo(B) > 0 ) System.out.println("Positive"); System.out.println( A + ".equals(" + B + ") is " + A.equals(B) ); System.out.println(); A = appleA; B = berry; System.out.print( A + ".compareTo(" + B + ") returns "); if ( A.compareTo(B) == 0) System.out.println("Zero"); if ( A.compareTo(B) < 0 ) System.out.println("Negative"); if ( A.compareTo(B) > 0 ) System.out.println("Positive"); System.out.println( A + ".equals(" + B + ") is " + A.equals(B) ); System.out.println(); A = berry; B = appleA; System.out.print( A + ".compareTo(" + B + ") returns "); if ( A.compareTo(B) == 0) System.out.println("Zero"); if ( A.compareTo(B) < 0 ) System.out.println("Negative"); if ( A.compareTo(B) > 0 ) System.out.println("Positive"); System.out.println( A + ".equals(" + B + ") is " + A.equals(B) ); } } |
Here is the output of the program. You might want to copy the program to a file and run it with a few more selections for A
and B
.
apple.compareTo(apple) returns Zero
apple.equals(apple) is true
apple.compareTo(berry) returns Negative
apple.equals(berry) is false
berry.compareTo(apple) returns Positive
berry.equals(apple) is false
If you edit the program and change some of the strings to contain upper case, the program might output mysterious results.
Question 7:
(Thought Question: ) Do you think that "APPLE".compareTo("apple")
returns zero?
8. Comparing Strings
Answer:
No. Upper and lower case matter.
Comparing Strings
Upper case characters are regarded as less than lower case characters. So "APPLE".compareTo("apple")
returns a negative integer.
When strings are compared, case-sensitive dictionary order is used. Mostly this means that when two strings of the same case are compared, the one that appears first in the dictionary is less than the other. The technical term for this is lexicographic order. Here are the details:
Rule 1: If A.compareTo(B) == 0
, then A
and B
are the same length (counting all characters, including blanks and punctuation) and each character in A
is identical (including case) to the character in B
at the same location.
"batcave".compareTo("batcave") == 0
"batcave".compareTo("bat cave") != 0
There are more rules on the following pages.
Question 8:
Decide which strings, when used with compareTo()
return zero.
9. Nearly Same Strings, but Different Lengths
Answer:
"bugbear" .compareTo ("bugbear") zero "bugbear" .compareTo ("Bugbear") NOT zero "Zorba" .compareTo ("Zorba!") NOT zero "mushroom" .compareTo ("mush room") NOT zero "TOAD" .compareTo ("TOAD") zero
Nearly Same Strings, but Different Lengths
Rule 2: If string A
is a prefix of string B
, then A.compareTo(B) < 0
.
If string B
is a prefix of string A
, then A.compareTo(B) > 0
.
"bat".compareTo("batcave") < 0
"apple".compareTo("applesauce") < 0
"BAT".compareTo("BATCAVE") < 0
"batcave".compareTo("bat") > 0
"applesauce".compareTo("apples") > 0
"BATCAVE".compareTo("BAT") > 0
In using this rule you need to pay attention to case. "BAT" is not a prefix of "batcave".
There are yet more rules.
Question 9:
Decide on the value returned by compareTo()
:
10. First Differing Pair of Characters
Answer:
"bugbear" .compareTo ("bugbear") zero "bug" .compareTo ("bugbear") negative "pepper" .compareTo ("peppermint") negative "toadstool" .compareTo ("toad") positive "cat" .compareTo ("caterpillar") negative
First Differing Pair of Characters
The remaining case is the difficult one. Say that two strings are not identical, and one is not the prefix of the other. Then there must be at least one character in one string that is different from a character at the same position in the other string:
first differing characters are 'a' and 'e'
beat
|
beet
first differing characters are 'r' and 'h'
bear rug
|
bear hug
first differing characters are 'c' and 'm'
batcave
||||
batmobile
first differing characters are 'b' and 'B'
baseball bat
| |
baseBall hat
Find the first pair of differing characters. The result of compareTo()
is based on just that pair.
Rule 3: Find the first differing pair of characters in the strings A
and B
. Call them Achar
and Bchar
. Then A.compareTo(B)
is negative if Achar
comes before Bchar
in the alphabet that Java uses (and otherwise is positive).
This rule compares just two characters. For characters of the same case, the one that comes earlier in the alphabet that Java uses is less than the other. For characters of different case, all upper case characters are less than all lower case characters.
The lengths of the two strings do not matter. Merely find the first differing pair of characters, and base the result on them.
Question 10:
Decide on the following:
Comparison Zero, Positive, or Negative "bugbear" .compareTo ("Bugbear") "rugrat" .compareTo ("rugRat") "ant" .compareTo ("turtle") "toadstool" .compareTo ("total") "ABCDEFG" .compareTo ("ABcD") "roadrunner" .compareTo ("roadkill")
11. All the Rules
Answer:
"bugbear" .compareTo ("Bugbear") positive "rugrat" .compareTo ("rugRat") positive "ant" .compareTo ("turtle") negative "toadstool" .compareTo ("total") negative "ABCDEFG" .compareTo ("ABcD") negative "roadrunner" .compareTo ("roadkill") positive
All the Rules
Here are all the rules for comparing strings:
Rule 1: If
A.compareTo(B) == 0
, thenA
andB
are the same length (counting all characters, including blanks and punctuation) and each character inA
is identical (including case) to the character inB
at the same location.
Rule 2: Otherwise, if string
A
is a prefix of stringB
, thenA.compareTo(B) < 0
. IfB
is a prefix of stringA
, thenA.compareTo(B) > 0
.
Rule 3: Otherwise, find the first differing pair of characters in the strings
A
andB
. Call themAchar
andBchar
. ThenA.compareTo(B)
is negative ifAchar
comes beforeBchar
in the alphabet used by Java (and otherwise is positive).
The rules about what character comes first in the alphabet depend on what country you are in. This is one of the aspects of internationalization, which is the subject of customizing programs for use in different countries. Lets not worry about that.
Question 11:
Of course, you would like to practice this:
12. Collating Sequence
Answer:
"turtle" .compareTo ("turtledove") negative "polarbear" .compareTo ("polarbear") zero "freezing point" .compareTo ("freezing") positive "Power" .compareTo ("power") negative "FORTRAN" .compareTo ("fortran") negative
Collating Sequence
The alphabet that Java uses in comparing characters is called a collating sequence. All characters are placed into this sequence, so any two characters can be compared. Here is the part of the sequence that includes the most common characters:
sp ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ?
@ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _
` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~
Characters are listed in increasing value, so
A < K
0 < Z
Z < a
% < +
@ < {
z < ~
The first character listed 'sp' stands for the single space character. For example,
" hello".compareTo("hello")
returns a negative value.
Most of the time you don't need these details. But sometimes you do, so it is nice to know that they exist. The fact that space comes before nearly all other characters is sometimes useful to explain unexpected program behavior.
Question 12:
More practice. Compare digit-containing strings like "23.5" using character-by-
character string comparison, not arithmetic comparison.
13. Ordered Array
Answer:
Comparison Zero, Negative, or Positive " 9999" .compareTo ("023") negative "(rat)" .compareTo ("[cat]") negative "23.5" .compareTo ("23,7") positive "More Cheese?" .compareTo ("More Cheese!") positive "cobol" .compareTo ("cobalt") positive
Ordered Array
The elements of an ordered array are arranged in ascending (or descending) order. In general, an ordered array can have duplicate elements. (In some situations, though, an array is guaranteed not to have duplicates.) The picture shows an array of ints
arranged into ascending order.
The elements of an array can be arranged in order by using a static sort()
method of the Arrays
class.
// Sort the array into ascending order
static void sort( array )
There are sort()
methods for arrays of type byte[]
, char[]
, double[]
, float[]
, int[],
and long[]
. There is also a method that can sort object references based on the values of the objects.
Sorting is an important process in computer programming. Many data processing operations depend on data that is sorted, much as the data in a filing cabinet is kept sorted.
Question 13:
Would a dictionary be useful if its definitions were not in sorted order?
14. Integer Sorting Program
Answer:
No
Integer Sorting Program
static void sort( int[] )
method of Arrays
. The method is static
so it can be used without constructing an Arrays
object.
import java.util.Arrays; class ArrayDemoOne { public static void main ( String[] args ) { int[] scramble = {148, -23, 67, 110, -17, 44, 103, -12, -8, 91, -12, 43, 0, 9, 80, 34, 21, 44, 15, 11}; System.out.print("Scrambled array: "); for ( int j=0; j < scramble.length; j++ ) System.out.print( scramble[j] + " "); System.out.println(); Arrays.sort( scramble ); System.out.print("Sorted array: "); for ( int j=0; j < scramble.length; j++ ) System.out.print( scramble[j] + " "); System.out.println(); } } |
The output of the program is:
Scrambled array: 148 -23 67 110 -17 44 103 -12 -8 91 -12 43 0 9 80 34 21 44 15 11
Sorted array: -23 -17 -12 -12 -8 0 9 11 15 21 34 43 44 44 67 80 91 103 110 148
Question 14:
Could compareTo()
be used to decide on the order for an array of String
references?
15. Integer Sorting Program
Answer:
Yes.
Integer Sorting Program
Here is a picture of an ordered array. Each cell of the array holds a reference to a String
. The order of the String
s is determined by the values returned by the compareTo()
method for String
s.
For any two strings X
and Y
, if X.compareTo(Y)
is negative, then X
is left of Y
in the ordered array.
For an array of object references, the sort()
method automatically uses the compareTo()
method of the class of objects being sorted. The class must implement the Comparable
interface (and so must have a compareTo()
method).
static void sort( Object[] a )
- // Sorts the array a into ascending order,
// Each cell of the array must refer to an object
// (must not be null).
If not all cells of the array are filled, use
static void sort( Object[] a,
int fromIndex, int toIndex )
// Sorts the array a into ascending order,
// as determined by the values compareTo() returns.
//
// Only the cells between the two indexes are sorted.
// Each of those cells must refer to an object.
Question 15:
Does String
implement Comparable
?
16. String Sorting Program
Answer:
Yes. So an array of String
references can be sorted.
String Sorting Program
Here is a program that demonstrates how sort()
is used with an array of String
references.
Notice the use of the for-each loops.
The output of the program is:
Scrambled array: bat fox gnu eel ant dog fox gnat
Sorted array: ant bat dog eel fox fox gnat gnu
import java.util.Arrays; class ArrayDemoTwo { public static void main ( String[] args ) { String[] animals = {"bat", "fox", "gnu", "eel", "ant", "dog", "fox", "gnat" }; System.out.print("Scrambled array: "); for ( String anm : animals ) System.out.print( anm + " "); System.out.println(); Arrays.sort( animals ); System.out.print("Sorted array: "); for ( String anm : animals ) System.out.print( anm + " "); System.out.println(); } } |
Question 16:
To use sort()
with a class that you define, what interface must that class implement?
17. Dictionary Entry
Answer:
The class must implement Comparable
.
Dictionary Entry
Say that you are writing a program that acts like a dictionary. A dictionary entry has two instance variables: the word that it defines and the definition.
A class that implements Comparable<T>
must implement the method int compareTo( T other )
where T
is the type of the class.
Since our Entry
implements the Comparable<Entry>
interface, it must implement the method int compareTo( Entry other )
.
class Entry implements Comparable<Entry> { private String word; private String definition; public Entry ( String word, String definition ) { this.word = word; this.definition = definition; } public String getWord() { return word; } public String getDefinition() { return definition; } public String toString() { return getWord() + "\t" + getDefinition(); } public int compareTo( Entry other ) { return ; } } |
Question 17:
When the entries of a dictionary are put in order, does the order depend on the definition?
Should the compareTo()
method depend on the definition?
Fill in the blank to complete the compareTo()
method.
Hint: use the compareTo()
method of the String
.
18. Entry Testing Program
Answer:
When the entries of a dictionary are put in order, does the order depend on the definition? No.
Should the compareTo()
method depend on the definition? No.
Fill in the blank to complete the compareTo()
method.
public int compareTo( Entry other )
{
return getWord().compareTo( other.getWord() );
}
Another solution is:
public int compareTo( Entry other )
{
return word.compareTo( other.word );
}
Entry Testing Program
Entry
class works as expected.
import java.util.Arrays; class Entry implements Comparable<Entry> { . . . } class EntryTester { public static void main ( String[] args ) { Entry[] wordList = new Entry[10]; wordList[0] = new Entry( "WWW", "World Wide Web" ); wordList[1] = new Entry( "HTTP","Hypertext Transport Protocol" ); wordList[2] = new Entry( "DNS", "Domain Name System" ); wordList[3] = new Entry( "AWT", "Application Windowing Toolkit" ); wordList[4] = new Entry( "CPU", "Central Processing Unit" ); wordList[5] = new Entry( "RAM", "Random Access Memory" ); wordList[6] = new Entry( "URL", "Uniform Resource Locator" ); wordList[7] = new Entry( "GUI", "Graphical User Interface" ); wordList[8] = new Entry( "API", "Application Programming Interface" ); wordList[9] = new Entry( "ROM", "Read-only Memory" ); Arrays.sort( wordList ); for ( int j=0; j<wordList.length; j++ ) System.out.println( wordList[j].toString() ); } } |
The program outputs:
API Application Programming Interface
AWT Application Windowing Toolkit
DNS Domain Name System
CPU Central Processing Unit
GUI Graphical User Interface
ROM Read-only Memory
HTTP Hypertext Transport Protocol
RAM Random Access Memory
URL Uniform Resource Locator
WWW World Wide Web
The sort()
method used our compareTo()
to determine the order of the entries.
Question 18:
Must an array be in sorted order for it to be searched?
19. Binary Search
Answer:
No. Linear search can be used to look through the entries one-by-one starting with the first entry.
Binary Search
Linear search is slow. Just think of using it by hand with a paper dictionary. Looking up "zebra" would take a long time if you first had to inspect every entry that preceded it. Usually you search for an entry by guessing about where it will be in the dictionary and then going to that page. If your guess is correct, you are done. Otherwise you refine your guess by looking at the page you picked and deciding if your new guess should go forward or backward. You can do this because the words are in sorted order.
When an array is ordered, an algorithm called binary search can be used to search for an entry. This algorithm works about the same way as you do when you search a dictionary. The Arrays
class has several binarySearch()
methods that can quickly search arrays of primitive types or of object references.
Let us look at the one that searches an array of object references.
static int binarySearch( Object[] array, Object key )
Search the array for an object that matches key
, using the compareTo()
method. If the object is found, return the index of the object in the array. Otherwise, return a negative value.
Details (safe to skip, for now): If the return value R is negative, then (-R) is one cell beyond where the key
would be found if it were in the array. Use this value to insert a new element into its proper place in the array. (Move elements at (-R) and above to make room.)
If (-R) equals the size of the array, then the key
is not in the array, and it should go at the very end, but there is no room.
For now, let us use binary search for searching and not insert new entries into the array.
Question 19:
With a dictionary of just 10 entries, does it make much difference how fast searching is?
20. Tiny Dictionary
Answer:
No... but you should know that binary search exists in case you need it in a large
application. With large amounts of data, binary search is very much faster than linear search.
Tiny Dictionary
import java.util.Arrays; import java.util.Scanner; class TinyDictionary { public static void main ( String[] args ) { Entry[] wordList = new Entry[10]; wordList[0] = new Entry( "WWW", "World Wide Web" ); wordList[1] = new Entry( "HTTP","Hypertext Transport Protocol" ); wordList[2] = new Entry( "DNS", "Domain Name System" ); wordList[3] = new Entry( "AWT", "Application Windowing Toolkit" ); wordList[4] = new Entry( "CPU", "Central Processing Unit" ); wordList[5] = new Entry( "RAM", "Random Access Memory" ); wordList[6] = new Entry( "URL", "Uniform Resource Locator" ); wordList[7] = new Entry( "GUI", "Graphical User Interface" ); wordList[8] = new Entry( "API", "Application Programming Interface" ); wordList[9] = new Entry( "ROM", "Read-only Memory" ); Arrays.sort( wordList ); Scanner scan = new Scanner( System.in ); String key = ""; int location; System.out.print("Word: "); key = scan.next(); while ( !key.equals("quit") && !key.equals("q") ) { location = Arrays.binarySearch( wordList, new Entry( key, "" ) ); if ( location < 0 ) System.out.println("Not in the dictionary"); else System.out.println( wordList[location] ); System.out.print("Word: "); key = scan.next(); } } } |
The following program implements a tiny dictionary. The user enters a word, the program looks up the word and prints the word and its definition. With a little work, this program could be turned into an almost practical application.
The binary search method is a static method of the Arrays
class, so it can be invoked by Arrays.binarySearch()
without the need for an Arrays
object.
The parameters are a sorted list of Entry
objects, and an Entry
object to serve as the key to look up. The key is constructed using the word the user entered and an empty string for the definition:
new Entry( key, "" )
Since the compareTo()
method does not look at the definition, this works fine.
Here is sample output from the program:
Word: URL
URL Uniform Resource Locator
Word: WWW
WWW World Wide Web
Word: quit
Question 20:
Must all the cells of the array be non-null to useArrays.binarySearch()
?
21. Monster Object
Answer:
Yes.
Monster Object
Say that you are writing a computer game that involves a hero who encounters various monsters. Monsters have several characteristics: hit points, strength, age, and name. The number of hit points a monster has is how far it is from death. A monster with a large number of hit points is hard to kill. The hero also has hit points.
When the hit points of the hero reach zero, the game is over. The strength of a monster affects how many hit points the hero looses when the monster hits the hero. The age and name of the monster do not affect the outcome of battles between the monster and a hero.
Monster
needs a compareTo()
method so that monsters can be compared. For example, the game will present the hero with monsters in increasing order of difficulty.
Here is an outline of the Monster
class.
class Monster implements { private int hitPoints, strength, age; private String name; public Monster( int hp, int str, int age, String nm ) { hitPoints = hp; strength = str; this.age = age; name = nm; } public int getHitPoints() { return hitPoints; } public int getStrength() { return strength; } public int getAge() { return age; } public String getName() { return name; } public String toString() { return "HP: " + getHitPoints() + " \tStr: " + getStrength() + "\t" + getName(); } public int compareTo( ) { .... more goes here ... } } |
Question 21:
Fill in the blanks.
22. Use only some Instance Variables
Answer:
See Below
Use only some Instance Variables
The compareTo()
method takes a reference to another Monster
as a parameter.
class Monster implements Comparable<Monster> { . . . public int compareTo( Monster other ) { .... more goes here ... } } |
Typically, only some of the instance variables of a complex object are used by compareTo()
. Say that you want monsters to be listed in ascending order of hit points. Monsters with the same number of hit points are ordered by ascending
strength.
It is easy to get this backwards. What you want is for compareTo(Monster other)
to return a negative int
when the monster that owns the method is less than the other
monster.
Here is a partially completed method that does that:
public int compareTo( Monster other ) { int hitDifference = getHitPoints()-other.getHitPoints(); if ( ) return hitDifference; else return ; } |
Question 22:
Fill in the blanks.
23. End of Chapter
Answer:
public int compareTo( Monster other )
{
int hitDifference = getHitPoints()-other.getHitPoints();
if ( hitDifference != 0 )
return hitDifference;
else
return getStrength()-other.getStrength();
}
End of Chapter
You have reached the end of the chapter. You may wish to search this list for something that interests you.
- The compareTo() compareTo() method.
- natural order natural order
- lexicographic order lexicographic order
- collating sequence collating sequence
- ordered array ordered array and the
sort()
method - sort(), objects
sort()
method with reference values. - binary search binary search