Comparable introduction
Comparable is the sort interface.
If a class implements the comparable interface, it means "this class supports sorting." The class that implements the comparable interface supports sorting, assuming that there is now a list (or array) of objects for the class that implements the comparable interface, the list (or array) can be passed through Collections.sort (or Arrays.sort) to sort.
In addition, the object of the class implementing the comparable interface can be used as a key in an ordered map (such as TreeMap) or as an element in an ordered collection (TreeSet) without specifying a comparer.
Comparable definition
The comparable interface only includes a function, which is defined as follows:
Copy Code code as follows:
Package Java.lang;
Import java.util.*;
Public interface Comparable<t> {
public int compareTo (T o);
}
Description
Suppose we use X.compareto (y) to "compare the size of x and Y". Returning a "negative number" means "x is smaller than Y"; returning "0" means "x equals Y"; returning "positive" means "X is greater than Y".
Comparator Introduction
Comparator is the comparator interface.
If we need to control the order of a class, and the class itself does not support sorting (that is, not implementing the comparable interface), then we can create a "comparer for that class" to sort. This "comparer" only needs to implement the comparator interface.
That is, we can create a new comparer by implementing the comparator class, and then sort the class by the comparer.
Comparator definition
The Comparator interface consists of only two functions, which are defined as follows:
Copy Code code as follows:
Package java.util;
Public interface Comparator<t> {
int compare (t O1, T O2);
Boolean equals (Object obj);
}
Description
(01) If a class implements the comparator interface: it must implement the CompareTo (t O1, T O2) function, but it may not implement the Equals (Object obj) function.
Why not implement the Equals (Object obj) function? Because any class, the default is already implemented equals (Object obj). All classes in Java inherit from Java.lang.Object and implement the Equals (Object obj) function in Object.java, so all other classes are equivalent to implementing the function.
The int compare (t O1, T O2) is the size of the comparison O1 and O2. Returning "negative numbers" means "O1 is smaller than O2"; returning "0" means "O1 equals O2"; returning "positive" means "O1 is greater than O2."
Comparison of Comparator and comparable
Comparable is a sort interface, and if a class implements the comparable interface, it means "this class supports sorting."
And comparator is a comparator; if we need to control the order of a class, we can create a "comparer for that class" to sort.
We are not hard to find: comparable is equivalent to "internal comparator", and comparator is equivalent to "external comparator".
We use a test program to illustrate these two interfaces. The source code is as follows:
Copy Code code as follows:
Import java.util.*;
Import java.lang.Comparable;
/**
* @desc "Comparator" and "comparable" comparison procedures.
* (a) "comparable"
* It is a sort interface that contains only one function CompareTo ().
* A class implements the comparable interface, meaning that the class itself supports sorting, which can be sorted directly by Arrays.sort () or Collections.sort ().
* () "Comparator"
* It is a comparator interface that includes two functions: compare () and Equals ().
* A class implements the comparator interface, then it is a "comparer". Other classes, which can be sorted according to the comparer.
*
* To sum up: comparable is an internal comparator, and comparator is an external comparator.
* A class itself implements the comparable comparer, meaning that it supports sorting itself, and if it does not implement comparable itself, it can also be sorted by an external comparer comparator.
*/
public class comparecomparatorandcomparabletest{
public static void Main (string[] args) {
New ArrayList (dynamic array)
arraylist<person> list = new arraylist<person> ();
adding objects to ArrayList
List.add (New person ("CCC", 20));
List.add (New person ("AAA", 30));
List.add (New person ("BBB", 10));
List.add (New person ("ddd", 40);
Print the original sequence of the list
System.out.printf ("Original Sort, list:%s\n", list);
Sort the list
This is sorted according to the "Comparable<string> Interface for person implementation", which is sorted according to "name"
Collections.sort (list);
System.out.printf ("Name Sort, list:%s\n", list);
Sort list By "comparer (Ascagecomparator)"
Ascagecomparator Sort by: sorted by ascending order of "age"
Collections.sort (list, new Ascagecomparator ());
System.out.printf ("ASC (age) Sort, list:%s\n", list);
Sort list By "comparer (Descagecomparator)"
Descagecomparator is sorted by descending order of "age"
Collections.sort (list, new Descagecomparator ());
System.out.printf ("Desc (age) Sort, list:%s\n", list);
Determine whether two person is equal
Testequals ();
}
/**
* @desc Test Two person comparisons are equal.
* Because person implements the Equals () function: If both the age and name are equal, the two is considered equal.
* So, the P1 and P2 are equal.
*
* TODO: If you remove the Equals () function in person, p1 is not equal to P2
*/
private static void Testequals () {
person P1 = new person ("Eee", 100);
person P2 = new Person ("Eee", 100);
if (P1.equals (p2)) {
System.out.printf ("%s EQUAL%s\n", p1, p2);
} else {
System.out.printf ("%s not EQUAL%s\n", p1, p2);
}
}
/**
* @desc Person class.
* Person implements the comparable interface, which means that the person itself supports sorting
*/
private static class person implements comparable<person>{
int age;
String name;
Public person (String name, int age) {
THIS.name = name;
This.age = age;
}
Public String GetName () {
return name;
}
public int getage () {
return age;
}
Public String toString () {
Return name + "-" +age;
}
/**
* Compare two person equality: if their name and age are equal, they are considered equal
*/
Boolean equals (person person) {
if (this.age = = Person.age && this.name = = person.name)
return true;
return false;
}
/**
* @desc Implement "comparable<string>" interface, that is, rewrite the compareto<t t> function.
* This is compared by "person's name".
*/
@Override
public int compareTo (person person) {
Return Name.compareto (Person.name);
return this.name-person.name;
}
}
/**
* @desc Ascagecomparator Comparator
* It is "the ascending comparer for the age of person"
*/
private static class Ascagecomparator implements Comparator<person> {
@Override
public int compare (person P1, person p2) {
Return P1.getage ()-p2.getage ();
}
}
/**
* @desc Descagecomparator Comparator
* It is "the ascending comparer for the age of person"
*/
private static class Descagecomparator implements Comparator<person> {
@Override
public int compare (person P1, person p2) {
Return P2.getage ()-p1.getage ();
}
}
}
The following is a description of the program.
A) the person class definition. As follows:
Copy Code code as follows:
private static class person implements comparable<person>{
int age;
String name;
...
/**
* @desc Implement "comparable<string>" interface, that is, rewrite the compareto<t t> function.
* This is compared by "person's name".
*/
@Override
public int compareTo (person person) {
Return Name.compareto (Person.name);
return this.name-person.name;
}
}
Description
The People class represents a person, and there are two attributes in the Persong class: Age and Name "name".
The person class implements the comparable interface, so it can be sorted.
b in Main (), we create a list of person's lists. As follows:
Copy Code code as follows:
New ArrayList (dynamic array)
arraylist<person> list = new arraylist<person> ();
adding objects to ArrayList
List.add (New person ("CCC", 20));
List.add (New person ("AAA", 30));
List.add (New person ("BBB", 10));
List.add (New person ("ddd", 40);
c) Next, we print out all the elements of the list. As follows:
Copy Code code as follows:
Print the original sequence of the list
System.out.printf ("Original Sort, list:%s\n", list);
D Then, we sort the list by collections the sort () function.
Because person implements the comparable interface, sorting by sort () is sorted by the rules defined by the person that is supported by the person, i.e. compareTo. As follows:
Copy Code code as follows:
Sort the list
This is sorted according to the "Comparable<string> Interface for person implementation", which is sorted according to "name"
Collections.sort (list);
System.out.printf ("Name Sort, list:%s\n", list);
e) contrasting comparable and comparator
We have defined two comparators ascagecomparator and Descagecomparator to perform ascending and descending sorting on the person individually.
E.1) Ascagecomparator Comparator
It is the ascending sort of person by age. The code is as follows:
Copy Code code as follows:
/**
* @desc Ascagecomparator Comparator
* It is "the ascending comparer for the age of person"
*/
private static class Ascagecomparator implements Comparator<person> {
@Override
public int compare (person P1, person p2) {
Return P1.getage ()-p2.getage ();
}
}
E.2) Descagecomparator Comparator
It sorts the descending order of person by age. The code is as follows:
Copy Code code as follows:
/**
* @desc Descagecomparator Comparator
* It is "the ascending comparer for the age of person"
*/
private static class Descagecomparator implements Comparator<person> {
@Override
public int compare (person P1, person p2) {
Return P2.getage ()-p1.getage ();
}
}
f) Run results
Run the program, the output is as follows:
Copy Code code as follows:
original sort, list:[ccc-20, AAA-30, bbb-10, ddd-40]
Name&nb sp; sort, list:[aaa-30, bbb-10, ccc-20, ddd-40]
Asc (age) Sort, list:[bbb-10, Ccc-20, AAA-30, ddd-40]
Desc (age) Sort, list:[ddd-40, AAA-30, ccc-20, bbb-10]
eee-100 EQUAL eee -MB
