Der Unterschied zwischen vergleichbar und Komparator in Java

Comparable Comparator

Comparable befindet sich im java.lang-Paket. Es handelt sich im Wesentlichen um einen internen Comparator, der Comparable selbst implementiert Das Vergleichsergebnis hängt von der Implementierung der natürlichen Vergleichsmethode „compareTo“ ab.

Die Rückgabewerte von CompareTo sind -1, 0, 1. Wenn der Komparator größer als das verglichene Objekt ist, wird 1 zurückgegeben, 0 wird zurückgegeben, wenn er gleich ist, und -1 wird zurückgegeben, wenn er kleiner als das verglichene Objekt ist.

Collections.sort und Arrays.sort können automatisch Objekte sortieren, die Comparable implementieren.

Kostenlose Online-Lernvideoempfehlung: Java-Lernen

Das Beispiel sieht wie folgt aus: Wir erstellen ein Knotenobjekt und überprüfen die Verwendung von Comparable durch Vergleich zwischen Knotenobjekten.

Die Implementierung des Node-Objekts ist wie folgt:

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

Wie Sie sehen können, haben wir die Comparable-Schnittstelle für Node implementiert und die CompareTo-Methode überschrieben.

Um es zunächst zu testen, erstellen wir 10 Knotenobjekte, fügen sie der Liste hinzu und ändern dann die Reihenfolge.

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

Das Ergebnis wird wie folgt angezeigt:

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

Jetzt ist die Ausgabe nicht in Ordnung, als nächstes verwenden wir Collections.sort, um sie zu sortieren.

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 vergleicht tatsächlich gemäß der Definition in der CompareTo-Methode. Wir haben zuvor die Sortierung in aufsteigender Reihenfolge der Anzahl definiert. Jetzt sind die Sortierergebnisse wie folgt:

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 befindet sich im Paket java.util und ist im Wesentlichen ein externer Komparator. Wenn eine Klasse Comparable nicht intern implementiert oder Comparable implementiert, die Vergleichsmethode jedoch nicht Ihren Wünschen entspricht, können wir die Implementierung von Comparator in Betracht ziehen. In der Comparator-Schnittstelle gibt es eine Vergleichsmethode, deren Verwendung mit der von CompareTo in Comparable identisch ist.

Wir müssen einen Komparator an die Sortiermethode übergeben, um die Sortierreihenfolge zu steuern. Wir können die Verwendung mehrerer Sortiermethoden überprüfen und feststellen, dass sie einen Comparator-Parameter übergeben können.

Collections.sort(List<T> list, Comparator<? super T> c);
Arrays.sort(T[] a, Comparator<? super T> c);

Ändern Sie unser vorheriges Node-Objekt und implementieren Sie Comparable nicht mehr.

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

Wir versuchen, in absteigender Reihenfolge zu sortieren, indem wir einen Komparator übergeben.

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

Die Ergebnisse sind wie folgt:

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 implementiert den Vergleich in umgekehrter Reihenfolge.

Zusammenfassung

Comparable ist ein interner Komparator und Comparator ist ein externer Komparator. Wenn die Klasse die Comparable-Schnittstelle nicht implementiert, aber sortiert werden muss, können wir darüber nachdenken mit Komparator. Aus einer anderen Perspektive ist die Kopplung bei der Verwendung der Comparable-Schnittstelle größer als die von Comparator, denn wenn wir den Vergleichsalgorithmus ändern müssen, müssen wir auch die Implementierungsklasse von Comparable ändern.

Dieser Artikel stammt aus der Kolumne Java Quick Start Jeder ist willkommen, gemeinsam zu diskutieren und zu lernen!

Das obige ist der detaillierte Inhalt vonDer Unterschied zwischen vergleichbar und Komparator in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!