Java数据结构

Question

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

V要求：

• 可变
• 按比较器排序（允许比较（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。 EnumMap对枚举键更有效。在番石榴检查中Multimap [examples]。

Answer 4

您需要一个以这种方式使用的集合实现V：HashMap＆lt; SomeEnum，V＆gt;。上述要求影响V（非实体）。正确？

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

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