Java复杂多条件排序：类型优先级与字母顺序组合实现

复杂多条件排序的需求分析

在实际开发中，我们经常需要对对象列表进行排序，而排序规则往往不止一个。例如，假设我们有一个actor（演员）列表，每个actor对象包含一个类型（如“artist”、“producer”、“mixer”等）和一个名称。现在，我们需要按照以下规则对列表进行排序：

1. 类型为“Artist”的演员排在最前面。
2. 类型为“Producer”的演员紧随其后。
3. 类型为“Mixer”的演员再次之。
4. 对于相同类型的演员，按照其名称的字母顺序进行排序。

这种需求要求我们首先根据自定义的类型优先级进行排序，然后在优先级相同的情况下，再根据另一个属性（名称）进行排序。

解决方案一：使用枚举定义类型优先级（推荐）

当类型集合是固定且已知时，使用枚举（Enum）来定义类型及其对应的优先级是一种非常清晰和健壮的方法。

1. 定义ActorType枚举

我们可以为每种演员类型分配一个优先级数值，数值越小代表优先级越高。

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;
    }

    /**
     * 比较两个ActorType的优先级
     * @param t1 类型1
     * @param t2 类型2
     * @return 比较结果
     */
    public static int compare(ActorType t1, ActorType t2) {
        return Integer.compare(t1.priority, t2.priority);
    }
}

2. 定义Actor类

为了演示，我们假设Actor类如下：

立即学习“Java免费学习笔记（深入）”；

public class Actor {
    private String name;
    private ActorType type; // 使用枚举类型

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

    public String getName() {
        return name;
    }

    public ActorType getType() {
        return type;
    }

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

3. 实现类型优先级Comparator

现在，我们可以创建一个Comparator来比较Actor对象的类型优先级。

import java.util.Comparator;

public class ActorByTypePriorityComparator implements Comparator {
    @Override
    public int compare(Actor actor1, Actor actor2) {
        return ActorType.compare(actor1.getType(), actor2.getType());
    }
}

4. 组合排序规则

Java 8 引入的 Comparator 接口提供了强大的链式方法，特别是 thenComparing()，可以非常优雅地组合多个排序规则。

Thiings

免费的拟物化图标库

下载

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

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

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

        // 创建组合Comparator
        Comparator combinedComparator = Comparator
                .comparing(Actor::getType, (t1, t2) -> ActorType.compare(t1, t2)) // 首先按类型优先级排序
                .thenComparing(Actor::getName); // 然后按名称字母顺序排序

        // 或者更简洁地利用ActorType的getPriority方法
        // Comparator combinedComparator = Comparator
        //         .comparingInt(actor -> actor.getType().getPriority()) // 首先按类型优先级排序
        //         .thenComparing(Actor::getName); // 然后按名称字母顺序排序


        Collections.sort(actors, combinedComparator);

        System.out.println("\n排序后列表:");
        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=PRODUCER}
Actor{name='Frank', type=OTHER}
Actor{name='Grace', type=MIXER}

排序后列表:
Actor{name='Bob', type=ARTIST}
Actor{name='David', type=ARTIST}
Actor{name='Alice', type=PRODUCER}
Actor{name='Eve', type=PRODUCER}
Actor{name='Charlie', type=MIXER}
Actor{name='Grace', type=MIXER}
Actor{name='Frank', type=OTHER}

解决方案二：使用Map定义类型优先级（适用于类型动态或不可修改的情况）

如果演员类型是字符串，并且由于某种原因（例如，类型是动态从外部配置加载的，或者不能修改现有Actor类以使用枚举），无法将其改为枚举类型，那么可以使用 Map 来存储类型及其优先级。

1. 定义Actor类（使用String类型）

public class Actor {
    private String name;
    private String type; // 使用String类型

    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 + '\'' +
               '}';
    }
}

2. 实现基于Map的类型优先级Comparator

这个Comparator需要一个Map来存储每种字符串类型对应的优先级。

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

public class ActorByTypeStringPriorityComparator implements Comparator {

    private final Map typePriorityMap;

