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>();
  

• with a Comparator(V)(使用HashMap<K,SortedSet<V>>带有提供的比较器的值)

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

• with a Map<K,SortedSet<V>>(如果要对键进行排序,请使用此方法,传入SortedMap实现)

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

• 使用a Map<K,SortedSet<V>>和a Comparator<V>(与上面相同,但使用自定义比较器对值进行排序)

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

• with a Class<K extends Enum<K>>(EnumMap内部使用效率更高,值自然排序)

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

• 使用a Class<K extends Enum<K>>和a 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我在其他答案中写的类):

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
                }
            });
        }
});