用Java填充布尔数组

作为一个相当绿色的Java代码编写者，我为自己写了一个简单的文本冒险设置了巨大的挑战。 不出所料，我已经遇到困难了！

我试图给我的Location类属性来存储它包含的出口。 为此，我使用了一个布尔数组，基本上保存表示每个出口的真/假值。 我并不完全相信这一点

a）这是做这件事最有效的方法

b）我使用正确的代码填充数组。

我会很感激任何和所有的反馈，即使它是一个完整的代码over-haul！

目前，当实例化一个位置时，我生成一个String，我通过setExits方法发送：

String e = "NSU"; secretRoom.setExits(e); 

在Location类中，setExits如下所示：

 public void setExits(String e) { if (e.contains("N")) bexits[0] = true; else if (e.contains("W")) bexits[1] = true; else if (e.contains("S")) bexits[2] = true; else if (e.contains("E")) bexits[3] = true; else if (e.contains("U")) bexits[4] = true; else if (e.contains("D")) bexits[5] = true; } 

老实说，我认为这看起来特别笨重，但我想不出有另一种方法去做。 我现在也不完全确定如何编写getExits方法…

任何帮助将受到欢迎！

Answer 1

是否有任何理由，你为什么这样用String来做，而不是通过booleans ，即

 public void setExits(boolean N, boolean E, boolean S, boolean W, boolean U, boolean D) 

还是有安装者 ？

 public void setNorthOpen(boolean open) { bexits[4] = open; } 

其次，为什么你将出口存储为布尔数组，这是一个小的有限集合，为什么不呢

 boolean N,S,E,W,U,D; 

那么你不需要跟踪数组中每个方向的数字。

也

这是一个正确的答案（如果不是像@gexicide那样完全最优化的话），但是我完全鼓励任何人在这里看看其他的答案，看看如何用Java以不同的方式完成事情。

备查

代码的工作属于Code Review ，而不是Stack Overflow。 虽然@kajacx指出，这个代码不应该 – 事实上的工作。

Answer 2

最有效和最具performance力的方式如下：

使用enum s作为Exits并使用EnumSet来存储它们。 EnumSet是一个高效的Set实现，它使用一个位字段来表示枚举常量。

这里是你如何做到这一点：

 public enum Exit { North, West, South, East, Up, Down; } EnumSet<Exit> set = EnumSet.noneOf(Exit.class); // An empty set. // Now you can simply add or remove exits, everything will be stored compactly set.add(Exit.North); // Add exit set.contains(Exit.West); // Test if an exit is present set.remove(Exit.South); //Remove an exit 

枚举集合将在一个单独的内部存储所有的退出，所以你的代码是expression，快速，并节省了大量的内存。

Answer 3

好的，首先，你的setExits()方法不能按预期的方式工作，如果setExits() -else将最大限度地执行1个代码分支，例如：

 if (e.contains("N")) bexits[0] = true; else if (e.contains("W")) bexits[1] = true; 

即使e包含N和W ，也只会设置bexits[0] 。 此方法也只会添加退出（例如调用setExits("")不会删除任何现有的退出。

我会改变这种方法：

 bexits[0] = e.contains("N"); bexits[1] = e.contains("W"); ... 

此外，我definetly不会记得，北在索引0，西1，…所以一个普遍的做法是命名您的索引使用最终的静态常量：

 public static final int NORTH = 0; public static final int WEST = 1; ... 

然后你可以写你的setExits方法：

 bexits[NORTH] = e.contains("N"); bexits[WEST] = e.contains("W"); ... 

（更可读）

最后，如果你希望你的代码更好地安排，你可以创build一个Exits类来表示可用的退出，并且由布尔数组支持。 然后在你创build你的string的地方，你可以创build这个类来保存你自己的工作，然后parsing一个string。

编辑：

作为@gexicide的答案，有一个非常方便的类EnumSet这可能会更好地表示出口比bollean数组。

Answer 4

在另一个答案中的EnumSet是最好的方法来做到这一点，我只是想为未来添加一件事情，当你开始看不仅是你可以移动，而是你移动到的地方。

和EnumSet你也有EnumMap 。

如果你定义一个Room类/接口，那么你可以在Room类里面

 Map<Direction, Room> exits = new EnumMap<>(Direction.class); 

您现在可以将链接添加到地图中，如下所示：

 exits.put(Direction.NORTH, theRoomNorthOfMe); 

