使用Java Stream和Comparator实现自定义字母顺序排序

import java.util.Comparator;
import java.util.List;
import java.util.Arrays;
import java.util.stream.Collectors;

/**
 * 自定义比较器，根据指定的字母顺序对字符串进行排序。
 */
class MyComparator implements Comparator<String> {
    private String customOrder; // 存储自定义的字母顺序

    /**
     * 构造函数，初始化自定义字母顺序。
     * @param order 包含自定义字母顺序的字符串。
     */
    MyComparator(String order) {
        this.customOrder = order;
    }

    // compare方法将在后续实现
    @Override
    public int compare(String s1, String s2) {
        // 实现逻辑
        return 0; 
    }
}

    @Override
    public int compare(String s1, String s2) {
        // 获取两个字符串的首字符在 customOrder 字符串中的索引
        // 索引越小，表示该字符在自定义顺序中越靠前
        int index1 = customOrder.indexOf(s1.charAt(0));
        int index2 = customOrder.indexOf(s2.charAt(0));

        // 返回索引的差值。
        // 如果 index1 < index2，则 s1 应该排在 s2 前面，返回负数。
        // 如果 index1 > index2，则 s1 应该排在 s2 后面，返回正数。
        // 如果 index1 == index2，则表示首字符优先级相同，返回 0。
        return index1 - index2;
    }

public class CustomSortDemo {
    public static void main(String[] args) {
        // 示例1
        List<String> names1 = Arrays.asList("Robin", "Zax", "John");
        String order1 = "ZJR";
        System.out.println("原始列表1: " + names1);
        System.out.println("自定义顺序1: " + order1);
        List<String> sortedNames1 = names1.stream()
                                          .sorted(new MyComparator(order1))
                                          .collect(Collectors.toList());
        System.out.println("排序结果1: " + sortedNames1); // 预期输出: [Zax, John, Robin]

        System.out.println("--------------------");

        // 示例2
        List<String> names2 = Arrays.asList("Robin", "Zax", "John", "Rohan");
        String order2 = "OZJRHBAS";
        System.out.println("原始列表2: " + names2);
        System.out.println("自定义顺序2: " + order2);
        List<String> sortedNames2 = names2.stream()
                                          .sorted(new MyComparator(order2))
                                          .collect(Collectors.toList());
        System.out.println("排序结果2: " + sortedNames2); // 预期输出: [Zax, John, Rohan, Robin]
    }
}

原始列表1: [Robin, Zax, John]
自定义顺序1: ZJR
排序结果1: [Zax, John, Robin]
--------------------
原始列表2: [Robin, Zax, John, Rohan]
自定义顺序2: OZJRHBAS
排序结果2: [Zax, John, Rohan, Robin]

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

class OptimizedMyComparator implements Comparator<String> {
    private final Map<Character, Integer> charOrderMap;

    OptimizedMyComparator(String order) {
        this.charOrderMap = new HashMap<>();
        for (int i = 0; i < order.length(); i++) {
            charOrderMap.put(order.charAt(i), i);
        }
    }

    @Override
    public int compare(String s1, String s2) {
        Integer index1 = charOrderMap.getOrDefault(s1.charAt(0), Integer.MAX_VALUE); // 未定义的字符优先级最低
        Integer index2 = charOrderMap.getOrDefault(s2.charAt(0), Integer.MAX_VALUE);
        return index1.compareTo(index2);
    }
}

// 仅为示意，实际实现需更严谨地处理各种情况
@Override
public int compare(String s1, String s2) {
    int len1 = s1.length();
    int len2 = s2.length();
    int limit = Math.min(len1, len2);

    for (int i = 0; i < limit; i++) {
        char c1 = s1.charAt(i);
        char c2 = s2.charAt(i);

        Integer orderIndex1 = charOrderMap.get(c1); // 假设使用Map优化
        Integer orderIndex2 = charOrderMap.get(c2);

        // 处理字符不在自定义顺序中的情况
        if (orderIndex1 == null && orderIndex2 == null) {
            // 两个字符都不在自定义顺序中，按默认字符顺序比较
            if (c1 != c2) return Character.compare(c1, c2);
        } else if (orderIndex1 == null) {
            // c1不在自定义顺序中，c2在。通常认为在自定义顺序中的字符优先级更高
            return 1; // c1排在c2后面
        } else if (orderIndex2 == null) {
            // c2不在自定义顺序中，c1在
            return -1; // c1排在c2前面
        } else {
            // 两个字符都在自定义顺序中，按自定义顺序比较
            int diff = orderIndex1 - orderIndex2;
            if (diff != 0) {
                return diff;
            }
        }
    }
    // 如果一个字符串是另一个的前缀，较短的字符串排在前面
    return len1 - len2;
}