给你一个由 1（陆地）和 0（水）组成的的二维网格，请你计算网格中岛屿的数量。
岛屿总是被水包围，并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。
此外，你可以假设该网格的四条边均被水包围。
示例：
输入：grid = [
[1, 1, 1, 1, 0],
[1, 1, 0, 1, 0],
[1, 1, 0, 0, 0],
[0, 0, 0, 0, 0]
]
输出：1

解题思路：

遍历二维数组，如果遇到数字值为1，则将岛屿计数+1，同时将当前项的值修改为0。之后以当前项为参考点依次访问其上下左右的数据项，判断其值是否为1，为1则修改为0，并且以当前数据项为参考点依次访问其上下左右的数据项，如果当前项的值为0，则结束访问。

代码实现：

public class Solution_114 {

    public int numIslands(int[][] grid) {
        if (grid == null || grid.length <= 0) return 0;
        int islandsNum = 0;
        int rows = grid.length;
        int cols = grid[0].length;
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                int val = grid[i][j];
                if (val == 1) {
                    islandsNum++;
                    grid[i][j] = 0;

                    dfs(i, j, grid);
                }
            }
        }
        return islandsNum;
    }

    private void dfs(int i, int j, int[][] grid) {
        int rows = grid.length;
        int cols = grid[0].length;
        // 右
        int right = i + 1;
        if (right < rows) {
            if (grid[right][j] == 1) {
                grid[right][j] = 0;

                dfs(right, j, grid);
            }
        }
        // 下
        int bottom = j + 1;
        if (bottom < cols) {
            if (grid[i][bottom] == 1) {
                grid[i][bottom] = 0;

                dfs(i, bottom, grid);
            }
        }
        // 上
        int top = j - 1;
        if (top >= 0) {
            if (grid[i][top] == 1) {
                grid[i][top] = 0;

                dfs(i, top, grid);
            }
        }
        // 左
        int left = i - 1;
        if (left >= 0) {
            if (grid[left][j] == 1) {
                grid[left][j] = 0;

                dfs(left, j, grid);
            }
        }
    }

    public static void main(String[] args) {
        Solution_114 solution_114 = new Solution_114();
        System.out.println(solution_114.numIslands(new int[][]{
                {1, 1, 1, 1, 0},
                {1, 1, 0, 1, 0},
                {1, 1, 0, 0, 0},
                {0, 0, 0, 0, 0}
        }));
    }
}