So verwenden Sie Comparable und Comparator, um Neuordnungen in Java zu entfernen

1. Sortieren und Deduplizieren

Bei der täglichen Arbeit gibt es immer einige Szenarien, die eine gewisse Filterung der Ergebnismenge erfordern. Beispielsweise muss der nach der Interaktion mit Dritten erhaltene Ergebnissatz erneut sortiert und dedupliziert werden. In diesem Fall wird der Ergebnissatz nach einem bestimmten Feld dedupliziert oder nach einem bestimmten Feld sortiert.

Wenn es in Java um Deduplizierung geht, können wir uns leicht die Eigenschaften von Set (ungeordnet, keine Duplizierung) vorstellen, und TreeSet (geordnet, keine Duplizierung) kann auch Deduplizierungsregeln (Deduplizierung) angeben last ist normalerweise die Ergebnismenge in aufsteigender Reihenfolge.

Wenn es um das Sortieren geht, können wir uns leicht verschiedene Sortieralgorithmen vorstellen, aber Java bietet bereits Sortierfunktionen, wie z. B. die Methode sort() in Sammlungen, und Sie können auch die Sortierfelder angeben und aufsteigend und absteigender Reihenfolge.

Lassen Sie mich hier noch etwas sagen, die Eigenschaften von Set (ungeordnet und ohne Gewicht):

• #🎜🎜 #Ungeordnet: Die Unordnung ist nicht zufällig, da die im Satz platzierten Elemente entsprechend dem Hashwert des Elements platziert werden Wenn es falsch ist und angenommen wird, dass die beiden Elemente nicht gleich sind, wird es hinzugefügt

# 🎜🎜# 2. Die Verwendung von Comparable und 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);
    }
}

In Bezug auf das Problem der aufsteigenden und absteigenden Sortierung sind die Rückgabewerte der Vergleichsmethoden in Comparable und Comparator werden ausgetauscht, wenn sie größer als 0 sind.

Wenn also die Parameterreihenfolge a, b ist:

Wenn a>b

, Das ist a-b>0, denn die Reihenfolge ist a, b, nach dem Austausch ist b vorne, a hinten, die Sortierreihenfolge ist

aufsteigende Reihenfolge

, was eine natürliche Sortierung ist ;

• # 🎜🎜#

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

  Wenn b>a, dann ist b-a>0, weil die Reihenfolge ist a, b, nach dem Austausch kommt b zuerst, a Danach Sortierreihenfolge

  absteigend
.

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

  3. Unterschied

  # 🎜 🎜#Comparable

Comparator

java.utilIst es eine funktionale Schnittstelle 🎜🎜#Das verglichene Objekt kann von Ihnen selbst geändert werdenDas verglichene Objekt kann nicht von Ihnen selbst geändert werden, oder das Objekt Die vergleichbare Schnittstelle ist implementiert, aber die Vergleichsregeln gelten nicht#🎜🎜 #

Owning package	java.lang# 🎜🎜#
Vergleichsmethode# ?? 🎜#

Das obige ist der detaillierte Inhalt vonSo verwenden Sie Comparable und Comparator, um Neuordnungen in Java zu entfernen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!