    public ActorByTypeStringPriorityComparator() {
        this.typePriorityMap = new HashMap<>();
        // 初始化优先级映射
        typePriorityMap.put("Artist", 1);
        typePriorityMap.put("Producer", 2);
        typePriorityMap.put("Mixer", 3);
        // 对于未定义的类型，可以赋予一个较低的优先级
        // 例如，Integer.MAX_VALUE，使其排在最后
    }

    // 也可以通过构造函数传入优先级Map，使其更灵活
    public ActorByTypeStringPriorityComparator(Map customPriorityMap) {
        this.typePriorityMap = new HashMap<>(customPriorityMap);
    }

    @Override
    public int compare(Actor a1, Actor a2) {
        // 获取a1的优先级，如果类型未定义，则赋予一个默认的低优先级
        int a1Priority = this.typePriorityMap.getOrDefault(a1.getType(), Integer.MAX_VALUE);
        // 获取a2的优先级
        int a2Priority = this.typePriorityMap.getOrDefault(a2.getType(), Integer.MAX_VALUE);

        return Integer.compare(a1Priority, a2Priority);
    }
}

3. 组合排序规则

与枚举方案类似，使用 thenComparing() 方法组合排序规则。

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

public class SortingExampleWithStringTypes {
    public static void main(String[] args) {
        List 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", "Producer"));
        actors.add(new Actor("Frank", "Other")); // 未在Map中定义的类型
        actors.add(new Actor("Grace", "Mixer"));

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

        // 创建类型优先级Comparator
        ActorByTypeStringPriorityComparator typeComparator = new ActorByTypeStringPriorityComparator();

        // 创建组合Comparator
        Comparator combinedComparator = typeComparator
                .thenComparing(Actor::getName); // 然后按名称字母顺序排序

        Collections.sort(actors, combinedComparator);

        System.out.println("\n排序后列表:");
        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='Producer'}
Actor{name='Frank', type='Other'}
Actor{name='Grace', type='Mixer'}

排序后列表:
Actor{name='Bob', type='Artist'}
Actor{name='David', type='Artist'}
Actor{name='Alice', type='Producer'}
Actor{name='Eve', type='Producer'}
Actor{name='Charlie', type='Mixer'}
Actor{name='Grace', type='Mixer'}
Actor{name='Frank', type='Other'}

注意事项与最佳实践

1. 枚举 vs. Map:
   • 枚举方案：推荐用于类型固定且数量有限的情况。它提供了类型安全，代码更清晰，不易出错，且性能略优。
   • Map方案：适用于类型动态、从外部配置加载或无法修改现有类的情况。它更灵活，但需要额外处理未定义类型（如使用getOrDefault）和潜在的拼写错误问题。
2. 处理未定义类型: 在Map方案中，务必考虑如何处理在typePriorityMap中不存在的类型。通常，可以赋予一个默认的最高或最低优先级（例如Integer.MIN_VALUE或Integer.MAX_VALUE），以确保这些类型也能被正确排序。
3. 链式比较的顺序: Comparator.thenComparing() 的调用顺序至关重要。它表示“如果前一个比较器认为两个对象相等，则使用下一个比较器进行比较”。因此，主排序规则（如类型优先级）应放在前面，次级规则（如名称字母顺序）放在后面。
4. 可读性与维护性: 优先选择代码可读性高、易于维护的方案。枚举方案通常在这方面表现更好。
5. Null值处理: 如果Actor的name或type字段可能为null，Comparator需要额外处理null值，例如使用Comparator.nullsFirst()或Comparator.nullsLast()。

总结

本文详细介绍了在Java中实现复杂多条件排序的两种主要方法：使用枚举定义固定类型优先级和使用Map处理动态类型优先级。无论采用哪种方法，Java 8的Comparator.comparing()和thenComparing()方法都为我们提供了强大而简洁的工具来组合多个排序规则。在实际开发中，根据具体需求和类型特征选择最合适的方案，并注意处理边界情况，可以构建出高效、健壮且易于维护的排序逻辑。