1

是否有任何美学方法可以根据其他两种枚举类型检索枚举值？我想做的是获得两个枚举参数的状态，如下例所示：

public enum State{

ONE_STATE,
SECOND_STATE;
THIRD_STATE;

public static State getState(Direction dir, Type type) {
    if (dir.equals(Direction.LEFT) && type.equals(Type.BIG)) {
        return ONE_STATE;
    }
    else if (dir.equals(Direction.RIGHT) && type.equals(Type.SMALL)) {
        return SECOND_STATE;
    }
    else if (dir.equals(Direction.UP) && type.equals(Type.SMALL)) {
        return FIRST_STATE;
    }
    return THIRD_STATE;
}

}

当然这会说话，但我的目的是让一些事情更清楚，因为这样的可能性会随着时间的推移而增加。

4

6 回答 6

0

使用嵌套的 EnummMap。“Effective Java”一书（Item 33）解释了为什么这是最好的解决方案。

// Using a nested EnumMap to associate data with enum pairs
public enum Phase {
    SOLID, LIQUID, GAS;
    public enum Transition {
        MELT(SOLID, LIQUID), FREEZE(LIQUID, SOLID),
        BOIL(LIQUID, GAS), CONDENSE(GAS, LIQUID),
        SUBLIME(SOLID, GAS), DEPOSIT(GAS, SOLID);
        final Phase src;
        final Phase dst;
        Transition(Phase src, Phase dst) {
            this.src = src;
            this.dst = dst;
        }
        // Initialize the phase transition map
        private static final Map<Phase, Map<Phase,Transition>> m =
                new EnumMap<Phase, Map<Phase,Transition>>(Phase.class);
        static {
            for (Phase p : Phase.values())
                m.put(p,new EnumMap<Phase,Transition>(Phase.class));
            for (Transition trans : Transition.values())
                m.get(trans.src).put(trans.dst, trans);
        }
        public static Transition from(Phase src, Phase dst) {
            return m.get(src).get(dst);
        }
    }
}
于 2013-02-21T15:26:34.113 回答
0

您可以使用switches 而不是ifs 但这不会使代码更短。它将具有更清晰的优点，并且根据您的 IDE，您可以让它在switch缺少案例时给您错误。

让项目最多的枚举是外部的switch，其他的是内部的switch。

State enum仅当只有Directionand的一种组合Type“到达” that时，才能向您添加字段State。

switch(dir) {
  case LEFT:
  {
    switch(type) {
      case BIG:
      ...
于 2013-02-21T15:25:15.953 回答
0

为什么不使用查找表？行数组 - 每行包含 2 个输入和一个输出。

LEFT,  BIG,   ONE_STATE
RIGHT, SMALL, SECOND_STATE

等，并提供一种方法来查找并在查找失败时返回默认值。

做不到这一点，你可以调查双重调度

于 2013-02-21T15:19:20.267 回答
0

枚举可以有字段，您可以尝试以下操作：

public enum State {
    ONE_STATE(Direction.LEFT, Type.BIG),
    ...

    Direction d;
    Type t;

    private State(Direction d, Type t) {
        ...
    }

    public static State getState(Direction d, Type t) {
        for (State s : State.values()) {
            if (s.d == d && s.t == t) {
                return s;
            }
        }
        return null;
    }
}
于 2013-02-21T15:20:48.447 回答
0

将 Direction 和 Type 作为枚举的成员怎么样，如下所示：

public enum State {

    ONE_STATE(Direction.LEFT, Type.BIG),
    SECOND_STATE(Direction.RIGHT, Type.SMALL);
    THIRD_STATE(Direction.UP, Type.SMALL);

    private Direction direction;
    private Type type;

    private State(Direction direction, Type type) {
        this.direction = direction;
        this.type = type;
    }

    public static State getState(Direction dir, Type type) {
        for (State state : values()) {
            if (state.direction == dir && state.type == type) {
                return state;
            }
        }
        return THIRD_STATE;
    }
}

请注意，如果每个枚举有多个不同的组合，这将不起作用。在这种情况下，您将需要使用另一张海报所建议的某种查找表。例如，您可以使用Map<Pair<Direction, Type>, State>. （Java 没有Pair<T, U>类，但您可以轻松地创建一个类或在许多不同的库中找到一个。）

于 2013-02-21T15:20:56.347 回答
0

DIRECTION您可以将和封装TYPE在一个具体的类中（比如EnumGroup）。并创建一个Hashmap包含 key 作为enum的对象EnumGroup和value 的值。通过这种方式，我们可以为和的多个组合保存值。我们也可以有两个不同的具有相同的值。这是代码演示。valueStatestateDIRECTIONSTATEEnumGroupstate

import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;
import java.util.List;
class EnumGroup 
{
    Direction direction;
    Type type;
    private EnumGroup(){}//To prevent parmeterless construction
    public EnumGroup(Direction direction , Type type)
    {
        if (direction==null || type == null)
        {
            throw new IllegalStateException("null is not allowed");
        }
        this.direction = direction;
        this.type = type;
    }
    @Override
    public int hashCode()
    {
        return direction.toString().hashCode() + type.toString().hashCode() ;
    }
    @Override
    public boolean equals(final Object other)
    {
        if (other == null || !(other instanceof EnumGroup))
        {
            return false;
        }
        if (this == other)
        {
            return true;
        }
        EnumGroup temp = (EnumGroup)other;
        if (temp.type == this.type && temp.direction == this.direction)
        {
            return true;
        }
        return false;
    }
}
enum Direction
{
    LEFT,RIGHT,DOWN,UP,ACCROSS;
}
enum Type
{
    BIG,SMALL,MEDIUM;
}
enum State
{
    ONE_STATE,FIRST_STATE,SECOND_STATE,THIRD_STATE;
    private static final Map<EnumGroup,State> map = new HashMap<EnumGroup,State>();
    static
    {
        map.put(new EnumGroup(Direction.LEFT,Type.BIG),ONE_STATE);
        map.put(new EnumGroup(Direction.RIGHT,Type.SMALL),SECOND_STATE);
        map.put(new EnumGroup(Direction.UP,Type.SMALL),FIRST_STATE);
        /*
        .
        .
        .
        */
    }
    public static State getState(EnumGroup eGroup) 
    {
        State state = map.get(eGroup);
        return state == null ? THIRD_STATE : state;
    }
}
public class EnumValueByArgument
{
    public static void main(String st[])
    {
        ArrayList<EnumGroup> list = new ArrayList<EnumGroup>();
        for (Direction direction : Direction.values())
        {
            for (Type type : Type.values() )
            {
                list.add(new EnumGroup(direction,type));
            }
        }
        for (EnumGroup eGroup : list )
        {
            System.out.println(State.getState(eGroup));
        }
    }
}
于 2013-02-21T18:18:28.660 回答