La différence entre comparable et Comparator en Java

Comparateur Comparable

Comparable se trouve sous le package java.lang. Il s'agit essentiellement d'un comparateur interne qui implémente Comparable peut lui-même comparer. , quant au résultat de la comparaison, il dépend de la mise en œuvre de la méthode de comparaison naturelle compareTo.

Les valeurs de retour de compareTo sont -1, 0, 1. Si le comparateur est supérieur à l'objet comparé, 1 est renvoyé, 0 est renvoyé s'il est égal et -1 est renvoyé s'il est inférieur à l'objet comparé.

Collections.sort et Arrays.sort peuvent trier automatiquement les objets qui implémentent Comparable.

Recommandation de vidéo d'apprentissage en ligne gratuite : apprentissage Java

L'exemple est le suivant, nous construisons un objet nœud et vérifions l'utilisation de Comparable via une comparaison entre les objets nœuds.

L'implémentation de l'objet node est la suivante :

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

Comme vous pouvez le voir, nous avons implémenté l'interface Comparable pour Node et remplacé la méthode compareTo.

Pour le tester d'abord, nous créons 10 objets Node et les ajoutons à la liste, puis mélangeons l'ordre.

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

Le résultat s'affiche comme suit :

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

Maintenant, la sortie est dans le désordre, nous utilisons ensuite Collections.sort pour la trier.

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 compare en fait selon la définition de la méthode compareTo Nous avons précédemment défini le tri par ordre croissant de nombre. Maintenant, les résultats du tri sont les suivants :

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

Comparateur.

Comparator est situé sous le package java.util et est essentiellement un comparateur externe. Si une classe n’implémente pas Comparable en interne ou implémente Comparable mais que la méthode de comparaison ne vous convient pas, nous pouvons envisager d’implémenter Comparator. Il existe une méthode de comparaison dans l'interface Comparator et la méthode d'utilisation est la même que compareTo dans Comparable.

Nous devons passer un Comparator à la méthode de tri afin de contrôler l'ordre de tri. Nous pouvons vérifier l'utilisation de plusieurs méthodes de tri et constater qu'elles peuvent transmettre un paramètre Comparator.

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

Modifiez notre précédent objet Node et n'implémentez plus 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;
	}
	
}

On essaye de trier par ordre décroissant en passant dans un 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);
		}
	}
}

Les résultats sont les suivants :

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 implémente la comparaison par ordre inverse.

Résumé

Comparable est un comparateur interne, et Comparator est un comparateur externe. Si la classe n'implémente pas l'interface Comparable mais doit être triée, nous pouvons envisager. en utilisant le comparateur. D'un autre point de vue, le couplage de l'utilisation de l'interface Comparable est supérieur à celui de Comparator, car lorsque nous devons modifier l'algorithme de comparaison, nous devons également modifier la classe d'implémentation de Comparable.

Cet article est issu de la rubrique Java Quick Start Tout le monde est invité à discuter et à apprendre ensemble !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!