java - 哈希是合适的解决方案吗？我是不是太复杂了？

Question

我写了一个 2D 平台游戏，我需要带(最多 4 个)门的房间。我用 Java 编写它，但语言无关紧要。

每个房间可以有 4 扇门，分别位于顶部、底部和侧面。我称它们为 NORTH、SOUTH、EAST 和 WEST。当我 build 一个房间时，我只给它一个整数，整数中的每一位代表一扇门。

例如，如果我想要一个有 3 扇门的房间(一个在北边，一个在东边，一个在西边)我给房间编号:11(二进制为 1011)。

因此，每扇门都有一个整数来标识它。

NORTH = 8;//1000
SOUTH = 4;//0100
EAST =  2;//0010
WEST =  1;//0001

如果我生成一个房间，我会为它提供这些标识符的组合。

例如:前面提到的房间将获得标识符

doorStock = NORTH | EAST | WEST;

我将这些门存储在一个简单的数组中:

Door doors[] = new Door[4];

我的问题是:我需要一个可以将标识符映射到数组中正确索引的函数。我并不总是需要 4 扇门。

起初我做的似乎是最简单的:doors 数组总是有 4 个元素，而我不会使用的索引将简单地保持为 null。

public Door getDoor(int doorID){
    switch(doorID){
        case NORTH:{
            return doors[0];
        }
        case SOUTH:{
            return doors[1];
        }
        case EAST:{
            return doors[2];
        }
        case WEST:{
            return doors[3];
        }
    }
    return null;
}

为了安全起见，我需要确定我请求的门是否确实存在于房间中。

private boolean doorExists(int doorID){
    return (doorID & doorStock) != 0
}

因此，查询函数如下所示:

public Door getDoor(int doorID){
    switch(doorID){
        case NORTH:{
            if(doorExists(NORTH))return doors[0];
            else return null;
        }
        case SOUTH:{
            if(doorExists(NORTH))return doors[1];
            else return null;
        }
        case EAST:{
            if(doorExists(NORTH))return doors[2];
            else return null;
        }
        case WEST:{
            if(doorExists(NORTH))return doors[3];
            else return null;
        }
    }
    return null;
}

这是有效的。但!这样，数组可能会因未使用的元素而浪费空间。此外，类 Door 可能是任意大小，增加了内存浪费。

更不用说我可能需要更多的门“插槽”(例如，如果我尝试在 3D 中实现它)，所以我决定尝试根据门的标识符来制作门阵列的大小:

Door doors = new Door[Integer.bitCount(doorStock)];

这很快就出现了 IndexOutOfBounds 错误。我并不感到惊讶，因为门数组可以是 0 到 4 之间的任意大小，所以我需要一种新的哈希方法。

我想到的是两个哈希表，一个用于数组索引:

private final int[][] doorhash = {
    /* NORTH  SOUTH   EAST    WEST doorStock*/
    { -1,     -1,     -1,     -1} /*0000*/,
    { -1,     -1,     -1,      0} /*0001*/,
    { -1,     -1,      0,     -1} /*0010*/,
    { -1,     -1,      0,      1} /*0011*/,
    { -1,      0,     -1,     -1} /*0100*/,
    { -1,      0,     -1,      1} /*0101*/,
    { -1,      0,      1,     -1} /*0110*/,
    { -1,      0,      1,      2} /*0111*/,
    {  0,     -1,     -1,     -1} /*1000*/,
    {  0,     -1,     -1,      1} /*1001*/,
    {  0,     -1,      1,     -1} /*1010*/,
    {  0,     -1,      1,      2} /*1011*/,
    {  0,      1,     -1,     -1} /*1100*/,
    {  0,      1,     -1,      2} /*1101*/,
    {  0,      1,      2,     -1} /*1110*/,
    {  0,      1,      2,      3} /*1111*/
};

还有一个，它有助于映射上一个表:

private final int[] directionHash = {
    -1, /*0000*/
     3, /*0001 - WEST*/
     2, /*0010 - EAST*/
    -1, /*0011*/
     1, /*0100 - SOUTH*/
    -1, /*0101*/
    -1, /*0110*/
    -1, /*0111*/
     0, /*1000 - NORTH*/
};

所以我当前的映射函数如下所示:

public Door getDoor(int doorID){
    switch(doorID){
        case NORTH:{
            if(doorExists(NORTH))return doors[doorhash[doorStock][directionHash[NORTH]]];
            else return null;
        }
        case SOUTH:{
            if(doorExists(NORTH))return doors[doorhash[doorStock][directionHash[SOUTH]]];
            else return null;
        }
        case EAST:{
            if(doorExists(NORTH))return doors[doorhash[doorStock][directionHash[EAST]]];
            else return null;
        }
        case WEST:{
            if(doorExists(NORTH))return doors[doorhash[doorStock][directionHash[WEST]]];
            else return null;
        }
    }
    return null;
}

这似乎也能正常工作，但我觉得有一个更简单的解决方案来解决这个问题，或者一个具有更少浪费的哈希表的解决方案。我觉得这不像它应该的那样渐近灵活，或者我把事情复杂化了。什么是更好的方法？

感谢您的宝贵时间!

Answer 1

枚举是你的 friend :

// Each possible direction - with Up/Down added to show extendability.
public enum Dir {
  North,
  South,
  East,
  West,
  Up,
  Down;
}

class Room {
  // The doors.
  EnumSet doors = EnumSet.noneOf(Dir.class);

  // Many other possible constructors.
  public Room ( Dir ... doors) {
    this.doors.addAll(Arrays.asList(doors));
  }

  public boolean doorExists (Dir dir) {
    return doors.contains(dir);
  }
}

在这里让枚举为您完成繁重的工作是很自然的。他们还提供了一个非常高效的现成 EnumSet。