【发布时间】：2013-11-07 08:00:08
【问题描述】：
我编写了一个 2D 平台游戏，我需要有（最多 4 个）门的房间。我用 Java 写的，但语言无关紧要。
每个房间可以有 4 扇门，分别位于顶部、底部和侧面。我称他们为NORTH、SOUTH、EAST 和WEST。当我建造一个房间时，我只给它一个整数，整数中的每一位代表一扇门。
例如，如果我想要一个有 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 扇门。
起初我所做的似乎是最简单的：门数组总是有 4 个元素，而我不会使用的索引将保持为空。
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;
}
这似乎也可以正常工作，但我觉得有一个更简单的解决方案可以解决这个问题，或者使用较少浪费的哈希表。我觉得这不像它应该的那样渐近灵活，或者我把事情复杂化了。什么是更好的方法？
感谢您的宝贵时间！
【问题讨论】：
-
没有门的房间不是房间，所以
0000是非法值。 -
“这样阵列可能会因为未使用的元素而浪费空间”——除非您拥有数百万个房间，否则无需担心。您的数组将存储对 Door 对象的引用，而不是对象本身（即 C++ 术语中的指针），因此 Door 类的大小与无门 null 无关。
-
你为什么要这样做，它有一种疯狂的感觉。 4 个布尔值有什么问题？
-
除了 Rups 评论：您正在尝试优化 Door 类中浪费空间的可能性，这导致了这个问题。这可能表明你想多了 - 过早的优化，万恶之源，yadda yadda。
-
@PeterRader：如果您使用传送，则不会：-)