Comparable interface implementation and usage introduction, comparable Interface

Comparable interface implementation and usage introduction, comparable Interface

1. What is the Comparable interface?

This interface forcibly sorts the objects of each class. This sort is called the natural sorting of the classCompareToMethod is called its natural comparison method. You can useCollections. sort(AndArrays. sort. Objects that implement this interface can be used as keys in an ordered ing table or elements in an ordered set without specifying a comparator. It is strongly recommended (though not required) to make the natural order consistent with equals. The same as equals indicates thatCEveryE1AndE2For example(E1.compareTo (Object) e2) = 0)AndE1.equals (Object) e2)Class with the same Boolean ValueCThe natural sorting of is called the same as equals.

2. Implementation Method

Int compareTo (T o) compares the order of the object with the specified object. If the object is smaller than, equal to, or greater than the specified object, a negative integer, zero, or positive integer is returned.
We strongly recommend (x. compareTo (y) = 0) = (x. equals (y), but not strictly. In general, any class that implements the Comparable interface and violates this condition should clearly point out this fact. We recommend that you elaborate: "NOTE: This class has a natural sorting that is inconsistent with equals ."
Parameter: the object to be compared. Return Value:

Negative integer, zero, or positive integer, based on whether the object is smaller than, equal to, or greater than the specified object. Throw:

ClassCastException-if the specified object type cannot be compared with this object.

3. Instance

Import java. util .*;

1. Public class EmployeeSortTest {
3. /**
4. * @ Param args
5. */
6. Public static void main (String [] args ){
7. // TODO Auto-generated method stub
8. Employee [] staff = new Employee [3];
9. Staff [0] = new Employee ("harry Hacker", 35000 );
10. Staff [1] = new Employee ("carl cracke", 75000 );
11. Staff [2] = new Employee ("tony Tester", 38000 );
13. Arrays. sort (staff); // The sort method can sort object Arrays, but the Comparable interface must be implemented.
14. /* The Comparable interface is prototype:
15. * Public interface Comparable <T>
16. *{
17. * Int compareTo (T other); // The method in the interface automatically belongs to the public method.
18. *}
19. */
20. For (Employee e: staff)
21. System. out. println ("id =" + e. getId () + "name =" + e. getName () +
22. ". Salary =" + e. getSalary ());
23. }
25. }
26. /*
27. * To sort the Employee objects, you must implement the Comparable interface in the Employee class,
28. * That is, to implement the comepareTo () method
29. */
30. Class Employee implements Comparable <Employee>
31. {
32. Public Employee (String n, double s)
33. {
34. Name = n;
35. Salary = s;
36. Random ID = new Random ();
37. Id = ID. nextInt (10000000 );
38. }
39. Public int getId ()
40. {
41. Return id;
42. }
43. Public String getName ()
44. {
45. Return name;
46. }
48. Public double getSalary ()
49. {
50. Return salary;
51. }
53. Public void raiseSalary (double byPercent)
54. {
55. Double raise = salary * byPercent/100;
56. Salary + = raise;
57. }
59. Public int compareTo (Employee other)
60. {
61. If (id <other. id) // What is the sort method compared here? The sort method is implemented according to the comparison items in ascending order.
62. Return-1;
63. If (id> other. id)
64. Return 1;
65. Return 0;
66. }
67. Private int id;
68. Private String name;
69. Private double salary;
70. }

4. Differences from Comparator

Comparator is located under the java. util package, while Comparable is located under the java. lang package. The Comparable interface embeds the comparison code into its own class, while the latter implements comparison in an independent class. If the class designer does not implement the Comparable interface because of the Compare problem, you can use the Comparator to sort the comparison algorithm and prepare for using different Sorting Standards. For example: in ascending or descending order.

Let's look at a Comparator example:

Import java. util. TreeSet;
Import java. util. Comparator;
Class NumComparator implements Comparator <NameTag> {
Public int compare (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 );
}
}