Является ли хеширование подходящим решением? Я слишком усложняю?

Перечисления — ваш друг:

// 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, который чрезвычайно эффективен.

Ваше решение, вероятно, является наиболее эффективным по пространству, однако, вероятно, будет неэффективным по времени и, безусловно, наименее понятным для написания.

Простой объектно-ориентированный подход состоял бы в том, чтобы иметь класс Room с 4 booleans либо в массиве, либо независимо по вашему желанию;

public class Room {

    //Consider an ENUM for bonus points
    public static int NORTH=0;
    public static int SOUTH=1;
    public static int EAST=2;
    public static int WEST=3;   

    private boolean[] hasDoor=new boolean[4];

    public Room(boolean northDoor,boolean southDoor,boolean eastDoor,boolean westDoor) {
        setHasDoor(northDoor,NORTH);
        setHasDoor(southDoor,SOUTH);
        setHasDoor(eastDoor,EAST);
        setHasDoor(westDoor,WEST);
    }

    public final  void setHasDoor(boolean directionhasDoor, int direction){
        hasDoor[direction]=directionhasDoor;
    }
    public final boolean  getHasDoor(int direction){
        return hasDoor[direction];
    }


}

Всем ясно, не читая документы или методы, что это делает, и это всегда то, к чему вы должны стремиться в первую очередь.

Затем это можно использовать следующим образом

public static void main(String[] args){
    ArrayList<Room> rooms=new ArrayList<Room>();

    rooms.add(new Room(true,false,true,false));
    rooms.add(new Room(true,true,true,false));

    System.out.println("Room 0 has door on north side:"+rooms.get(0).getHasDoor(NORTH));

}

Или в 2D-массиве, соответствующем вашему плану этажа.

public static void main(String[] args){
    Room[][] rooms=new  Room[10][10]; 

    rooms[0][0]=new Room(true,false,true,false);
    rooms[0][1]=new Room(true,false,true,false);
    //........
    //........
    //other rooms
    //........
    //........

    System.out.println("Room 0,0 has door on north side:"+rooms[0][0].getHasDoor(NORTH));

}

Весь важный вопрос заключается в том, заботитесь ли вы об экономии нескольких килобайт за счет чистого кода и, возможно, скорости выполнения? В ситуации нехватки памяти вы, вероятно, делаете, в противном случае вы этого не сделаете.

Вы определенно переусердствуете с этим. Это может быть разрешено, например, с помощью символов и использования массива char[4] для хранения (максимум) 4 разных символов n, s, w и e.

Вы можете использовать String для сбора информации о дверях, и каждая char будет одной дверью (тогда у вас может быть что-то вроде "nnse", означающее, что есть 2 двери на северной стене, 1 южная дверь и одна восточная дверь).

Вы также можете использовать ArrayList символов и преобразовать их в массив, если хотите. Зависит от того, что вы хотите с этим делать, но есть много способов добиться того, что вы пытаетесь сделать.

И помни, что

Преждевременная оптимизация — корень всех зол

Хорошо, основываясь на комментариях, я решил не усложнять ситуацию дальше. Я буду использовать первое решение, в котором массив doors будет иметь 4 элемента, а функция отображения:

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;
}

Я просто подумал, что это хороший теоретический вопрос, вот и все. Спасибо за ответы!

Хорошо, я согласен на 100%, что Enums — это то, что нужно. Единственное, что я бы посоветовал, тем более, что это логика, применяемая к игре, и вам, вероятно, потребуется где-то хранить информацию, определяющую комнату, — это использовать систему двоичных идентификаторов. Используя такую ​​систему, вы можете хранить бинарное представление того, какие двери доступны в комнате. Эта система хорошо работает, когда вы имеете дело с предметами, где у вас может быть максимум один предмет. В вашем случае в комнате может быть только 1 дверь для каждого направления. Если вы суммируете все двоичные значения для каждой двери в комнате, вы можете сохранить это значение, а затем преобразовать это значение обратно в соответствующие перечисления.

Пример:

public enum Direction {

    NONE (0, 0),
    NORTH (1, 1),
    SOUTH (2, 2),
    EAST (3, 4),
    WEST (4, 8),
    NORTHEAST (5, 16),
    NORTHWEST (6, 32),
    SOUTHEAST (7, 64),
    SOUTHWEST (8, 128),
    UP (9, 256),
    DOWN (10, 512);

    private Integer id;
    private Integer binaryId;

    private Direction(Integer id, Integer binaryId) {
        this.id = id;
        this.binaryId = binaryId;
    }

    public Integer getId() {
        return id;
    }

    public Integer getBinaryId() {
        return binaryId;
    }

    public static List<Direction> getDirectionsByBinaryIdTotal(Integer binaryIdTotal) {
        List<Direction> directions = new ArrayList<Direction>();

        if (binaryIdTotal >= 512) {
            directions.add(Direction.DOWN);
            binaryIdTotal -= 512;
        }
        if (binaryIdTotal >= 256) {
            directions.add(Direction.UP);
            binaryIdTotal -= 256;
        }
        if (binaryIdTotal >= 128) {
            directions.add(Direction.SOUTHWEST);
            binaryIdTotal -= 128;
        }
        if (binaryIdTotal >= 64) {
            directions.add(Direction.SOUTHEAST);
            binaryIdTotal -= 64;
        }
        if (binaryIdTotal >= 32) {
            directions.add(Direction.NORTHWEST);
            binaryIdTotal -= 32;
        }
        if (binaryIdTotal >= 16) {
            directions.add(Direction.NORTHEAST);
            binaryIdTotal -= 16;
        }
        if (binaryIdTotal >= 8) {
            directions.add(Direction.WEST);
            binaryIdTotal -= 8;
        }
        if (binaryIdTotal >= 4) {
            directions.add(Direction.EAST);
            binaryIdTotal -= 4;
        }
        if (binaryIdTotal >= 2) {
            directions.add(Direction.SOUTH);
            binaryIdTotal -= 2;
        }
        if (binaryIdTotal >= 1) {
            directions.add(Direction.NORTH);
            binaryIdTotal -= 1;
        }

        return directions;
    }

}

Я бы даже смоделировал двери в виде перечисления, чтобы в будущем можно было использовать другие типы дверей. Например:

public enum Door { TOP, BOTTOM, LEFT, RIGHT };

public class Room {
    private Set<Door> doors = new HashSet<Door>;
    public Room(Door... doors) {
        //Store doors.
        this.doors = doors;
    }

    public boolean hasDoor(Door door) {
        return this.doors.contains(door);
    }
}

Вы можете преобразовать это:

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;
}

к этому:

public Door getDoor(int doorID){
    int index = 0;
    int id = doorID;
    while(id > 1){
        if(id & 1 == 1)
            return null;
        id = id >>> 1;
        index++;
    }
return doors[index];
}