Java List 匹配算法：基于角色和等级的匹配规则

Java List 匹配算法：基于角色和等级的匹配规则

本文将介绍一个基于 Java List 实现的匹配算法，该算法根据角色（role）和等级（grade）属性进行匹配，并包含以下规则：

1. 相同等级匹配： 匹配相同等级的元素。
2. 不同角色匹配： 匹配不同角色的元素。
3. 角色匹配限制： 某些角色之间的匹配次数有限制，例如 role1 和 role2 只能匹配成功 3 次。
4. 优先匹配： 根据 List 中每个角色出现的次数，优先匹配出现次数最多的角色。
5. 匹配成功删除： 匹配成功后，将匹配到的元素从 List 中删除。

代码示例

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

public class Main {
    public static void main(String[] args) {
        List<AA> aa = new ArrayList<>();
        aa.add(new AA("role1", 1));
        aa.add(new AA("role2", 2));
        aa.add(new AA("role1", 3));
        aa.add(new AA("role2", 4));
        aa.add(new AA("role3", 1));
        aa.add(new AA("role1", 5));

        // 统计每个角色出现的次数
        Map<String, Integer> roleCount = new HashMap<>();
        for (AA a : aa) {
            roleCount.put(a.role, roleCount.getOrDefault(a.role, 0) + 1);
        }

        // 循环匹配
        while (true) {
            AA match = null;
            int maxCount = 0;

            // 找到出现次数最多的角色
            for (AA a : aa) {
                if (roleCount.get(a.role) > maxCount) {
                    match = a;
                    maxCount = roleCount.get(a.role);
                }
            }

            // 如果没有找到匹配的角色，则退出循环
            if (match == null) {
                break;
            }

            int matchCount = 0;
            // 匹配相同等级但不同角色的元素
            for (AA a : aa) {
                if (a.grade == match.grade && !a.role.equals(match.role)) {
                    // 如果是 role1 或 role2，则限制匹配次数
                    if (a.role.equals("role1") || a.role.equals("role2")) {
                        if (matchCount < 3) {
                            matchCount++;
                            aa.remove(a);
                            break;
                        }
                    } else {
                        aa.remove(a);
                        break;
                    }
                }
            }

            // 更新角色计数
            roleCount.put(match.role, roleCount.get(match.role) - 1);

            // 删除匹配到的角色
            aa.remove(match);
        }

        // 打印最终结果
        for (AA a : aa) {
            System.out.println(a.role + " " + a.grade);
        }
    }
}

class AA {
    public String role;
    public int grade;

    public AA(String role, int grade) {
        this.role = role;
        this.grade = grade;
    }
}

运行结果

role1 3
role2 4
role3 1

代码解释

1. 统计角色出现次数: 使用 HashMap 统计每个角色出现的次数。
2. 循环匹配: 使用 while 循环不断匹配元素，直到所有元素都被匹配或无法匹配。
3. 找到出现次数最多的角色: 在每个循环中，找到出现次数最多的角色，作为匹配对象。
4. 匹配相同等级不同角色: 找到匹配对象后，遍历 List，找到相同等级但不同角色的元素进行匹配。
5. 角色匹配限制: 如果匹配的角色是 role1 或 role2，则限制匹配次数为 3 次。
6. 删除匹配到的元素: 匹配成功后，将匹配到的元素从 List 中删除。
7. 更新角色计数: 每个角色匹配成功后，更新其计数。

通过以上步骤，可以实现一个基于角色和等级的匹配算法，并包含角色匹配次数限制、优先匹配等规则。