Implementation and use of the comparable Interface

1. What is the comparable interface?

This interface forcibly sorts the objects of each class. This sort is calledNatural sortingThe compareto method of the class is called itsNatural Comparison Method. Objects (and arrays) that implement this interface can be automatically sorted by collections. Sort (and arrays. 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 means that for every E1 and E2 in Class C, when and only when (e1.compareto (object) E2) = 0) and e1.equals (object) E2) when the same Boolean value exists, the natural sorting of class C is calledSame 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

ImportJava. util .*;

1. PublicClassEmployeesorttest {

2. 
   

3. /**

4. * @ Param ARGs

5. */

6. PublicStaticVoidMain (string [] ARGs ){

7. // Todo auto-generated method stub

8. Employee [] Staff =NewEmployee [3];

9. Staff [0] =NewEmployee ("Harry hacker", 35000 );

10. Staff [1] =NewEmployee ("Carl cracke", 75000 );

11. Staff [2] =NewEmployee ("Tony tester", 38000 );

12. 
    

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. }

24. 
    

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. ClassEmployeeImplementsComparable <employee>

31. {

32. PublicEmployee (string N,DoubleS)

33. {

34. Name = N;

35. Salary = s;

36. Random id =NewRandom ();

37. Id = ID. nextint (10000000 );

38. }

39. PublicIntGETID ()

40. {

41. ReturnID;

42. }

43. PublicString getname ()

44. {

45. ReturnName;

46. }

47. 
    

48. PublicDoubleGetsalary ()

49. {

50. ReturnSalary;

51. }

52. 
    

53. PublicVoidRaisesalary (DoubleBypercent)

54. {

55. DoubleRaise = salary * bypercent/100;

56. Salary + = raise;

57. }

58. 
    

59. PublicIntCompareto (employee other)

60. {

61. If(ID <other. ID) // What sort method is compared here to implement the arrangement based on the comparison items from small to large

62. Return-1;

63. If(ID> other. ID)

64. Return1;

65. Return0;

66. }

67. PrivateIntID;

68. PrivateString name;

69. PrivateDoubleSalary;

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 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 );
}
}

Implementation and use of the comparable Interface