Question

我有下一个enum课程：

public class DataParameter {

    public enum Types {
        BIG(-1), SMALL(1), SMAL2(2), SMAL3(5), BIG1(-1), BIG2(1), BIG3(2), BIF4(
                5);

        private final int id;

        Types(int id) {
            this.id = id;
        }

        public int getValue() {
            return id;
        }

        public static <T> parseType(T type, int id) {
            int intType = Integer.parseInt(String.valueOf(type));

            if (intType == SIZE_XL.getValue()) {
                if (id == -1)
                    return BIG;
                if (id == 1)
                    return BIG2;
                if (id == 2)
                    return BIG3;
                if (id == 5)
                    return BIG4;
            } else if (intType == SIZE_LARGE.getValue()) {
                if (id == 5)
                    return BIG4;
                if (id == 2)
                    return SMALL2;
                if (id == 5)
                    return SMALL3;
            } else if (intType == SIZE_UKNOWN.getValue()) {
                if (id == -1)
                    return BIG;
                if (id == -1)
                    return BIG;
                if (id == -1)
                    return BIG1;
                if (id == 5)
                    return BIG4;
            } else if (intType == SIZE_UKNOWN_2.getValue()) {
                return SMAL3;
            }

            return returnDefault(intType);
        }
    }

    public DataParameter(GameTypes type) {
        mValue = type.getValue();
    }
}

这个代码非常混乱很多if语句的问题。我试图创建一个将成为下一个结构的地图：

SIZE_XL ---> BIG,BIG2,BIG4
SIZE_LARGE ---> BIG4,SMALL2 ,SMALL3
SIZE_UKNOWN ---> BIG , BIG1 , BIG4

和他们当我得到钥匙时，我将从地图中检索元素我感到困惑，因为在enum课程中我遇到了一些未知问题。

HashMap<Integer, HashMap<Integer, Integer> myMap = new HashMap<Integer, HashMap<Integer, Integer>();
myMap.put(SIZE_XL.getValue(),BIG2.getValue(),BIG2)
myMap.put(SIZE_XL.getValue(),BIG3.getValue(),BIG3)
myMap.put(SIZE_XL.getValue(),BIG4.getValue(),BIG4)

...

... ..

我很感激在这个问题上的帮助

Answer 1

您需要创建一个地图，而不是直接将值放在Map中，而是需要将该地图放在来自enum的Key上。您目前将值放在一个不适用于Map

的表单中

即。而不是使用

HashMap<Integer, HashMap<Integer, Integer> myMap = new HashMap<Integer, HashMap<Integer, Integer>();
myMap.put(SIZE_XL.getValue(),BIG2.getValue(),BIG2)

使用：

HashMap<Integer, HashMap<Integer, Integer> myMap = new HashMap<Integer,     HashMap<Integer, Integer>();
Map<Integer, Integer> valueMap = new HashMap<Integer, Integer>();//create a map for values
valueMap.put(BIG2.getValue(), BIG2);//put the value and enum field in the value map
myMap.put(SIZE_XL.getValue(), valueMap);//put the value map against the key in your map.

Answer 2

在你的代码中，你省略了SIZE_XL和类似常量的定义，我建议不要将它们定义为常量，而是将它们放在自己的enum中，例如：< / p>

enum Size {
  XL(2), LARGE(1), UNKNOWN(-1), UNKNOWN_2(-2);

  private final int value;
  Size(int val) {
    value = val;
  }

  public int getValue() {
    return value;
  }
}

在您的解析方法中，您正在根据两个参数查找Types，实际上这些是您需要合并以获取价值的两个键。 Table是Guava中定义的数据结构，具有两个键（一行和一列）和一个值。将感兴趣的组合（在您的解析函数中定义）存储在ImmutableTable中，可以快速查找正确的值。代码变为：

public enum Types {
  SMALL(1), SMALL2(2), SMALL3(3),

  BIG(0), BIG1(1), BIG2(2), BIG3(3), BIG4(4);

  static final ImmutableTable<Integer, Integer, Types> TABLE =
    ImmutableTable.<Integer, Integer, Types>builder()
      .put(Size.XL.getValue(), BIG.getValue(), BIG)
      .put(Size.XL.getValue(), BIG2.getValue(), BIG2)
      .put(Size.XL.getValue(), BIG4.getValue(), BIG4)
      .put(Size.LARGE.getValue(), BIG4.getValue(), BIG4)
      .put(Size.LARGE.getValue(), SMALL2.getValue(), SMALL2)
      .put(Size.LARGE.getValue(), SMALL3.getValue(), SMALL3)
      .put(Size.UNKNOWN.getValue(), BIG.getValue(), BIG)
      .put(Size.UNKNOWN.getValue(), BIG1.getValue(), BIG1)
      .put(Size.UNKNOWN.getValue(), BIG4.getValue(), BIG4)
      .build();

  private final int id;

  Types(int id) {
    this.id = id;
  }

  public int getValue() {
    return id;
  }

  public static Collection<Types> getTypesWithSize(Size size) {
    return TABLE.row(size.getValue()).values();
  }

  public static Collection<Types> getTypesWithId(Types types) {
    return TABLE.column(types.getValue()).values();
  }

  public static <T> Types parseType(T type, int id) {
    final int intType = Integer.parseInt(String.valueOf(type));

    if (!TABLE.contains(intType, id)) {
      // return some default value or throw exception
    }
    return TABLE.get(intType, id);
  }
}

现在您可以将此代码用作：

Types.getTypesWithSize(Size.LARGE); // returns [SMALL2, BIG4, SMALL3]
Types.getTypesWithId(Types.SMALL3); // returns [SMALL3]

请注意，我必须更改Types的某些值，以避免重复的行和列组合，对于给定的行和列，只能有一个Types实例。

在Enum类中存储值的Map集合以便更好地访问

2 个答案: