构建基于Map的排序对象教程

import java.util.Iterator;
import java.util.Map;
import java.util.LinkedHashMap; // 推荐使用，以保证顺序

// 假设的WorklistColumn枚举
enum WorklistColumn {
    ID, NAME, STATUS;

    @Override
    public String toString() {
        return name().toLowerCase(); // 转换为小写字符串作为列名
    }
}

// 假设的Direction枚举
enum Direction {
    ASCENDING, DESCENDING;
}

// 假设的Sort类定义 (简化版，与问题描述一致)
class Sort {
    private List<Column> columns = new ArrayList<>();

    private Sort() {} // 私有构造函数

    public static Sort by(String column) {
        return (new Sort()).and(column);
    }

    public static Sort by(String column, Direction direction) {
        return (new Sort()).and(column, direction);
    }

    public Sort and(String name) {
        this.columns.add(new Column(name));
        return this;
    }

    public Sort and(String name, Direction direction) {
        this.columns.add(new Column(name, direction));
        return this;
    }

    // 内部类 Column
    private static class Column {
        String name;
        Direction direction;

        Column(String name) {
            this(name, Direction.ASCENDING); // 默认升序
        }

        Column(String name, Direction direction) {
            this.name = name;
            this.direction = direction;
        }

        @Override
        public String toString() {
            return name + " " + direction;
        }
    }

    @Override
    public String toString() {
        return "Sort{" +
               "columns=" + columns +
               '}';
    }
}

public class SortBuilder {

    // 自定义异常，用于处理空排序条件
    static class NoCriteriaException extends RuntimeException {
        public NoCriteriaException(String message) {
            super(message);
        }
    }

    /**
     * 根据Map构建Sort对象。
     * Map的迭代顺序将决定排序条件的优先级。
     *
     * @param columnsDirectionsMap 包含列名和排序方向的Map
     * @return 构建好的Sort对象
     * @throws NoCriteriaException 如果Map为空
     */
    private Sort buildSort(Map<WorklistColumn, Direction> columnsDirectionsMap) {
        if (columnsDirectionsMap.isEmpty()) {
            throw new NoCriteriaException("Sorting criteria map cannot be empty.");
        }

        // 获取Map条目的迭代器
        Iterator<Map.Entry<WorklistColumn, Direction>> criterionIterator =
                columnsDirectionsMap.entrySet().iterator();

        // 处理第一个条目：使用Sort.by()初始化Sort对象
        Map.Entry<WorklistColumn, Direction> firstCriterion = criterionIterator.next();
        Sort sort = Sort.by(firstCriterion.getKey().toString(), firstCriterion.getValue());

        // 处理剩余条目：使用sort.and()追加排序条件
        while (criterionIterator.hasNext()) {
            Map.Entry<WorklistColumn, Direction> nextCriterion = criterionIterator.next();
            sort.and(nextCriterion.getKey().toString(), nextCriterion.getValue());
        }

        return sort;
    }

    public static void main(String[] args) {
        SortBuilder builder = new SortBuilder();

        // 示例1: 使用LinkedHashMap保持插入顺序
        Map<WorklistColumn, Direction> sortCriteria1 = new LinkedHashMap<>();
        sortCriteria1.put(WorklistColumn.NAME, Direction.ASCENDING);
        sortCriteria1.put(WorklistColumn.ID, Direction.DESCENDING);
        sortCriteria1.put(WorklistColumn.STATUS, Direction.ASCENDING);

        Sort sortObject1 = builder.buildSort(sortCriteria1);
        System.out.println("Sort Object 1 (LinkedHashMap): " + sortObject1);
        // 预期输出: Sort{columns=[name ASCENDING, id DESCENDING, status ASCENDING]}

        // 示例2: 尝试使用HashMap (不推荐，顺序不可预测)
        Map<WorklistColumn, Direction> sortCriteria2 = new HashMap<>();
        sortCriteria2.put(WorklistColumn.NAME, Direction.ASCENDING);
        sortCriteria2.put(WorklistColumn.ID, Direction.DESCENDING);
        sortCriteria2.put(WorklistColumn.STATUS, Direction.ASCENDING);

        Sort sortObject2 = builder.buildSort(sortCriteria2);
        System.out.println("Sort Object 2 (HashMap - Order may vary): " + sortObject2);
        // 实际输出顺序可能与LinkedHashMap不同

        // 示例3: 空Map测试
        Map<WorklistColumn, Direction> emptyMap = new LinkedHashMap<>();
        try {
            builder.buildSort(emptyMap);
        } catch (NoCriteriaException e) {
            System.err.println("Error: " + e.getMessage());
        }
    }
}