优化枚举查找图

Question

I am wondering if there is a better way to create and search through the static Maps below. As seen in the main() method.

import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

public enum PokemonType {
  BUG("Bug"),
  DARK("Dark"),
  DRAGON("Dragon"),
  ELECTRIC("Electric"),
  FAIRY("Fairy"),
  FIGHTING("Fighting"),
  FIRE("Fire"),
  FLYING("Flying"),
  GHOST("Ghost"),
  GRASS("Grass"),
  GROUND("Ground"),
  ICE("Ice"),
  NORMAL("Normal"),
  POISON("Poison"),
  PSYCHIC("Psychic"),
  ROCK("Rock"),
  STEEL("Steel"),
  WATER("Water");

  private String name;

  @SuppressWarnings("serial")
  public static Map<PokemonType, Set<PokemonType>> noEffect = new HashMap<PokemonType, Set<PokemonType>>() {{
    put(BUG, new HashSet<PokemonType>());
    put(DARK, new HashSet<PokemonType>());
    put(DRAGON, new HashSet<PokemonType>());
    put(ELECTRIC, new HashSet<PokemonType>() {{ addAll(Arrays.asList(GROUND)); }});
    put(FAIRY, new HashSet<PokemonType>());
    put(FIGHTING, new HashSet<PokemonType>() {{ addAll(Arrays.asList(GHOST)); }});
    put(FIRE, new HashSet<PokemonType>());
    put(FLYING, new HashSet<PokemonType>());
    put(GHOST, new HashSet<PokemonType>() {{ addAll(Arrays.asList(NORMAL)); }});
    put(GRASS, new HashSet<PokemonType>());
    put(GROUND, new HashSet<PokemonType>() {{ addAll(Arrays.asList(FLYING)); }});
    put(ICE, new HashSet<PokemonType>());
    put(NORMAL, new HashSet<PokemonType>() {{ addAll(Arrays.asList(GHOST)); }});
    put(POISON, new HashSet<PokemonType>());
    put(PSYCHIC, new HashSet<PokemonType>());
    put(ROCK, new HashSet<PokemonType>());
    put(STEEL, new HashSet<PokemonType>());
    put(WATER, new HashSet<PokemonType>());
  }};

  @SuppressWarnings("serial")
  public static Map<PokemonType, Set<PokemonType>> notVeryEffective = new HashMap<PokemonType, Set<PokemonType>>() {{
    put(BUG, new HashSet<PokemonType>() {{ addAll(Arrays.asList(FIGHTING,FIRE,FLYING,GHOST,POISON,STEEL)); }});
    put(DARK, new HashSet<PokemonType>() {{ addAll(Arrays.asList(DARK,FIGHTING,STEEL)); }});
    put(DRAGON, new HashSet<PokemonType>() {{ addAll(Arrays.asList(STEEL)); }});
    put(ELECTRIC, new HashSet<PokemonType>() {{ addAll(Arrays.asList(DRAGON,ELECTRIC)); }});
    put(FAIRY, new HashSet<PokemonType>());
    put(FIGHTING, new HashSet<PokemonType>() {{ addAll(Arrays.asList(BUG,FLYING,POISON,PSYCHIC)); }});
    put(FIRE, new HashSet<PokemonType>() {{ addAll(Arrays.asList(DRAGON,FIRE,ROCK,WATER)); }});
    put(FLYING, new HashSet<PokemonType>() {{ addAll(Arrays.asList(ROCK,STEEL)); }});
    put(GHOST, new HashSet<PokemonType>() {{ addAll(Arrays.asList(STEEL)); }});
    put(GRASS, new HashSet<PokemonType>() {{ addAll(Arrays.asList(BUG,DRAGON,FIRE,FLYING,GRASS,POISON,STEEL)); }});
    put(GROUND, new HashSet<PokemonType>() {{ addAll(Arrays.asList(BUG,GRASS)); }});
    put(ICE, new HashSet<PokemonType>() {{ addAll(Arrays.asList(FIRE,ICE,STEEL,WATER)); }});
    put(NORMAL, new HashSet<PokemonType>() {{ addAll(Arrays.asList(ROCK,STEEL)); }});
    put(POISON, new HashSet<PokemonType>() {{ addAll(Arrays.asList(GHOST,GROUND,POISON,ROCK)); }});
    put(PSYCHIC, new HashSet<PokemonType>() {{ addAll(Arrays.asList(PSYCHIC,STEEL)); }});
    put(ROCK, new HashSet<PokemonType>() {{ addAll(Arrays.asList(FIGHTING,GROUND,STEEL)); }});
    put(STEEL, new HashSet<PokemonType>() {{ addAll(Arrays.asList(ELECTRIC,FIRE,STEEL,WATER)); }});
    put(WATER, new HashSet<PokemonType>() {{ addAll(Arrays.asList(DRAGON,GRASS,WATER)); }});
  }};

