Java数据结构

Question

我需要一些可以从标准集合或使用番石榴构建的数据结构。所以它应该是可变的Map<Enum, V>。其中V 是非常有趣的结构。

V 要求：

• 可变
• 按比较器排序（允许使用 compare(a, b) == 0 等元素） - 这些是迭代的需要
• 设置（没有这样的a 和b，即a.equals(b) == true）- 可选

地图的额外可选要求

• 键应按其自然顺序迭代

现在是 HashMap<SomeEnum, LinkedList<Entity>>，代码中有不同的内容，例如 collections.sort()。

谢谢。

Answer 1

示例实现

这是您需要的类的Guava Multimap 实现：

首先是缺点：它必须驻留在包com.google.common.collect 中。番石榴的制造者以其无限的智慧使AbstractSortedSetMultimap 包作用域。

我将在所有示例中使用 enum：

public enum Color{
    RED, BLUE, GREEN
};

构造类

有六个构造函数：

• 空（使用HashMap 和自然排序的值）

  SortedSetMultimap<Color,String> simple = 
      new EnumValueSortMultiMap<Color, String>();
  

• 使用Comparator(V)（使用HashMap<K,SortedSet<V>> 和提供的值比较器）

  SortedSetMultimap<Color,String> inreverse =
      new EnumValueSortMultiMap<Color, String>(
          Ordering.natural().reverse()
      );
  

• 带有Map<K,SortedSet<V>>（如果您想对键进行排序，请使用它，传入SortedMap 实现）

  SortedSetMultimap<Color,String> withSortedKeys = 
      new EnumValueSortMultiMap<Color, String>(
          new TreeMap<Color, Collection<String>>()
      );
  

• 带有Map<K,SortedSet<V>> 和Comparator<V>（与上面相同，但使用自定义比较器对值进行排序）

  SortedSetMultimap<Color,String> reverseWithSortedKeys = 
      new EnumValueSortMultiMap<Color, String>(
          new TreeMap<Color, Collection<String>>(),
          Ordering.natural().reverse()
      );
  

• 使用Class<K extends Enum<K>>（在内部使用EnumMap 以提高效率，值的自然排序）

  SortedSetMultimap<Color,String> withEnumMap =
      new EnumValueSortMultiMap<Color, String>(
          Color.class
      );
  

• 带有Class<K extends Enum<K>> 和Comparator<V>（与上面相同，但使用自定义比较器对值进行排序）

  SortedSetMultimap<Color,String> reverseWithEnumMap =
      new EnumValueSortMultiMap<Color, String>(
          Color.class, Ordering.natural().reverse()
      );
  

源代码

课程如下：

package com.google.common.collect;

import java.util.Collection;
import java.util.Comparator;
import java.util.EnumMap;
import java.util.HashMap;
import java.util.Map;
import java.util.SortedSet;
import java.util.TreeSet;

public class EnumValueSortMultiMap<K extends Enum<K>,
    V extends Comparable<? super V>>
    extends AbstractSortedSetMultimap<K, V>{

    private static final long serialVersionUID = 5359491222446743952L;

    private Comparator<? super V> comparator;
    private Class<K> enumType;

    public EnumValueSortMultiMap(){
        this(new HashMap<K, Collection<V>>());
    }

    public EnumValueSortMultiMap(final Comparator<? super V> comparator){
        this(new HashMap<K, Collection<V>>(), comparator);
    }

    public EnumValueSortMultiMap(final Map<K, Collection<V>> map){
        this(map, Ordering.natural());
    }

    public EnumValueSortMultiMap(final Map<K, Collection<V>> map,
        final Comparator<? super V> comparator){
        super(map);
        this.comparator = comparator;
    }

    public EnumValueSortMultiMap(final Class<K> enumClass,
        final Comparator<? super V> comparator){
        this(new EnumMap<K, Collection<V>>(enumClass), comparator);
    }

    public EnumValueSortMultiMap(final Class<K> enumClass){
        this(new EnumMap<K, Collection<V>>(enumClass));
    }

    @Override
    Map<K, Collection<V>> backingMap(){
        return new EnumMap<K, Collection<V>>(enumType);
    }

    @Override
    public Comparator<? super V> valueComparator(){
        return comparator;
    }

    @Override
    SortedSet<V> createCollection(){
        return new TreeSet<V>(comparator);
    }

}

---

其他方法

更新：我想正确的 Guava 方法应该是这样的（它使用我写的 SortedArrayList 类 in my other answer）：

public static <E extends Enum<E>, V> Multimap<E, V> getMap(
    final Class<E> clz){

    return Multimaps.newListMultimap(
        Maps.<E, Collection<V>> newEnumMap(clz),
        new Supplier<List<V>>(){
            @Override
            public List<V> get(){
                return new SortedArrayList<V>();
            }
        }
    );
}

Answer 2

如果一个额外的类太多，你可能想使用类Multimaps的工厂方法。

SortedSetMultimap<Color, Entity> set = Multimaps.newSortedSetMultimap(
    new HashMap<Enum, Collection<Entity>>(), 
    new Supplier<TreeSet<Entity>>() {
        @Override
        public TreeSet<Entity> get() {
            return new TreeSet<Entity>(new Comparator<Entity>() {
                @Override
                public int compare(Entity o1, Entity o2) {
                    //TODO implement
                }
            });
        }
});

Answer 3

您可以使用EnumMap 代替当前的HashMap。 EnumMaps 对于枚举键更有效。在番石榴中检查Multimap [examples]。

Answer 4

你需要一个这样使用的集合实现 V：HashMap。上述要求影响 V（而非实体）。对吧？

我认为link TreeSet<E> 应该满足您的要求：

• TreeSet 实现了 Set 接口
• 按自然顺序或自定义比较器排序
• 可以添加和删除元素