Java中复杂排序逻辑的实现：多条件Comparator设计指南

public class Actor {
    private String name;
    private String type; // 例如 "Artist", "Producer", "Mixer", "Director"

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

    public String getName() {
        return name;
    }

    public String getType() {
        return type;
    }

    @Override
    public String toString() {
        return "Actor{" +
               "name='" + name + '\'' +
               ", type='" + type + '\'' +
               '}';
    }
}

public enum ActorType {
    ARTIST(1),
    PRODUCER(2),
    MIXER(3),
    // 对于其他未明确指定优先级的类型，可以赋予一个较大的默认值，
    // 或者根据实际需求，让它们在特定类型之后按字母顺序排列。
    // 这里为了演示，我们假设所有其他类型都有一个更高的默认优先级值
    OTHER(Integer.MAX_VALUE); 

    private final int priority;

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

    public int getPriority() {
        return priority;
    }

    // 提供一个静态方法，用于根据字符串类型获取对应的枚举或默认值
    public static ActorType fromString(String typeName) {
        for (ActorType type : ActorType.values()) {
            if (type.name().equalsIgnoreCase(typeName)) {
                return type;
            }
        }
        return OTHER; // 如果未找到匹配的枚举，返回OTHER
    }

    // 比较两个ActorType的优先级
    public static int compare(ActorType t1, ActorType t2) {
        return Integer.compare(t1.priority, t2.priority);
    }
}

import java.util.Comparator;

public class ActorByTypePriorityComparator implements Comparator<Actor> {

    @Override
    public int compare(Actor actor1, Actor actor2) {
        ActorType type1 = ActorType.fromString(actor1.getType());
        ActorType type2 = ActorType.fromString(actor2.getType());
        return ActorType.compare(type1, type2);
    }
}

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

public class ActorByStringPriorityComparator implements Comparator<Actor> {

    private final Map<String, Integer> typePriorityMap;

    public ActorByStringPriorityComparator() {
        // 默认构造器，可以预设优先级
        this.typePriorityMap = new HashMap<>();
        typePriorityMap.put("Artist", 1);
        typePriorityMap.put("Producer", 2);
        typePriorityMap.put("Mixer", 3);
        // 其他类型将获得默认的Integer.MAX_VALUE优先级
    }

    public ActorByStringPriorityComparator(Map<String, Integer> customPriorityMap) {
        // 允许通过构造器注入自定义优先级Map
        this.typePriorityMap = new HashMap<>(customPriorityMap);
    }

    @Override
    public int compare(Actor a1, Actor a2) {
        // 使用getOrDefault处理未知类型，赋予其一个较低的优先级
        int a1Priority = this.typePriorityMap.getOrDefault(a1.getType(), Integer.MAX_VALUE);
        int a2Priority = this.typePriorityMap.getOrDefault(a2.getType(), Integer.MAX_VALUE);
        return Integer.compare(a1Priority, a2Priority);
    }
}

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

public class ActorSorter {

    public static void main(String[] args) {
        List<Actor> actors = new ArrayList<>();
        actors.add(new Actor("Alice", "Producer"));
        actors.add(new Actor("Bob", "Artist"));
        actors.add(new Actor("Charlie", "Mixer"));
        actors.add(new Actor("David", "Artist"));
        actors.add(new Actor("Eve", "Director")); // 未在优先级列表中的类型
        actors.add(new Actor("Frank", "Producer"));
        actors.add(new Actor("Grace", "Mixer"));
        actors.add(new Actor("Heidi", "Director"));

        System.out.println("原始列表:");
        actors.forEach(System.out::println);

        // 1. 使用枚举方式组合Comparator
        Comparator<Actor> typePriorityComparatorEnum = new ActorByTypePriorityComparator();
        Comparator<Actor> nameComparator = Comparator.comparing(Actor::getName);

        Comparator<Actor> finalComparatorEnum = typePriorityComparatorEnum.thenComparing(nameComparator);

        Collections.sort(actors, finalComparatorEnum);

        System.out.println("\n按枚举优先级和姓名排序后的列表:");
        actors.forEach(System.out::println);

        // 重置列表以便演示Map方式
        actors.clear();
        actors.add(new Actor("Alice", "Producer"));
        actors.add(new Actor("Bob", "Artist"));
        actors.add(new Actor("Charlie", "Mixer"));
        actors.add(new Actor("David", "Artist"));
        actors.add(new Actor("Eve", "Director"));
        actors.add(new Actor("Frank", "Producer"));
        actors.add(new Actor("Grace", "Mixer"));
        actors.add(new Actor("Heidi", "Director"));

        // 2. 使用Map方式组合Comparator
        // 假设我们有一个自定义的优先级Map
        Map<String, Integer> customPriorities = new HashMap<>();
        customPriorities.put("Artist", 1);
        customPriorities.put("Producer", 2);
        customPriorities.put("Mixer", 3);

        Comparator<Actor> typePriorityComparatorMap = new ActorByStringPriorityComparator(customPriorities);

        Comparator<Actor> finalComparatorMap = typePriorityComparatorMap.thenComparing(nameComparator);

        Collections.sort(actors, finalComparatorMap);

        System.out.println("\n按Map优先级和姓名排序后的列表:");
        actors.forEach(System.out::println);
    }
}

原始列表:
Actor{name='Alice', type='Producer'}
Actor{name='Bob', type='Artist'}
Actor{name='Charlie', type='Mixer'}
Actor{name='David', type='Artist'}
Actor{name='Eve', type='Director'}
Actor{name='Frank', type='Producer'}
Actor{name='Grace', type='Mixer'}
Actor{name='Heidi', type='Director'}

按枚举优先级和姓名排序后的列表:
Actor{name='Bob', type='Artist'}
Actor{name='David', type='Artist'}
Actor{name='Alice', type='Producer'}
Actor{name='Frank', type='Producer'}
Actor{name='Charlie', type='Mixer'}
Actor{name='Grace', type='Mixer'}
Actor{name='Eve', type='Director'}
Actor{name='Heidi', type='Director'}

按Map优先级和姓名排序后的列表:
Actor{name='Bob', type='Artist'}
Actor{name='David', type='Artist'}
Actor{name='Alice', type='Producer'}
Actor{name='Frank', type='Producer'}
Actor{name='Charlie', type='Mixer'}
Actor{name='Grace', type='Mixer'}
Actor{name='Eve', type='Director'}
Actor{name='Heidi', type='Director'}