请帮助我对康威生命游戏的基本java实现
声明：本页面是StackOverFlow热门问题的中英对照翻译，遵循CC BY-SA 4.0协议，如果您需要使用它，必须同样遵循CC BY-SA许可，注明原文地址和作者信息，同时你必须将它归于原作者（不是我）：StackOverFlow
原文地址: http://stackoverflow.com/questions/4058292/
Warning: these are provided under cc-by-sa 4.0 license. You are free to use/share it, But you must attribute it to the original authors (not me):
StackOverFlow
Please help with my basic java implementation of Conway's game of life
提问by user476033
I have spent quite a while trying to write a program to implement Conway's game of life - Link with more info.. I am following some online guides and was given the majority of the functions. I wrote the "next" and "neighbours" methods shown below. Could anyone tell me if these are good implementations, and how they could be made better please ?
我花了很长时间试图编写一个程序来实现康威的生活游戏 -链接更多信息。. 我正在遵循一些在线指南，并获得了大部分功能。我编写了如下所示的“next”和“neighbors”方法。谁能告诉我这些是否是好的实现，以及如何使它们变得更好？
The point of the exercise was to not modify or change any of the other methods and just write the next method ! :)
练习的重点是不要修改或更改任何其他方法，只需编写下一个方法！:)
import java.io.*;
import java.util.Random;
public class Life {
private boolean[][] cells;
public static void main( String[] args ) {
Life generation = new Life( );
for (int i = 0; i != 10; i++) {
System.out.println( generation );
generation.next( );
}
}
// Constructors
public void next (){
int SIZE;
SIZE=cells.length;
boolean[][] tempCells = new boolean [SIZE] [SIZE];
for( int i=0; i<SIZE; i++ ) {
for( int j=0; j<SIZE; j++ ) {
tempCells[i][j] = cells[i][j];
}
}
for (int row = 0; row < cells.length ; row++)
{
for (int col = 0 ; col < cells[row].length ; col++)
{
if ( neighbours(row, col) > 3 || neighbours(row, col) < 2 )
{
tempCells[row][col] = false;
}
else if (neighbours(row, col) == 3 )
{
tempCells[row][col] = true;
}
}
}
cells = tempCells;
}
public int neighbours (int row, int col) {
int acc=0;
for ( int i = row -1; i <= row + 1 ; i++)
{
for (int j = col -1 ; j <= col + 1 ; j++)
{
try {
if (cells[i][j]==true && (i != row || j!=col))
{
acc++;
}
} catch ( ArrayIndexOutOfBoundsException f)
{continue;}
}
}
return acc;
}
// Initialises 6 * 6 grid with Glider pattern.
public Life( ) {
final int SIZE = 8;
// Arguably, this should have been a class (static) array.
final int[][] pairs = {{2,4},{3,3},{1,2},{2,2},{3,2}};
cells = new boolean[ SIZE ][ ];
for (int row = 0; row < SIZE; row ++) {
cells[ row ] = new boolean[ SIZE ];
}
for (int pair = 0; pair < pairs.length; pair ++) {
final int row = pairs[ pair ][ 0 ];
final int col = pairs[ pair ][ 1 ];
cells[ row ][ col ] = true;
}
}
// Initialise size * size grid with random cells.
//public Life( int size ) {
//final Random rand = new Random( );
//cells = new boolean[ size ][ ];
//for (int row = 0; row < size; row ++) {
//cells[ row ] = new boolean[ size ];
//for (int col = 0; col < size; col ++) {
//cells[ row ][ col ] = (rand.nextInt( 2 ) == 0);
//}
//}
//}
// Public methods and helper methods.
@Override
public String toString( ) {
String result = "";
for (int row = 0; row < cells.length; row ++) {
final boolean[] column = cells[ row ];
for (int col = 0; col < column.length; col ++) {
result = result + (column[ col ] ? "x" : ".");
}
result = result + "\n";
}
return result;
}
}
采纳答案by Fred Foo
You don't need to copy the contents of cellsto tempCells(the first nested loop in next). Instead, you can add one extra clause to the if-elsein the next loop. Also, storing the result from neighboursmay be a good idea for both speed and clarity.
您不需要复制cellsto tempCells（中的第一个嵌套循环next）的内容。相反，您可以在下一个循环中向if-添加一个额外的子句else。此外，存储结果neighbours对于速度和清晰度来说可能是一个好主意。
for (int row = 0; row < cells.length ; row++)
for (int col = 0 ; col < cells[row].length ; col++) {
int n = neighbours(row,col);
if (n > 3 || n < 2)
tempCells[row][col] = false;
else if (n == 3)
tempCells[row][col] = true;
else
tempCells[row][col] = cells[row][col];
}
(Apart from that, looks fine, but I haven't run and tested your code.)
（除此之外，看起来不错，但我还没有运行和测试你的代码。）
回答by Tamoghna Chowdhury
Don't use ArrayIndexOutOfBoundException to compute out-of-boundary (OOB) conditions. It kills performance. Better use the wrap-around mechanism to treat your array like a sphere so that you don't encounter OOBs at all. You could try something like this:
不要使用 ArrayIndexOutOfBoundException 来计算边界外 (OOB) 条件。它会扼杀性能。最好使用环绕机制将您的数组视为一个球体，这样您就根本不会遇到 OOB。你可以尝试这样的事情：
public Cell[] getNeighbours(int i, int j) {
int i2 = i - 1, i3 = i + 1, j2 = j - 1, j3 = j + 1;
if (i2 == -1) i2 = board.length - 1;
if (i3 == (board.length)) i3 = 0;
if (j2 == -1) j2 = board[i].length - 1;
if (j3 == (board[i].length)) j3 = 0;
return new Cell[]{board[i2][j2], board[i2][j], board[i2][j3], board[i][j2], board[i][j3], board[i3][j2], board[i3][j], board[i3][j3]};
}
}
Then you can loop through the returned array and check how many of those are alive and return that count.
然后你可以遍历返回的数组并检查其中有多少是存活的并返回该计数。
