Comment utiliser Comparable et Comparator en Java

Comparable et Comparator

Comparable et Comparator sont deux interfaces Java liées au tri, également connues sous le nom de tri naturel et de tri personnalisé. J'ai récemment lu du contenu pertinent et je vais maintenant enregistrer mon propre statut d'apprentissage ci-dessous.
Comparable et Comparator sont deux interfaces de tri, utilisées pour implémenter la fonction de tri dans les collections Java. Les fonctions spécifiques peuvent être obtenues à partir de l'API.

Comparable

Voici une brève introduction tirée de la documentation de l'API :

Cette interface impose un ordre total sur les objets de chaque classe qui l'implémente. Cet ordre est appelé ordre naturel de la classe, et la classe’ La méthode compareTo est appelée sa méthode de comparaison naturelle. Compare cet objet avec l'objet spécifié pour l'ordre. Renvoie un entier négatif, zéro ou un entier positif car cet objet est inférieur, égal ou supérieur à l'objet spécifié.

Utilisation :

Vous devez implémenter l'interface Comparable de la classe d'entité de tri et remplacer la méthode compareTo() pour avoir la fonction de tri. Certaines collections (telles que TreeSet) qui trient automatiquement les éléments appelleront automatiquement la méthode CompareTo() pour le tri lorsque des éléments sont placés dans la collection (à condition que les éléments doivent implémenter cette interface). Mais il peut également être utilisé dans d’autres endroits, et pas seulement dans TreeSet, il est largement utilisé.

Comparator

Voici une brève introduction tirée de la documentation de l'API :

Une fonction de comparaison, qui impose un ordre total sur certaines collections d'objets, peut être transmise à une méthode de tri (telle que Collections.sort ou Arrays). .sort) pour permettre un contrôle précis de l'ordre de tri. Les comparateurs peuvent également être utilisés pour contrôler l'ordre de certaines structures de données (telles que des ensembles triés ou des cartes triées), ou pour fournir un ordre pour des collections d'objets qui n'ont pas de tri. ordre naturel.

Utilisation :

Comparator est une interface tierce. L'utilisation spécifique est la suivante : concevoir un comparateur, créer une classe, implémenter cette interface et remplacer la méthode compare(). Et comme Comparator est une interface fonctionnelle, les expressions Lambda peuvent être utilisées à la place des objets Comparator, ce qui rend le code plus concis et plus clair.

Parler ne coûte pas cher, montre-moi le code.

Remarque : le contenu du blog peut ne pas être très détaillé, donc si vous voulez voir les détails spécifiques, vous devriez principalement lire des livres et des documents officiels. plus Présentez brièvement l'utilisation de base.

Classe d'entité de test : Chien

public class Dog implements Comparable<Dog>{
	private String name;
	private int age;
	
	public Dog(String name, int age) {
		this.name = name;
		this.age = age;
	}
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
	@Override
	public String toString() {
		return "Dog [name=" + name + ", age=" + age + "]";
	}

	@Override
	public int compareTo(Dog dog) {
		return this.age > dog.age ? 1 : this.age < dog.age ? -1 : 0;
	}
}

Classe d'entité de test : Chat

public class Cat implements Comparable<Cat>{
	private String name;
	private Integer age;
	
	public Cat(String name, Integer age) {
		this.name = name;
		this.age = age;
	}
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Integer getAge() {
		return age;
	}
	public void setAge(Integer age) {
		this.age = age;
	}
	
	@Override
	public String toString() {
		return "Cat [name=" + name + ", age=" + age + "]";
	}

	@Override
	public int compareTo(Cat o) {
		//可以直接调用，这样更简单
		//调换 o.age 和 this.age 就是相反的顺序
		return o.age.compareTo(this.age); 
	}
}

Classe de test : Test

public class Test {
	public static void main(String[] args) {
		List<Dog> dogs = new LinkedList<>();
		List<Cat> cats = new LinkedList<>();
		
		dogs.add(new Dog("大黄",6));
		dogs.add(new Dog("大白",1));
		dogs.add(new Dog("小黑",5));
		dogs.add(new Dog("旺财",3));
		dogs.add(new Dog("二哈",2));
		
		cats.add(new Cat("牛牛",3));
		cats.add(new Cat("花咪",4));
		cats.add(new Cat("咪咪",10));
		cats.add(new Cat("小黄",2));
		cats.add(new Cat("大橘",6));
		
		//参数为 null 使用 自然排序，否则使用 定制排序
		//也可以看出来 定制排序 优先级高于 自然排序
		System.out.println("---------自然排序 升序--------");
		dogs.sort(null);   
		dogs.forEach(System.out::println);
		System.out.println("---------自然排序 降序--------");
		cats.sort(null);
		cats.forEach(System.out::println);
		
		//定制排序
	    //Comparator<Dog> c = (e1,e2)->e2.getAge() - e1.getAge();
		//dogs.sort(c) 这个就是下面这个的具体形式，
		//可以看出来参数是一个 Comparator 对象  
		System.out.println("---------定制排序 降序--------");
		dogs.sort((e1,e2)->e2.getAge() - e1.getAge());
		//流式API的简单的应用，效果和上面的类似，或者直接使用 forEacn 循环遍历
		dogs.stream().forEach(System.out::println);
		System.out.println("---------定制排序 升序--------");
	//	另一种遍历方式，可以看出来函数式编程非常灵活，我也是初学，觉得很神奇。
		cats.stream()
		.sorted((e1,e2)->e1.getAge()-e2.getAge())
		.forEach(System.out::println);
	}
}

Capture d'écran en cours d'exécution : Instructions supplémentaires :

Méthode

Description dans la documentation de l'API :

Trie cette liste selon l'ordre induit par le comparateur spécifié.list.sort()Tous les éléments de cette liste doivent être mutuellement comparables à l'aide du comparateur spécifié (c.compare(e1, e2) ne doit pas lancez une ClassCastException pour tous les éléments e1 et e2 de la liste). Si le comparateur spécifié est nul, alors tous les éléments de cette liste doivent implémenter l'interface Comparable et l'ordre naturel des éléments doit être utilisé. Cette liste doit être modifiable, mais pas nécessairement. redimensionnable.

Vous pouvez voir que cette méthode trie un objet Comparator. Si le paramètre entrant est nul, le tri naturel sera effectué, mais notez : le principe du tri naturel est que la classe d'entité correspondante implémente l'interface Comparable, et a remplacé la méthode compareTo().

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!