EnumMap<K extends Enum<K>, V> в Java четко упорядочено по определению связанного перечисления, как вы также можете увидеть в javadoc:

Карты перечислений поддерживаются в естественном порядке их ключей (порядок, в котором объявляются константы перечисления). Это находит свое отражение в итераторах возвращенного видом коллекций ( keySet(), entrySet()и values()).

Что мне нужно, так это SortedMapиспользование enum в качестве типа ключа. Я хочу использовать такие методы, как headMap()или firstKey(), но я хочу получить выгоду от дополнительной производительности процессора + памяти EnumMaps. А TreeMapзвучит как слишком много накладных расходов здесь.

Вопрос : было ли это просто пропущено при реализации, было ли это ленью (полученной из AbstractMap) или есть веская причина, почему EnumMapэто не так SortedMap?

Это не даст ответа на ваш основной вопрос (потому что ответ есть только у оригинальных дизайнеров), но один из подходов, который я рассматривал, состоял в том, чтобы вы реализовали его самостоятельно. Пытаясь сделать SortedMapреализацию на основе EnumMap, я придумал следующий класс.

Это, безусловно , быстрый и грязный реализации (и обратите внимание , что это не в полной мере соответствует требованиям SortedMap- поскольку зрения требований не выполнено), но если вам нужен один, вы можете улучшить его:

class SortedEnumMap<K extends Enum<K>, V> 
    extends EnumMap<K, V> 
    implements SortedMap<K, V> {

    private Class<K> enumClass;
    private K[] values;

    public SortedEnumMap(Class<K> keyType) {
        super(keyType);
        this.values = keyType.getEnumConstants();
        this.enumClass = keyType;

        if (this.values.length == 0) {
            throw new IllegalArgumentException("Empty values");
        }
    }

    @Override
    public Comparator<? super K> comparator() {
        return Comparator.comparingInt(K::ordinal);
    }

    @Override
    public SortedMap<K, V> subMap(K fromKey, K toKey) {
        List<K> keys = Arrays.stream(this.values)
                .dropWhile(k -> k.ordinal() < fromKey.ordinal())
                .takeWhile(k -> k.ordinal() < toKey.ordinal())
                .collect(Collectors.toList());

        return this.forKeys(keys);
    }

    @Override
    public SortedMap<K, V> headMap(K toKey) {
        List<K> keys = new ArrayList<>();

        for (K k : this.values) {
            if (k.ordinal() < toKey.ordinal()) {
                keys.add(k);
            } else {
                break;
            }
        }

        return this.forKeys(keys);
    }

    @Override
    public SortedMap<K, V> tailMap(K fromKey) {
        List<K> keys = new ArrayList<>();

        for (K k : this.values) {
            if (k.ordinal() >= fromKey.ordinal()) {
                keys.add(k);
            }
        }

        return this.forKeys(keys);
    }

    //Returned map is NOT a "view" or the current one
    private SortedEnumMap<K, V> forKeys(List<K> keys) {
        SortedEnumMap<K, V> n = new SortedEnumMap<>(this.enumClass);
        keys.forEach(key -> n.put(key, super.get(key)));

        return n;
    }

    @Override
    public K firstKey() {
        return this.values[0];
    }

    @Override
    public K lastKey() {
        return this.values[this.values.length - 1];
    }
}

И для быстрого теста (ошибки еще не найдены):

SortedMap<Month, Integer> m = new SortedEnumMap(Month.class);

for (Month v : Month.values()) {
    m.put(v, v.getValue());
}

System.out.println("firstKey():       " + m.firstKey());
System.out.println("lastKey():        " + m.lastKey());
System.out.println("headMap/June:     " + m.headMap(Month.JUNE));
System.out.println("tailMap/June:     " + m.tailMap(Month.JUNE));
System.out.println("subMap/April-July " + m.subMap(Month.APRIL, Month.JULY));

Я получил:

firstKey():       JANUARY
lastKey():        DECEMBER
headMap/June:     {JANUARY=1, FEBRUARY=2, MARCH=3, APRIL=4, MAY=5}
tailMap/June:     {JUNE=6, JULY=7, AUGUST=8, SEPTEMBER=9, OCTOBER=10, NOVEMBER=11, DECEMBER=12}
subMap/April-July {APRIL=4, MAY=5, JUNE=6}

Запрос на открытую функцию

Я смог найти эту проблему для OpenJDK . Это с 2005, но все еще открыто / неразрешено.

Я бы предположил, что нет «веских причин» для того, чтобы это не было реализовано.