可视化康威'；Java中的生活游戏（可能使用GUI）？

我刚刚完成了。我想知道什么是一个很好的方式来可视化的一代人的进步。到目前为止，我有一个简单的打印声明：

        System.out.println();
        for (int j= 0; j < n; j++){
            for (int k= 0; k < n; k++){
                System.out.print(board[j][k] + "\t");
            }
            System.out.print("\n");
        }

System.out.println（）；
对于（int j=0；j

这对于测试来说是可以的，但是我真的希望看到一些复杂的结构。我的问题是：我应该如何推进可视化？也许我可以构建某种GUI（尽管我还没有这样做）

以下是我如何构建算法的总体思路：

    int i= 0;
    while (i < 3){
        int[][] temp= board;
        for (int j= 0; j < n; j++){
            for (int k= 0; k < n; k++){
                //Update temp array according to Conway's rules. 
            }
        }
        board= temp;
        i++;
        //Print statements
    }

inti=0；
而（i<3）{
int[][]温度=电路板；
对于（int j=0；j

---

所以，我的确切问题是：如何用它构建GUI

gui：我在学校的时候，我们还实现了生活游戏，我们制作了一个简单的gui，但它很有趣，也是一个很好的实践。我们创造了一种“卡片布局”，用不同颜色的简单、小图像将生活对象放入其中。（颜色=对象的状态）。这是一个简单的可视化方法。此外，您可以清楚地看到对象是如何根据其邻居而变化的

---

刚刚发现了一个不错的，有人还实现了一个gui（带有屏幕截图）。这不是完整的代码，但您可能会知道如何做。

很久以前我就没有接触过这一点，这是我用java实现的，很有趣

基本上我只是把活细胞画成4x4个红色方块。更新方法有一些可以优化的if测试，但我认为性能增益可以忽略不计。在下面的代码中，值为1的磁贴处于活动状态，值为0的磁贴处于不活动状态

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.beans.Transient;
import java.util.Random;

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.Timer;


@SuppressWarnings("serial")
public class ConwaysGameOfLife extends JPanel {

    private int[][] grid;
    private static final Random rnd = new Random();
    private int generationCounter;

    public ConwaysGameOfLife(int width, int height) {
        this.grid = new int[width / 4][height / 4];
        setupGrid();
    }

    private void setupGrid() {
        for (int[] row : grid) {
            for (int j = 0; j < row.length; j++) {
                if (rnd.nextDouble() < 0.92)
                    continue;
                row[j] = rnd.nextInt(2);
            }
        }
    }

    public void updateGrid() {
        for (int i = 0; i < grid.length; i++) {
            for (int j = 0; j < grid[i].length; j++) {
                applyRule(i, j);
            }
        }
    }


    private void applyRule(int i, int j) {
        int left = 0, right = 0, up = 0, down = 0;
        int dUpperLeft = 0, dUpperRight = 0, dLowerLeft = 0, dLowerRight = 0;

        if (j < grid.length - 1) {
            right = grid[i][j + 1];
            if(i>0)
                dUpperRight = grid[i - 1][j + 1];
            if (i < grid.length - 1)
                dLowerRight = grid[i + 1][j + 1];
        }

        if (j > 0) {
            left = grid[i][j - 1];
            if (i > 0)
                dUpperLeft = grid[i - 1][j - 1];
            if (i< grid.length-1)
                dLowerLeft = grid[i + 1][j - 1];
        }

        if (i > 0)
            up = grid[i - 1][j];
        if (i < grid.length - 1)
            down = grid[i + 1][j];

        int sum = left + right + up + down + dUpperLeft + dUpperRight
                + dLowerLeft
                + dLowerRight;

        if (grid[i][j] == 1) {
            if (sum < 2)
                grid[i][j] = 0;
            if (sum > 3)
                grid[i][j] = 0;
        }

        else {
            if (sum == 3)
                grid[i][j] = 1;
        }

    }

    @Override
    @Transient
    public Dimension getPreferredSize() {
        return new Dimension(grid.length * 4, grid[0].length * 4);
    }

    @Override
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);
        Color gColor = g.getColor();

        g.drawString("Generation: " + generationCounter++, 0, 10);
        for (int i = 0; i < grid.length; i++) {
            for (int j = 0; j < grid[i].length; j++) {
                if (grid[i][j] == 1) {
                    g.setColor(Color.red);
                    g.fillRect(j * 4, i * 4, 4, 4);
                }
            }
        }

        g.setColor(gColor);
    }

    public static void main(String[] args) {
        final ConwaysGameOfLife c = new ConwaysGameOfLife(800, 800);
        JFrame frame = new JFrame();
        frame.getContentPane().add(c);
        frame.pack();
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setLocationByPlatform(true);
        frame.setVisible(true);
        new Timer(100, new ActionListener() {

            @Override
            public void actionPerformed(ActionEvent e) {
                c.updateGrid();
                c.repaint();
            }
        }).start();
    }
}

导入java.awt.Color；
导入java.awt.Dimension；
导入java.awt.Graphics；
导入java.awt.event.ActionEvent；
导入java.awt.event.ActionListener；
导入java.beans.Transient；
导入java.util.Random；
导入javax.swing.JFrame；
导入javax.swing.JPanel；
导入javax.swing.Timer；
@抑制警告（“串行”）
公共类ConwaysGameOfLife扩展JPanel{
私有int[][]网格；
私有静态最终随机rnd=新随机（）；
专用整数生成计数器；
公共通道生活模式（内部宽度、内部高度）{
this.grid=新整数[width/4][height/4]；
setupGrid（）；
}
私有void setupGrid（）{
对于（int[]行：网格）{
对于（int j=0；j0）
dUpperRight=网格[i-1][j+1]；
如果（i<网格长度-1）
dLowerRight=栅格[i+1][j+1]；
}
如果（j>0）{
左=网格[i][j-1]；
如果（i>0）
dUpperLeft=网格[i-1][j-1]；
如果（i<网格长度-1）
dLowerLeft=网格[i+1][j-1]；
}
如果（i>0）
向上=网格[i-1][j]；
如果（i<网格长度-1）
向下=网格[i+1][j]；
整数和=左+右+上+下+左+右
+德洛维夫特
+德洛维莱特；
如果（网格[i][j]==1）{
如果（总和<2）
网格[i][j]=0；
如果（总和>3）
网格[i][j]=0；
}
否则{
如果（总和=3）
网格[i][j]=1；
}
}
@凌驾
@短暂的
公共维度getPreferredSize（）{
返回新维度（grid.length*4，grid[0].length*4）；
}
@凌驾
受保护组件（图形g）{
超级组件（g）；
Color gColor=g.getColor（）；
g、 抽绳（“生成：+generationCounter++，0，10）；
对于（int i=0；i

一次成功地得到了这样一个漂亮的图案

---

哦，谢谢你。我会查出来的@ButtingerXaver将其作为一个答案发布。这里是。是的，尽管爆炸性增长有点令人担忧，希望有一些好的孤独生命形式，但我认为这需要一个调整，如果一个细胞被更新，它的邻居直到下一代才看到它的新状态。我认为你的GoL实现是错误的。它不会产生人们期望在GoL中看到的模式类型-例如，没有“步行者”。检查我对你说的话