那么你的代码在房间之间移动可以是非常普遍的目的：

 Room destination=currentRoom.getExit(directionMoved); if (destination == null) { // Cannot move that way } else { // Handle move to destination } 

Answer 5

我会创build一个Exit枚举，并在Location类中设置一个Exit对象列表。

所以它会是这样的：

 public enum Exit { N, S, E, W, U, D } List<Exit> exits = parseExits(String exitString); location.setExits(exits); 

Answer 6

考虑到你的代码是什么样的，这是我可以实现的最具可读性的实现：

 public class Exits { private static final char[] DIRECTIONS = "NSEWUD".toCharArray(); public static void main(String... args) { String input = "NSE"; boolean[] exits = new boolean[DIRECTIONS.length]; for(int i = 0; i< exits.length; i++) { if (input.indexOf(DIRECTIONS[i]) >= 0) { exits[i] = true; } } } } 

这就是说，有一些更清洁的解决scheme可能。 就我个人而言，我会去与枚举和EnumSet 。

顺便说一下，你的原始代码是不正确的，因为它会将数组中的最多一个值设置为true。

Answer 7

如果您将出口定义为string，则应该使用它。 我会这样做：

 public class LocationWithExits { public static final String NORTH_EXIT="[N]"; public static final String SOUTH_EXIT="[S]"; public static final String EAST_EXIT="[E]"; public static final String WEST_EXIT="[W]"; private final String exitLocations; public LocationWithExits(String exitLocations) { this.exitLocations = exitLocations; } public boolean hasNorthExit(){ return exitLocations.contains(NORTH_EXIT); } public static void main(String[] args) { LocationWithExits testLocation=new LocationWithExits(NORTH_EXIT+SOUTH_EXIT); System.out.println("Has exit on north?: "+testLocation.hasNorthExit()); } } 

使用布尔数组可能会导致很多问题，如果你忘记了什么意思bexits [0]。 它是北方还是南方呢？ 等等

或者你可以使用枚举和可用的退出列表。 然后在methidtesting中，如果列表包含某个枚举值

Answer 8

就我个人而言，我认为你可以使用枚举来绕过它，然后进行如下操作：

 public void setExits(String e) { if (e.contains("N")) bexits[0] = true; else if (e.contains("W")) bexits[1] = true; else if (e.contains("S")) bexits[2] = true; else if (e.contains("E")) bexits[3] = true; else if (e.contains("U")) bexits[4] = true; else if (e.contains("D")) bexits[5] = true; } 

成

 public enum Directions { NORTH("N"), WEST("W"), SOUTH("S"), EAST("E"), UP("U"), DOWN("D"); private String identifier; private Directions(String identifier) { this.identifier = identifier; } public String getIdentifier() { return identifier; } } 

然后做：

 public void setExits(String e) { String[] exits = e.split(" "); for(String exit : exits) { for(Directions direction : Directions.values()) { if(direction.getIdentifier().equals(exit)) { bexits[direction.ordinal()] = true; break; } } } } 

虽然把它写下来了，但我真的不能告诉你它是否好多了。 增加新的方向比较容易，这是肯定的。

Answer 9

答案中列出的所有方法都很好。 但是我认为您需要采取的方法取决于您将要使用退出字段的方式。 例如，如果要将string作为string处理，那么Ross Drews方法将需要很多if-else条件和variables。

 String exit = "NE"; String[] exits = exit.split(" "); boolean N = false, E = false, S = false, W = false, U = false, D = false; for(String e : exits){ if(e.equalsIgnoreCase("N")){ N = true; } else if(e.equalsIgnoreCase("E")){ E = true; } else if(e.equalsIgnoreCase("W")){ W= true; } else if(e.equalsIgnoreCase("U")){ U = true; } else if(e.equalsIgnoreCase("D")){ D = true; } else if(e.equalsIgnoreCase("S")){ S = true; } } setExits(N, E, S, W, U, D); 

此外，如果你有一个退出，你想检查一个位置是否有特定的退出，那么你将不得不这样做

 public boolean hasExit(String exit){ if(e.equalsIgnoreCase("N")){ return this.N; // Or the corresponding getter method } else if(e.equalsIgnoreCase("E")){ return this.E; } else if(e.equalsIgnoreCase("W")){ return this.W; } else if(e.equalsIgnoreCase("U")){ return this.U; } else if(e.equalsIgnoreCase("D")){ return this.D; } else if(e.equalsIgnoreCase("S")){ return this.S; } } 

所以如果你想把它作为一个string来操作，我认为最好的办法是去列表和枚举。 通过这种方式，你可以做很多方法，如hasExit，hasAnyExit，hasAllExits，hasNorthExit，hasSouthExit，getAvailableExits等等。 考虑使用列表（或设置）的退出数量（6）不会是开销。 例如

枚举

 public enum EXIT { EAST("E"), WEST("W"), NORTH("N"), SOUTH("S"), UP("U"), DOWN("D"); private String exitCode; private EXIT(String exitCode) { this.exitCode = exitCode; } public String getExitCode() { return exitCode; } public static EXIT fromValue(String exitCode) { for (EXIT exit : values()) { if (exit.exitCode.equalsIgnoreCase(exitCode)) { return exit; } } return null; } public static EXIT fromValue(char exitCode) { for (EXIT exit : values()) { if (exit.exitCode.equalsIgnoreCase(String.valueOf(exitCode))) { return exit; } } return null; } } 

Location.java

 import java.util.ArrayList; import java.util.List; public class Location { private List<EXIT> exits; public Location(){ exits = new ArrayList<EXIT>(); } public void setExits(String exits) { for(char exitCode : exits.toCharArray()){ EXIT exit = EXIT.fromValue(exitCode); if(exit != null){ this.exits.add(exit); } } } public boolean hasExit(String exitCode){ return exits.contains(EXIT.fromValue(exitCode)); } public boolean hasAnyExit(String exits){ for(char exitCode : exits.toCharArray()){ if(this.exits.contains(EXIT.fromValue(exitCode))){ return true; } } return false; } public boolean hasAllExit(String exits){ for(char exitCode : exits.toCharArray()){ EXIT exit = EXIT.fromValue(exitCode); if(exit != null && !this.exits.contains(exit)){ return false; } } return true; } public boolean hasExit(char exitCode){ return exits.contains(EXIT.fromValue(exitCode)); } public boolean hasNorthExit(){ return exits.contains(EXIT.NORTH); } public boolean hasSouthExit(){ return exits.contains(EXIT.SOUTH); } public List<EXIT> getExits() { return exits; } public static void main(String args[]) { String exits = "NEW"; Location location = new Location(); location.setExits(exits); System.out.println(location.getExits()); System.out.println(location.hasExit('W')); System.out.println(location.hasAllExit("NW")); System.out.println(location.hasAnyExit("UD")); System.out.println(location.hasNorthExit()); } } 

Answer 10

为什么不这样做，如果你想要一个短代码：

 String symbols = "NWSEUD"; public void setExits(String e) { for (int i = 0; i < 6; i++) { bexits[i] = e.contains(symbols.charAt(i)); } } 

Answer 11

如果你想要一个通用的解决scheme，你可以使用一个映射 ，它从一个键（在你的情况W，S，E ..）映射到一个相应的值（在你的情况下是一个布尔值）。

当你做一个set ，你更新了关键的值。 当你做一个get ，你可以拿一个参数键，并简单地检索该键的值。 这个function已经存在于地图中，称为put和get 。

Answer 12

我真的很喜欢从string分配出口的想法，因为它使得简短和可读的代码。 一旦完成，我不明白你为什么要创build一个布尔数组。 如果你有一个string，只要使用它，虽然你可能想要添加一些validation，以防止意外分配包含不需要的字符的string：

 private String exits; public void setExits(String e) { if (!e.matches("[NSEWUD ]*")) throw new IllegalArgumentException(); exits = e; } 

唯一的另外一件事，我会添加一个方法canExit ，你可以调用一个方向参数; 例如if (location.canExit('N')) ... ：

 public boolean canExit(char direction) { return exits.indexOf(direction) >= 0; } 

我喜欢枚举，但是在这里使用它们似乎对我来说是过度工程，这将很快变得烦人。

---

**编辑**：其实，不要这样做。 它回答了错误的问题，它做了一些不需要做的事情。 我刚刚注意到@ TimB的答案是使用地图（EnumMap）将方向与房间相关联。 这说得通。

我仍然觉得如果你只需要跟踪退出的存在 ，一个string是简单而有效的，而其他任何东西都会使它过于复杂。 但是，只有知道哪些出口可用是没有用的。 你会想要经过这些出口，除非你的游戏有一个非常简单的布局，否则代码将不可能为每个方向推断正确的空间，所以你需要明确地将每个方向与另一个房间相关联。 所以似乎没有任何实际的使用方法“setExits”接受一个方向列表（不pipe它是如何在内部实现的）。

Answer 13

 public void setExits(String e) { String directions="NwSEUD"; for(int i=0;i<directions.length();i++) { if(e.contains(""+directions.charAt(i))) { bexits[i]=true; break; } } } 

做同样事情的迭代方式

Answer 14

应该用switch语句replaceelse if长链。

只要效率不是问题， Enum就是存储这些值的最具performance力的方法。 请记住， enum是一个类，所以创build一个新的枚举与相应的开销相关联。