Comment utiliser Comparable et Comparator pour supprimer la réorganisation en Java

1. Tri et déduplication

Dans le travail quotidien, il existe toujours certains scénarios qui nécessitent un certain filtrage de l'ensemble de résultats. Par exemple, l'ensemble de résultats obtenu après avoir interagi avec un tiers doit être à nouveau trié et dédupliqué. Dans ce cas, l'ensemble de résultats sera dédupliqué en fonction d'un certain champ, ou trié par un certain champ.

En Java, lorsqu'il s'agit de déduplication, on peut facilement penser aux caractéristiques de Set (non ordonné, pas de duplication), et TreeSet (ordonné, pas de duplication) peut également spécifier les règles de déduplication (les résultats après déduplication sont généralement en ordre croissant) défini).

En matière de tri, nous pouvons facilement penser à divers algorithmes de tri, mais Java fournit déjà des fonctions de tri, telles que la méthode sort() dans les collections, et vous pouvez également spécifier les champs de tri et l'ordre croissant et décroissant.

Permettez-moi de dire encore une chose ici, les caractéristiques de Set (pas d'ordre et pas de duplication) :

• Désordre : le désordre n'est pas aléatoire, car les éléments placés dans l'ensemble seront déterminés en fonction de la valeur de hachage de l'élément La position placée

• est en apesanteur : lors de l'ajout d'un élément, elle sera jugée selon la fonction equals() de l'élément. Si false est considéré comme deux éléments qui ne sont pas égaux, il sera ajouté

  .

2. L'utilisation de Comparable et Comparator

public class CompareTest {

    public static void main(String[] args) {
        // 例如：从第三方返回的结果集
        // 根据id去重，根据createTime降序排列
        String result = "["
                + "{ \"id\": 1, \"createTime\": \"2022-12-21 13:23:59\"}"
                + "{ \"id\": 2, \"createTime\": \"2022-11-11 12:43:01\"}"
                + "{ \"id\": 1, \"createTime\": \"2022-12-21 11:20:50\"}"
                + "{ \"id\": 3, \"createTime\": \"2023-01-01 14:30:00\"}"
                + "]";
        JSONArray examList = JSONArray.parseArray(result);
        System.out.println("初始数据集：" + examList);

        // 去重，利用set特性
        Comparator<JSONObject> comparator = (a, b) -> Integer.compare(a.getIntValue("id"), b.getIntValue("id"));
        Set<JSONObject> set = new TreeSet<>(comparator);
        examList.forEach(jo -> set.add((JSONObject) jo));
        // 此时的结果是，根据id去重，并且是升序的结果（自然排序）
        System.out.println("去重结果：" + set);

        // 此处为了，方便演示Comparable接口的作用，故把JSON映射成实体类，进行实现接口排序，其实sorted也可以使用Comparator排序
        List<ExamInfo> collect = set.stream()
                .map(jo -> JSONObject.toJavaObject(jo, ExamInfo.class))
                .sorted()
                .collect(Collectors.toList());
        System.out.println("指定排序结果：" + collect);
    }

}

public class ExamInfo implements Comparable<ExamInfo> {

    private int id;
    private String createTime;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getCreateTime() {
        return createTime;
    }

    public void setCreateTime(String createTime) {
        this.createTime = createTime;
    }

    @Override
    public String toString() {
        return "ExamInfo{" +
                "id=" + id +
                ", createTime=&#39;" + createTime + &#39;\&#39;&#39; +
                &#39;}&#39;;
    }

    @Override
    public int compareTo(ExamInfo o) {
        // 降序
        return o.getCreateTime().compareTo(this.createTime);
    }
}

Concernant la question du tri croissant et décroissant, les valeurs de retour des méthodes de comparaison dans Comparable et Comparator sont échangées si elles sont supérieures à 0.

Donc, lorsque l'ordre des paramètres est a,b :

• Si a>b, c'est-à-dire a-b>0, parce que l'ordre est a,b, après échange, b est devant, a est dans au verso, l'ordre de tri Ordre croissant, qui est un tri naturel

 // 升序
 Comparator<JSONObject> comparator = (a, b) -> Integer.compare(a.getIntValue("id"), b.getIntValue("id"));

• Si b>a, c'est-à-dire b-a>0, car l'ordre est a, b, après échange, b est devant, a est derrière, l'ordre de tri Ordre décroissant.

 	@Override
 	public int compareTo(ExamInfo o) {
        // 降序
        return o.getCreateTime().compareTo(this.createTime);
    }

3. Différence

	Comparable	Comparateur
Le package	java.lang	java.util
Est-ce une interface fonctionnelle	Oui	est la
méthode de comparaison	int compareTo(T o)	int compare(T o1, T o2)
Scénario d'utilisation	L'objet de comparaison, vous pouvez modifier l'objet de comparaison	, Vous ne pouvez pas le modifier vous-même, ou l'objet implémente l'interface Comparable, mais les règles de comparaison ne s'appliquent pas

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!