输入一个矩阵，按照从外向里依顺序一次打印

输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，
例如，如果输入如下4 X 4矩阵： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 
则依次打印出数字1,2,3,4,8,12,16,15,14,13,9,5,6,7,11,10.

解法一：

int[][] matrix = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}, {13, 14, 15, 16}};
        //int[][] matrix=new int[0][0];
        System.out.println(printMatrix(matrix));
        ArrayList<Integer> integers = new ArrayList<>();
        for (int i = 0; i < (matrix.length + 1) / 2; i++) {
            for (int j = i; j < matrix[i].length - i; j++) {
                integers.add(matrix[i][j]);
            }
            for (int k = i + 1; k < matrix.length - i; k++) {
                integers.add(matrix[k][matrix[i + 1].length - 1 - i]);
            }
            for (int m = matrix[matrix.length - i - 1].length - i - 2; m >= i; m--) {
                integers.add(matrix[matrix.length - i - 1][m]);
            }
            for (int n = matrix.length - i - 2; n > i; n--) {
                integers.add(matrix[n][i]);
            }
        }
        System.out.println(integers);

原理：用外层循环控制循环次数，内层循环控制指针指向的位置；首先从左至右横向打印i从零号未开始打印至最后一个即从i打印至第一个一维数组元素索引下标减i；然后纵向从上而下打印，第一个元素未从左至右横向打印的最后一个元素，所以总向打印应该从第二个元素开始，即为二位数组第二行最后一个元素，依次纵向打印即为：第k行（第k个一维数组）中的最后一个元素；然后则是从右向左打印，第一次循环即为最后一行元素倒叙打印，与上同理第一个元素以纵向打印，所以从第二个元素打印即可；最后从下而上纵向打印与上不同之处为第一个元素以及最后一个元素都已打印过，只需要打印中间部分其索引号空间为：二位数组总长度减1再减1，第一个减一是因为，索引号从零开始，第二个减一是因为最后一个元素已打印过，减i是为了避免上一次打印过的再次打印；用二位数组减i是为了确保每一次指针都指向每一次循环的最外层。

解法二：

package matrix;

import org.testng.annotations.AfterTest;

import java.util.ArrayList;

public class Matrix4 {
    public static void main(String[] args) {
        int[][] matrix = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}, {13, 14, 15, 16}};
       
        System.out.println(printMatrix(matrix));

    }

    //@Test
    public static ArrayList<Integer> printMatrix(int[][] matrix) {
        ArrayList<Integer> res = new ArrayList<Integer>();
        int m = matrix.length;
        if (m == 0)
            return res;
        int n = matrix[0].length;
        boolean[][] visted = new boolean[m][n];
        for (int i = 0; i < ((m + 1) / 2); i++) {
            for (int top = 0; top < n; top++)
                if (!visted[i][top]) {
                    res.add(matrix[i][top]);
                    visted[i][top] = true;
                }
            for (int right = 0; right < m && (n - 1 - i) >= 0; right++)
                if (!visted[right][n - 1 - i]) {
                    res.add(matrix[right][n - 1 - i]);
                    visted[right][n - 1 - i] = true;
                }
            for (int button = n - 1; button >= 0 && (m - 1 - i) >= 0; button--)
                if (!visted[m - 1 - i][button]) {
                    res.add(matrix[m - 1 - i][button]);
                    visted[m - 1 - i][button] = true;
                }
            for (int left = m - 1; left >= 0 && i < n; left--)
                if (!visted[left][i]) {
                    res.add(matrix[left][i]);
                    visted[left][i] = true;
                }
        }
        return res;
    }
}

原理：首先根据所列出的矩阵求取出总的二位数组长度，以及内部一维数组长度，即矩阵的长与宽；然后同步生成一个boolean型的同大小矩阵，其默认值为false，没打印一个元素就把对应位置的boolea值修改为true，每一次打印判断该位置的值是否为false，如果不是false，则自加一指向下一个元素知道为false则打印

package matrix;

import org.testng.annotations.AfterTest;

import java.util.ArrayList;

public class Matrix4 {
    public static void main(String[] args) {
        int[][] matrix = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}, {13, 14, 15, 16}};
        //int[][] matrix=new int[0][0];
        System.out.println(printMatrix(matrix));
        ArrayList<Integer> integers = new ArrayList<>();
        for (int i = 0; i < (matrix.length + 1) / 2; i++) {
            for (int j = i; j < matrix[i].length - i; j++) {
                integers.add(matrix[i][j]);
            }
            for (int k = i + 1; k < matrix.length - i; k++) {
                integers.add(matrix[k][matrix[i + 1].length - 1 - i]);
            }
            for (int m = matrix[matrix.length - i - 1].length - i - 2; m >= i; m--) {
                integers.add(matrix[matrix.length - i - 1][m]);
            }
            for (int n = matrix.length - i - 2; n > i; n--) {
                integers.add(matrix[n][i]);
            }
        }
        System.out.println(integers);
    }

    //@Test
    public static ArrayList<Integer> printMatrix(int[][] matrix) {
        ArrayList<Integer> res = new ArrayList<Integer>();
        int m = matrix.length;
        if (m == 0)
            return res;
        int n = matrix[0].length;
        boolean[][] visted = new boolean[m][n];
        for (int i = 0; i < ((m + 1) / 2); i++) {
            for (int top = 0; top < n; top++)
                if (!visted[i][top]) {
                    res.add(matrix[i][top]);
                    visted[i][top] = true;
                }
            for (int right = 0; right < m && (n - 1 - i) >= 0; right++)
                if (!visted[right][n - 1 - i]) {
                    res.add(matrix[right][n - 1 - i]);
                    visted[right][n - 1 - i] = true;
                }
            for (int button = n - 1; button >= 0 && (m - 1 - i) >= 0; button--)
                if (!visted[m - 1 - i][button]) {
                    res.add(matrix[m - 1 - i][button]);
                    visted[m - 1 - i][button] = true;
                }
            for (int left = m - 1; left >= 0 && i < n; left--)
                if (!visted[left][i]) {
                    res.add(matrix[left][i]);
                    visted[left][i] = true;
                }
        }
        return res;
    }
}