  @SuppressWarnings("serial")
  public static Map<PokemonType, Set<PokemonType>> superEffective = new HashMap<PokemonType, Set<PokemonType>>() {{
    put(BUG, new HashSet<PokemonType>() {{ addAll(Arrays.asList(DARK,GRASS,PSYCHIC)); }});
    put(DARK, new HashSet<PokemonType>() {{ addAll(Arrays.asList(GHOST,PSYCHIC)); }});
    put(DRAGON, new HashSet<PokemonType>() {{ addAll(Arrays.asList(DRAGON)); }});
    put(ELECTRIC, new HashSet<PokemonType>() {{ addAll(Arrays.asList(FIRE,WATER)); }});
    put(FAIRY, new HashSet<PokemonType>());
    put(FIGHTING, new HashSet<PokemonType>() {{ addAll(Arrays.asList(DARK,ICE,NORMAL,ROCK,STEEL)); }});
    put(FIRE, new HashSet<PokemonType>() {{ addAll(Arrays.asList(BUG,GRASS,ICE,STEEL)); }});
    put(FLYING, new HashSet<PokemonType>() {{ addAll(Arrays.asList(BUG,FIGHTING,GRASS)); }});
    put(GHOST, new HashSet<PokemonType>() {{ addAll(Arrays.asList(GHOST,PSYCHIC)); }});
    put(GRASS, new HashSet<PokemonType>() {{ addAll(Arrays.asList(GROUND,ROCK,WATER)); }});
    put(GROUND, new HashSet<PokemonType>() {{ addAll(Arrays.asList(ELECTRIC,FIRE,POISON,ROCK,STEEL)); }});
    put(ICE, new HashSet<PokemonType>() {{ addAll(Arrays.asList(DRAGON,FLYING,GRASS,GROUND)); }});
    put(NORMAL, new HashSet<PokemonType>());
    put(POISON, new HashSet<PokemonType>() {{ addAll(Arrays.asList(GRASS)); }});
    put(PSYCHIC, new HashSet<PokemonType>() {{ addAll(Arrays.asList(FIGHTING,POISON)); }});
    put(ROCK, new HashSet<PokemonType>() {{ addAll(Arrays.asList(BUG,FIRE,FLYING,ICE)); }});
    put(STEEL, new HashSet<PokemonType>() {{ addAll(Arrays.asList(ICE,PSYCHIC)); }});
    put(WATER, new HashSet<PokemonType>() {{ addAll(Arrays.asList(FIRE,GROUND,ROCK)); }});
  }};

  public float getModifier(PokemonType opponentType) {
    if (PokemonType.superEffective.get(this).contains(opponentType))
      return 2.0f;
    if (PokemonType.notVeryEffective.get(this).contains(opponentType))
      return 0.5f;
    if (PokemonType.noEffect.get(this).contains(opponentType))
      return 0.0f;
    return 1.0f;
  }

  public String getName() {
    return name;
  }

  public void setName(String name) {
    this.name = name;
  }

  public String shortName() {
    return this.name.substring(0, 3);
  }

  private PokemonType(String name) {
    this.name = name;
  }

  public static void main(String[] args) {
    assert(PokemonType.ELECTRIC.getModifier(PokemonType.WATER) == 2.0f);
    assert(PokemonType.GROUND.getModifier(PokemonType.DARK) == 1.0f);
    assert(PokemonType.FIRE.getModifier(PokemonType.DRAGON) == 0.5f);
    assert(PokemonType.NORMAL.getModifier(PokemonType.GHOST) == 0.0f);
  }
}

Answer 1

I would use an ImmutableMap or an UnmodifiableMap since the map(s) aren't supposed to be modified once they've been populated.

Also, I would create a single Map<List<PokemonType>, Float> , where each list would contain two PokemonType objects (the first object would be the attacker and the second would be the defender, or vice versa - it doesn't matter as long as it's consistent). Alternatively, I would create a single Map<PokemonTypePair, Float> , where PokemonTypePair is

public class PokemonTypePair {
    final public PokemonType attacker;
    final public PokemonType defender;

    public boolean equals(Object obj) {
        if(obj == null) return false;
        else if(!(obj instanceof PokemonTypePair)) return false;
        else {
            PokemonTypePair other = (PokemonTypePair)obj;
            return this.attacker.equals(other.attacker) &&
                this.defender.equals(other.defender);
        }
    }

    public int hashCode() {
        return (997 * attacker == null ? 0 : attacker.hashCode()) ^
            (991 * defender == null ? 0 : defender.hashCode());
    }
}

The the float for each map entry would be 0.0, 0.5, 1.0, or 2.0; alternatively, omit the map entries that would have a 1.0 value and assume that missing map entries correspond to a 1.0 value.

If the pairings are reflexive (meaning it doesn't matter who is the attacker and who is the defender - I don't know how pokemon works), then you just need a PokemonType pokemon1 field and a PokemonType pokemon2 field; put the PokemonType that's lower in alphabetical order in the pokemon1 field and the PokemonType that's higher in alphabetical order in the pokemon2 field, in order to simplify the equals method. Likewise, if you go with the List<List<PokemonType>> approach, sort the inner list in alphabetical order, or else use a List<Set<PokemonType>> instead.

This way, given any two pokemon types, you just need to look up the pair in a single map to find the multiplier, rather than having to check multiple maps.

If you want to quickly find the pairings that are ineffective / super effective / etc, then maintain separate lists or sets of the ineffective / super effective / etc pairings, ie List<List<PokemonType>> ineffectivePairing or List<PokemonPairing> ineffectivePairing

Answer 2

如果您有一个带有枚举键的Map或一个带有枚举值的Set，则使用EnumMap或EnumSet更为有效，因为它们是针对这种情况而设计的。