for(int m = Math.max(0, i - 1); m < Math.min(btn.length, i + 1); m++)

  for(int n = Math.max(0, j - 1); n < Math.min(btn[m].length, j + 1); n++)

    if(btn[m][n].getText().equals("*"))

      countMine++;

import java.util.Random;



public class MineTest {



    public static void main(String[] args) {

        Mine mine = new Mine(10, 10, 35);

        char[][] mineArray = mine.toArray();

        Mine.printMineArray(mineArray);

    }

}



class Mine {



    /**

     * 雷阵列

     */

    private char[][] mineArray;



    /**

     * 雷的总数

     */

    private int total;



    /**

     * 有雷时的标记

     */

    public final static char MINE = '#';



    /**

     * 周围无雷时的标记

     */

    public final static char BLANK = '0';



    public Mine(int height, int width, int total) {

        if(height * width < total) {

            throw new IllegalArgumentException(total + " is too many, total must be less than or equal to " + (height * width));

        }

        this.total = total;

        init(height, width);

    }



    public int getTotal() {

        return total;

    }



    public char[][] toArray() {

        return this.mineArray.clone();

    }



    /**

     * 输出雷阵列的工具方法

     * @param mineArray 雷阵列

     */

    public static void printMineArray(char[][] mineArray) {

        for(int i = 0; i < mineArray.length; i++) {

            for(int j = 0; j < mineArray[i].length; j++) {

                System.out.printf("%2c", mineArray[i][j]);

            }

            System.out.println();

        }

    }



    /**

     * 初始化雷阵列

      * @param height 阵列的行数

      * @param width 阵列的列数

      */

    private void init(int height, int width) {

        mineArray = new char[height][width];

        Random r = new Random();

        int y = 0, x = 0, t = 0;



        // 置雷

        while(t < total) {

            y = r.nextInt(height);

            x = r.nextInt(width);

            if (mineArray[y][x] != MINE) {

                pubMine(y, x);

                t++;

            }

        }



        // 将空白处置为周围无雷标记

        for (int i = 0, m = mineArray.length; i < m; i++) {

            for (int j = 0, n = mineArray[i].length; j < n; j++) {

                if(mineArray[i][j] == 0) {

                    mineArray[i][j] = BLANK;

                }

            }

        }

    }



    /**

     * 置雷，并在九宫周围单元格中置上单元格周围雷的数量

      * @param y 纵坐标

      * @param x 横坐标

      */

    private void pubMine(int y, int x) {

        // 扫描整个九宫

        for(int i = y - 1; i <= y + 1; i++) {

            // 行值在范围之外时忽略

            if(i < 0 || i > mineArray.length - 1) {

                continue;

            }



            for(int j = x - 1; j <= x + 1; j++) {

                // 列值在范围之外时忽略

                if(j < 0 || j > mineArray.length - 1 ) {

                    continue;

                }

                // 在九宫中心位置时置雷

                if(i == y && j == x) {

                    mineArray[i][j] = MINE;

                }

                // 如果周围单元格为雷时忽略

                if(mineArray[i][j] == MINE) {

                    continue;

                }



                if(mineArray[i][j] == 0) {

                    // 周围单元格为空时，标记为“1”

                    mineArray[i][j] = '1';

                }else{

                    // 周围单元格不为空时，标记为当前数值增加1

                    mineArray[i][j] += 1;

                }

            }

        }

    }

}