从Map构建Sort对象：利用迭代器模式处理初始化与链式调用

public 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, Direction
}

import java.util.Iterator;
import java.util.Map;
import java.util.LinkedHashMap; // 示例中可能需要
// 假设 WorklistColumn 和 Direction 是定义好的枚举或类
// 假设 Sort 类如上文所示

public class SortBuilder {

    // 假设 NoCriteriaException 是一个自定义的运行时异常
    public static class NoCriteriaException extends RuntimeException {
        public NoCriteriaException() {
            super("Sorting criteria map cannot be empty.");
        }
    }

    /**
     * 根据Map构建Sort对象。
     * Map的第一个条目用于初始化Sort对象，后续条目通过and()方法添加。
     *
     * @param columnsDirectionsMap 包含排序列及其方向的Map。
     * @return 构建好的Sort对象。
     * @throws NoCriteriaException 如果传入的Map为空。
     */
    private Sort buildSort(Map<WorklistColumn, Direction> columnsDirectionsMap) {
        // 1. 检查Map是否为空，空Map无法构建有效的Sort对象
        if (columnsDirectionsMap.isEmpty()) {
            throw new NoCriteriaException(); // 或者返回 null，取决于业务需求
        }

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

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

        // 4. 循环处理剩余的Map条目，通过and()方法添加到现有Sort对象
        while (criterionIterator.hasNext()) {
            Map.Entry<WorklistColumn, Direction> subsequentCriterion = criterionIterator.next();
            sort.and(subsequentCriterion.getKey().toString(), subsequentCriterion.getValue());
        }

        return sort;
    }

    // 示例用法
    public static void main(String[] args) {
        // 假设 WorklistColumn 和 Direction 是枚举类型
        // enum WorklistColumn { ID, NAME, DATE }
        // enum Direction { ASCENDING, DESCENDING }

        // 使用 LinkedHashMap 保证插入顺序，对于排序至关重要
        Map<WorklistColumn, Direction> sortCriteria = new LinkedHashMap<>();
        sortCriteria.put(WorklistColumn.DATE, Direction.DESCENDING);
        sortCriteria.put(WorklistColumn.NAME, Direction.ASCENDING);
        sortCriteria.put(WorklistColumn.ID, Direction.ASCENDING);

        SortBuilder builder = new SortBuilder();
        Sort finalSort = builder.buildSort(sortCriteria);

        // 打印或验证 finalSort 对象
        System.out.println("Generated Sort object: " + finalSort);
        // 预期输出：Sort[columns=[DATE:DESCENDING, NAME:ASCENDING, ID:ASCENDING]]
    }
}