用Java实现生命游戏_在java中生命游戏代码怎么实现输出

用Java实现生命游戏

---

一、题目： 编写一个生命游戏：
规则如下：
1. 一个人可以有8个邻居；
2. 一个人若只有一个邻居，在下一代会孤独的死去；
3. 若有2或3个邻居，在下一代依然活着；
4. 若有4个或以上邻居，在下一代会因拥挤而死；
5. 死去的人若有3个邻居，在下一代会复活；
6. 所有的死去或复活都在下一代变化时同时发生。

二、算法思路： 本题中可以理解为一个人住在一个二维矩阵的格子里，如下所示

图中用实心圆圈代表活着的邻居，用空心圆圈代表死去的邻居，一个人最多有上下左右4个，两个对角线4个，一共8个邻居。规则就可以根据周围邻居的存活情况进行下一次状态的判定。

在主函数中我们选定了一个4*4的矩阵，并将矩阵中邻居状态进行初始化，然后引用methods类中的三个方法进行变换。

其中Methods类存放三个方法：

1. check方法，用来检测存放着所有邻居状态的二维矩阵的所有位置，并用point数组，记录对应位置下一轮的状态，用代表1下一代死，2下一代继续活，3下一代复活；
2. getNext方法，用来将二维矩阵存储的邻居状态，根据point数组更新到下一代的状态，并将矩阵返回。
3. printLifeMap方法，用来将二维矩阵中的所有邻居，按照图示的状态打印出来。

三、代码如下：

package Exercise1;

import java.util.Random;
import java.util.Scanner;

    /*
    1.生命小游戏的邻居为上下左右和斜对角一共八个位置;
    2.默认选择4*4的格子。
    3.将默认的格子初始化，并打印输出
    4.使用Methods中的方法生成下一轮的状态，并打印
     */

public class LifeGame {
    public static void main(String[] args) {

        //先设置一个二维数组存储所有的格子
        String[][] lifeMap = new String[4][4];

        Methods me = new Methods();

        //对所有格子进行初始化输入，死为0，活为1
        //随机生成各个位置的邻居情况
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {

                int num = new Random().nextInt(2);
                if (num == 1)
                    lifeMap[i][j] = "●";
                else if (num == 0)
                    lifeMap[i][j] = "○";
            }
        }

        //打印格子初始状态
        System.out.println("初始状态为：");
        me.printLifeMap(lifeMap);
        System.out.println("===========");

        int n = 0;
        int num = 0;//记录变化的次数
        while (n == 0) {

            //用point数组，记录对应位置下一轮的状态，1下一代死，2下一代继续活，3下一代复活
            int[] point = me.check(lifeMap, new int[16]);

            //获得下一次变化后的图形
            lifeMap = me.getNext(lifeMap, point).clone();

            System.out.println("第" + (++num) + "次变化：");

            //打印出来
            me.printLifeMap(lifeMap);
            System.out.println("===========");

            System.out.println("输入0继续进行下一步，输入其他数字退出。");
            n = new Scanner(System.in).nextInt();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

package Exercise1;


public class Methods {

    public Methods() {
    }

    //该方法检测所有位置，并返回对应位置的point数组
    //用point数组，记录对应位置下一轮的状态，1下一代死，2下一代继续活，3下一代复活
    public int[] check(String[][] lifeMap, int[] point) {

        int n = 0;
        //统计周围邻居的情况
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {

                /*
                规则如下，进行判断
                    1.一个人可以有8个邻居；
                    2.一个人若只有一个邻居，在下一代会孤独的死去；
                    3.若有2或3个邻居，在下一代依然活着；
                    4.若有4个或以上邻居，在下一代会因拥挤而死；
                    5.死去的人若有3个邻居，在下一代会复活；
                    6.所有的死去或复活都在下一代变化时同时发生。
                */

                //用life变量记录周围活着的邻居个数
                int life = 0;

                //1.判断正下方的位置
                if (i + 1 < 4 && lifeMap[i + 1][j].equals("●")) {
                    life++;
                }

                //2.判断右下位置
                if (i + 1 < 4 && j + 1 < 4 && lifeMap[i + 1][j + 1].equals("●")) {
                    life++;
                }

                //3.判断左下位置
                if (i + 1 < 4 && j - 1 >= 0 && lifeMap[i + 1][j - 1].equals("●")) {
                    life++;
                }

                //4.判断右侧位置
                if (j + 1 < 4 && lifeMap[i][j + 1].equals("●")) {
                    life++;
                }

                //5.判断左侧位置
                if (j - 1 >= 0 && lifeMap[i][j - 1].equals("●")) {
                    life++;
                }

                //6.判断正上方位置
                if (i - 1 >= 0 && lifeMap[i - 1][j].equals("●")) {
                    life++;
                }

                //7.判断右上位置
                if (i - 1 >= 0 && j + 1 < 4 && lifeMap[i - 1][j + 1].equals("●")) {
                    life++;
                }

                //8.判断左上位置
                if (i - 1 >= 0 && j - 1 >= 0 && lifeMap[i - 1][j - 1].equals("●")) {
                    life++;
                }

                //用一个数组，记录对应位置下一轮的状态，1下一代死，2下一代继续活，3下一代复活
                if (lifeMap[i][j].equals("●")) {
                    if (life == 1)
                        point[n] = 1;
                    else if (life == 2 || life == 3)
                        point[n] = 2;
                    else if (life >= 4)
                        point[n] = 1;
                } else {
                    if (life == 3)
                        point[n] = 3;
                }
                n++;
            }
        }
        return point;
    }

    public String[][] getNext(String[][] lifeMap, int[] point) {

        int n = 0;
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {

                //变更状态
                if (point[n] == 1)
                    lifeMap[i][j] = "○";
                if (point[n] == 3)
                    lifeMap[i][j] = "●";

                n++;
            }
        }
        return lifeMap;
    }

    public void printLifeMap(String[][] lifeMap){
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                if (j == 3)
                    System.out.println(lifeMap[i][j] + " ");
                else
                    System.out.print(lifeMap[i][j] + " ");
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

四、运行结果：


之后的状态无限重复。

五、总结：

以上是我自己探索的一种解法，时间复杂度应该是o(n^2)，如果有大佬发现代码中问题，还请留言给我，我会再作修改，谢谢~