使用 Java Comparator 实现复杂排序逻辑

摘要：本文介绍了如何使用 Java Comparator 对 Actor 列表进行排序，其中 Actor 具有类型（如 "Artist"、"Producer"、"Mixer" 等）和名称。排序规则是：首先按照类型优先级排序（"Artist" 最优先，然后是 "Producer"，接着是 "Mixer"），其次按照 Actor 名称的字母顺序排序。文章提供了两种实现方式：使用枚举类型定义类型优先级和使用 Map 存储类型优先级，并分析了各自的优缺点。

在 Java 开发中，经常需要对集合进行排序。Comparator 接口提供了一种灵活的方式来定义自定义排序规则。当排序逻辑比较复杂，例如需要考虑多个排序条件时，就需要巧妙地使用 Comparator。本文将介绍如何使用 Comparator 对 Actor 列表进行排序，该列表需要按照 Actor 类型（如 "Artist"、"Producer"、"Mixer" 等）的优先级以及 Actor 名称进行排序。

方案一：使用枚举类型定义类型优先级

如果 Actor 的类型是固定的，并且可以预先定义，那么使用枚举类型来表示 Actor 类型并定义其优先级是一种非常清晰和类型安全的方式。

首先，定义一个 ActorType 枚举，其中包含每个 Actor 类型的优先级：

public enum ActorType {

  ARTIST(1),
  PRODUCER(2),
  MIXER(3);

  private final int priority;

  ActorType(int priority) {
    this.priority = priority;
  }

  public int getPriority() {
    return priority;
  }

  public static int compare(ActorType t1, ActorType t2) {
    return Integer.compare(t1.priority, t2.priority);
  }
}

在这个枚举中，每个 Actor 类型都有一个关联的优先级。compare 方法用于比较两个 ActorType 对象的优先级。

然后，创建一个 Actor 类，其中包含 ActorType 属性：

public class Actor {
    private String name;
    private ActorType actorType;

    public Actor(String name, ActorType actorType) {
        this.name = name;
        this.actorType = actorType;
    }

    public String getName() {
        return name;
    }

    public ActorType getActorType() {
        return actorType;
    }
}

接下来，创建一个 Comparator 来比较两个 Actor 对象：

import java.util.Comparator;

public class ActorByActorTypeComparator implements Comparator {

  @Override
  public int compare(Actor actor1, Actor actor2) {
    int typeComparison = ActorType.compare(actor1.getActorType(), actor2.getActorType());
    if (typeComparison != 0) {
      return typeComparison;
    }
    return actor1.getName().compareTo(actor2.getName()); // 按照名字排序
  }
}

这个 Comparator 首先比较两个 Actor 的类型优先级。如果类型优先级不同，则返回比较结果。如果类型优先级相同，则按照 Actor 的名称进行比较。

示例代码：

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List actors = new ArrayList<>();
        actors.add(new Actor("Bob", ActorType.PRODUCER));
        actors.add(new Actor("Alice", ActorType.ARTIST));
        actors.add(new Actor("Charlie", ActorType.MIXER));
        actors.add(new Actor("David", ActorType.ARTIST));

        Collections.sort(actors, new ActorByActorTypeComparator());

        for (Actor actor : actors) {
            System.out.println(actor.getName() + " - " + actor.getActorType());
        }
    }
}

输出结果：

Alice - ARTIST
David - ARTIST
Bob - PRODUCER
Charlie - MIXER

方案二：使用 Map 存储类型优先级

如果 Actor 的类型是字符串，或者不能使用枚举类型，那么可以使用 Map 来存储每个类型的优先级。

import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;

public class ActorByTypeComparator implements Comparator {

  private final Map typePriorityMap = new HashMap<>();

  public ActorByTypeComparator(Map typePriorityMap) {
        this.typePriorityMap.putAll(typePriorityMap);
  }


  @Override
  public int compare(Actor a1, Actor a2) {
    int a1Priority = this.typePriorityMap.getOrDefault(a1.getType(), Integer.MAX_VALUE);
    int a2Priority = this.typePriorityMap.getOrDefault(a2.getType(), Integer.MAX_VALUE);
    int priorityComparison = Integer.compare(a1Priority, a2Priority);

    if (priorityComparison != 0) {
        return priorityComparison;
    }
    return a1.getName().compareTo(a2.getName()); // 按照名字排序
  }
}

在这个 Comparator 中，typePriorityMap 存储了每个 Actor 类型的优先级。getOrDefault 方法用于获取 Actor 类型的优先级，如果类型不存在于 Map 中，则返回 Integer.MAX_VALUE，表示优先级最低。同样，在优先级相同的情况下，按照Actor名字进行排序。

示例代码：

import java.util.ArrayList;
import java
.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        List actors = new ArrayList<>();
        actors.add(new Actor("Bob", "Producer"));
        actors.add(new Actor("Alice", "Artist"));
        actors.add(new Actor("Charlie", "Mixer"));
        actors.add(new Actor("David", "Artist"));

        Map priorityMap = new HashMap<>();
        priorityMap.put("Artist", 1);
        priorityMap.put("Producer", 2);
        priorityMap.put("Mixer", 3);

        Collections.sort(actors, new ActorByTypeComparator(priorityMap));

        for (Actor actor : actors) {
            System.out.println(actor.getName() + " - " + actor.getType());
        }
    }

    static class Actor {
        private String name;
        private String type;

        public Actor(String name, String type) {
            this.name = name;
            this.type = type;
        }

        public String getName() {
            return name;
        }

        public String getType() {
            return type;
        }
    }
}

输出结果：

Alice - ARTIST
David - ARTIST
Bob - PRODUCER
Charlie - MIXER

总结

本文介绍了两种使用 Comparator 实现复杂排序逻辑的方法。

• 使用枚举类型： 适用于 Actor 类型固定的情况，代码清晰，类型安全。
• 使用 Map： 适用于 Actor 类型不固定，或者不能使用枚举类型的情况，更加灵活。

在实际开发中，应根据具体情况选择合适的方案。使用 Comparator 可以灵活地定义排序规则，使得代码更加简洁易懂。需要注意的是，在比较多个条件时，需要按照优先级顺序进行比较。如果优先级高的条件比较结果相同，则继续比较优先级低的条件。