Implementation and use of the comparable interface

1. What is the comparable interface?

This interface forces the overall ordering of the objects for each class that implements it. This sort is called the natural sort of the class, and the compareTo method of the class is called its natural comparison method . The list of objects (and arrays) that implement this interface can be automatically sorted by Collections.sort (and arrays.sort ). An object that implements this interface can be used as a key in an ordered map table or as an element in an ordered collection without specifying a comparer. It is strongly recommended (though not required) to make natural sorting consistent with equals. The so-called consistent with equals refers to each E1 and E2 of Class C , when and only if (E1.compareto (Object) e2 = = 0) with When E1.equals ((Object) E2) has the same Boolean value, the natural ordering of class C is called consistent with equals .

2. What method to implement

int CompareTo (T o) compares the order of this object with the specified object. If the object is less than, equal to, or greater than the specified object, it returns a negative integer, 0, or a positive integer, respectively.
It is highly recommended (X.compareto (y) ==0) = = (X.equals (y)) this practice, but not strictly required. In general, any implementation of comparable interfaces and classes that violate this condition should clearly state this fact. It is recommended that: "NOTE: This class has a natural sort that is inconsistent with equals. ”
Parameter:       O-The object to compare. Return:

        A negative integer, 0, or positive integer, depending on whether the object is less than, equal to, or greater than the specified object. Thrown:

        ClassCastException-If the type of the specified object does not allow it to be compared with this object.

3. Example

import java.util.*;

2. Public class employeesorttest {
6. /**
8. * @param args
10. */
12. Public Static void Main (string[] args) {
14. TODO auto-generated Method Stub
16. employee[] Staff = new employee[3];
18. staff[0] = new Employee ("Harry Hacker", 35000);
20. staff[1] = new Employee ("Carl Cracke", 75000);
22. staff[2] = new Employee ("Tony Tester", 38000);
26. Arrays.sort (staff); The Sort method enables you to sort an array of objects, but you must implement the comparable interface
28. The/*comparable interface prototype is:
30. * Public Interface Comparable<t>
32. * {
34. * int CompareTo (T other);//interface method automatically belongs to public method
36. * }
38. */
40. for (Employee E:staff)
42. System.out.println ("id=" +e.getid () + "Name=" +e.getname () +
44. ". salary=" +e.getsalary ());
46. }
50. }
52. /*
54. * Because you want to implement the sort of the employee object, you implement the comparable interface in the Employee class,
56. * I.E. to implement the Comepareto () method
58. */
60. class Employee implements comparable<employee>
62. {
64. Public Employee (String N, double s)
66. {
68. name = N;
70. Salary = s;
72. Random ID = new random ();
74. id = id.nextint (10000000);
76. }
78. Public int getId ()
80. {
82. return ID;
84. }
86. Public String GetName ()
88. {
90. return name;
92. }
96. Public double Getsalary ()
98. {
100. return salary;
102. }
106. Public void raisesalary ( double bypercent)
108. {
110. double raise = Salary *bypercent/100;
112. Salary+=raise;
114. }
118. Public int compareTo (Employee Other)
120. {
122. if (id<other.id)//What sort method is compared here to achieve is to follow this comparison of things from small to large arrangement
124. return -1;
126. if (id>other.id)
128. return 1;
130. return 0;
132. }
134. Private int ID;
136. Private String name;
138. Private Double salary;
140. }

4. The difference from comparator

Comparator is located under Package Java.util, and comparable is under package Java.lang, the comparable interface embeds the comparison code in its own class, while the latter implements comparisons in a separate class. If the designer of the class does not implement the comparable interface without taking into account the compare problem, it can be sorted by comparator to implement the comparison algorithm, and to prepare for the use of different sorting criteria, such as ascending and descending.

Let's look at a comparator example:

Import Java.util.TreeSet;
Import Java.util.Comparator;
Class Numcomparator implements Comparator<nametag> {
public intCompare(NameTag Left,nametag right) {
Return (Left.getnumber ()-right.getnumber ());
}
}
public class Collectionnine {
public static void Main (String arg[]) {
New Collectionnine ();
}
Collectionnine () {
Numcomparator Comparator = new Numcomparator ();
treeset<nametag> set = new treeset<nametag> (comparator);
Set.add (New NameTag ("Agamemnon", 300));
Set.add (New NameTag ("Cato", 400));
Set.add (New NameTag ("Plato", 100));
Set.add (New NameTag ("Zeno", 200));
Set.add (New NameTag ("Archimedes", 500));
for (NameTag Tag:set)
SYSTEM.OUT.PRINTLN (tag);
}
}

Ext.: http://www.cnblogs.com/gnuhpc/archive/2012/12/17/2822251.html

Implementation and use of the comparable interface