Comparable comparator
Comparable is located under the java.lang package. It is essentially an internal comparator. Classes that implement Comparable can themselves Comparison, as for the comparison result, it depends on the implementation of the natural comparison method compareTo.
The return values of compareTo are -1, 0, 1. If the comparator is greater than the compared object, 1 is returned, 0 is returned if it is equal, and -1 is returned if it is less than the compared object.
Collections.sort and Arrays.sort can automatically sort objects that implement Comparable.
Free online learning video recommendation: java learning
The example is as follows, we construct a node object and verify the usage of Comparable through comparison between node objects.
The implementation of the node object is as follows:
public class Node implements Comparable<Object>{
private int num;
private String name;
@Override
public String toString() {
return "num=" + num + " name=" + name;
}
public Node(int num, String name) {
super();
this.num = num;
this.name = name;
}
public Node() {
super();
}
public int getNum() {
return num;
}
public void setNum(int num) {
this.num = num;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public int compareTo(Object o) {
Node node = (Node)o;
return this.num - node.getNum();
}
}As you can see, we have implemented the Comparable interface for Node and overridden the compareTo method.
To test it first, we create 10 Node objects and add them to the List, and then shuffle the order.
public class MyTest {
public static void main(String[] args) {
List<Node> list = new ArrayList<Node>();
for(int i = 0;i < 10;i++) {
list.add(new Node(i,"node"));
}
//打乱顺序
Collections.shuffle(list);
for (Node node : list) {
System.out.println(node);
}
}
}The results are displayed as follows:
num=7 name=node num=0 name=node num=5 name=node num=9 name=node num=6 name=node num=3 name=node num=4 name=node num=8 name=node num=1 name=node num=2 name=node
Now the output is out of order, next we use Collections.sort to sort it.
public class MyTest {
public static void main(String[] args) {
List<Node> list = new ArrayList<Node>();
for(int i = 0;i < 10;i++) {
list.add(new Node(i,"node"));
}
//打乱顺序
Collections.shuffle(list);
Collections.sort(list);
for (Node node : list) {
System.out.println(node);
}
}
}Collections.sort actually compares according to the definition in the compareTo method. We previously defined sorting in ascending order of num. Now the sorting results are as follows:
num=0 name=node num=1 name=node num=2 name=node num=3 name=node num=4 name=node num=5 name=node num=6 name=node num=7 name=node num=8 name=node num=9 name=node
Comparator
Comparator is located under the java.util package and is essentially an external comparator. If a class does not implement Comparable internally or implements Comparable but the comparison method is not what you want, we can consider implementing Comparator. There is a compare method in the Comparator interface, and its usage is the same as compareTo in Comparable.
We need to pass the Comparator to the sorting method in order to control the sorting order. We can check the usage of several sorting methods and find that they can pass in a Comparator parameter.
Collections.sort(List<T> list, Comparator<? super T> c); Arrays.sort(T[] a, Comparator<? super T> c);
Modify our previous Node object and no longer implement Comparable.
public class Node{
private int num;
private String name;
@Override
public String toString() {
return "num=" + num + " name=" + name;
}
public Node(int num, String name) {
super();
this.num = num;
this.name = name;
}
public Node() {
super();
}
public int getNum() {
return num;
}
public void setNum(int num) {
this.num = num;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}We try to achieve descending sorting by passing in a Comparator.
public class MyTest {
public static void main(String[] args) {
List<Node> list = new ArrayList<Node>();
for(int i = 0;i < 10;i++) {
list.add(new Node(i,"node"));
}
//打乱顺序
Collections.shuffle(list);
Collections.sort(list, new Comparator<Node>() {
@Override
public int compare(Node o1, Node o2) {
return o2.getNum()-o1.getNum();
}
});
for (Node node : list) {
System.out.println(node);
}
}
}The results are as follows:
num=9 name=node num=8 name=node num=7 name=node num=6 name=node num=5 name=node num=4 name=node num=3 name=node num=2 name=node num=1 name=node num=0 name=node
Comparator implements reverse order comparison.
Summary
Comparable is an internal comparator, and Comparator is an external comparator. If the class does not implement the Comparable interface but needs to be sorted, we can consider using Comparator. From another perspective, the coupling of using the Comparable interface is greater than that of Comparator, because when we need to modify the comparison algorithm, we also need to modify the implementation class of Comparable.
This article comes from the java Quick Start column. Everyone is welcome to discuss and learn together!
The above is the detailed content of The difference between comparable and Comparator in java. For more information, please follow other related articles on the PHP Chinese website!