如何在java中创建矩阵的边框？

我有一个矩阵：

所以有两行两列

• 1 2
• 34

我有阅读功能

    for (int i = 0; i < m; i++) {
        for (int j = 1; j < n; j++) {
            try {//    System.out.println("number is ");
                a[i][j] = scanner.nextInt();

            } catch (java.util.NoSuchElementException e) {
                // e.printStackTrace();
            }
        }
    }         //print the input matrix

for（int i=0；i

如何创建矩阵的边框？我看到java中没有索引-1

我想要一个带数字的边框。例如： 0 0 0 0

• 0 0 0 0
• 01120
• 0340
• 0 0 0 0

我应该如何制作边框函数？

因此，您需要一个

（m+2）x（n+2）

矩阵：

// initialize m and n
...
// initialize the matrix with 0s
int a[][] = new int[m+2][n+2];

然后忽略第一个元素（

i

和

j

应跳过

0

）和最后一个元素（

i

应跳过

m+1

，

j

应跳过

n+1

）：

对于（inti=1；i那么，您需要一个
（m+2）x（n+2）
矩阵：

// initialize m and n
...
// initialize the matrix with 0s
int a[][] = new int[m+2][n+2];

然后忽略第一个元素（
i
和
j
应跳过
0
）和最后一个元素（
i
应跳过
m+1
，
j
应跳过
n+1
）：

for（int i=1；i详述我的评论：

如果您首先用文字说明创建边框意味着什么，那么将其从英语翻译成Java是一项简单的任务

让我们看看您给出的两个矩阵：

原件：

1 2
3 4

边界：

0 0 0 0
0 1 2 0
0 3 4 0
0 0 0 0

我们看到，在创建边框时，我们将矩阵的宽度和高度分别增加2（在上下和左右各有一个空的
0
s行），因此我们现在使用4x4矩阵，而不是2x2矩阵，元素的索引增加1（每个元素向右推一步，向下推一步）

用代码表示：

int[][] createBorder(int[][] matrix) {
    //this is our 4x4 matrix
    int[][] borderedMatrix = new int[matrix.length+2][matrix[0].length+2];

    //fill the 4x4 matrix with 0's
    for(int i = 0; i < borderedMatrix.length; i++) {
        for(int j = 0; j < borderedMatrix[0].length; j++) {
            borderedMatrix[i][j] = 0;
        }
    }

    //copy the values of the 2x2 into the 4x4 matrix, but push them one step to the right, and one step downwards
    for(int k = 0; k < matrix.length; k++) {
        for(int l = 0; l < matrix[0].length; l++) {
            borderedMatrix[k+1][l+1] = matrix[k][k];
        }
    }
    return borderedMatrix;
}

int[]]createBorder（int[]]matrix）{
//这是我们的4x4矩阵
int[][]borderedMatrix=新的int[matrix.length+2][matrix[0].length+2]；
//用0填充4x4矩阵
对于（int i=0；i
详细阐述我的评论：

如果您首先用文字说明创建边框意味着什么，那么将其从英语翻译成Java是一项简单的任务

让我们看看您给出的两个矩阵：

原件：

1 2
3 4

边界：

0 0 0 0
0 1 2 0
0 3 4 0
0 0 0 0

我们看到，在创建边框时，我们将矩阵的宽度和高度分别增加2（在上下和左右各有一个空的
0
s行），因此我们现在使用4x4矩阵，而不是2x2矩阵，元素的索引增加1（每个元素向右推一步，向下推一步）

用代码表示：

int[][] createBorder(int[][] matrix) {
    //this is our 4x4 matrix
    int[][] borderedMatrix = new int[matrix.length+2][matrix[0].length+2];

    //fill the 4x4 matrix with 0's
    for(int i = 0; i < borderedMatrix.length; i++) {
        for(int j = 0; j < borderedMatrix[0].length; j++) {
            borderedMatrix[i][j] = 0;
        }
    }

    //copy the values of the 2x2 into the 4x4 matrix, but push them one step to the right, and one step downwards
    for(int k = 0; k < matrix.length; k++) {
        for(int l = 0; l < matrix[0].length; l++) {
            borderedMatrix[k+1][l+1] = matrix[k][k];
        }
    }
    return borderedMatrix;
}

int[]]createBorder（int[]]matrix）{
//这是我们的4x4矩阵
int[][]borderedMatrix=新的int[matrix.length+2][matrix[0].length+2]；
//用0填充4x4矩阵
对于（int i=0；i
首先，您需要创建包含额外行和列的矩阵，例如，在您的示例中是4x4矩阵。它们将0放在边框上

当i==0或i==n-1，j==0或j==n-1时

int a[][] = new int[4][4];
int n,m;
n=4;
m=4;
for(int i=0;i<m;i++){
 for(int j=0;j<n;j++){
  if(i==0 || j==0 || i==m-1 || j==n-1){
   //a[i][j] = 0; 
   a[i][j] = 1;
   }
   System.out.print(a[i][j]+" ");
 }
  System.out.println();
}

int a[][]=新int[4][4]；
int n，m；
n=4；
m=4；
对于（int i=0；i首先，您需要创建具有额外行和列的矩阵，例如，在您的示例中为4x4矩阵。它们将0放在边框上

当i==0或i==n-1，j==0或j==n-1时

int a[][] = new int[4][4];
int n,m;
n=4;
m=4;
for(int i=0;i<m;i++){
 for(int j=0;j<n;j++){
  if(i==0 || j==0 || i==m-1 || j==n-1){
   //a[i][j] = 0; 
   a[i][j] = 1;
   }
   System.out.print(a[i][j]+" ");
 }
  System.out.println();
}

int a[][]=新int[4][4]；
int n，m；
n=4；
m=4；
对于（int i=0；i而言，最简单的方法是创建一个
n+1xm+1
矩阵，用
0
填充边框，然后用原始
nxm
矩阵填充剩余部分

所以如果我有你的例子矩阵

int[][] original = {{1, 2},
                    {3, 4}};
int borderWidth  = original[0].length + 2;
int borderHeight = original.length + 2;
int borderArray = new int[borderHeight][borderWidth];

for (int i = 0; i < borderWidth; i++) {   //border
    borderArray[0][i] = 0;                //populate top row
    borderArray[borderHeight - 1][i] = 0; //populate bottom row
    if (i == 0 || i == borderWidth - 1) { //populate left and right columns
        for (j = 1; j < borderHeight - 1; j++) {
            borderArray[j][i] = 0;
        }
    }
}

for (int i = 0; i < original.length; i++) { //populate middle with original
    System.arraycopy(original[i], 0, borderArray[i+1], 1, original[].length);
}

int[]original={{1,2}，
{3, 4}};
int borderWidth=原始[0]。长度+2；
int borderHeight=original.length+2；
int borderArray=新的int[borderHeight][borderWidth]；
对于（int i=0；i
最简单的方法是创建一个由
n+1xm+1
组成的矩阵，用
0
填充边框，然后用原始
nxm
矩阵填充剩余部分

所以如果我有你的例子矩阵

int[][] original = {{1, 2},
                    {3, 4}};
int borderWidth  = original[0].length + 2;
int borderHeight = original.length + 2;
int borderArray = new int[borderHeight][borderWidth];

for (int i = 0; i < borderWidth; i++) {   //border
    borderArray[0][i] = 0;                //populate top row
    borderArray[borderHeight - 1][i] = 0; //populate bottom row
    if (i == 0 || i == borderWidth - 1) { //populate left and right columns
        for (j = 1; j < borderHeight - 1; j++) {
            borderArray[j][i] = 0;
        }
    }
}

for (int i = 0; i < original.length; i++) { //populate middle with original
    System.arraycopy(original[i], 0, borderArray[i+1], 1, original[].length);
}

int[]original={{1,2}，
{3, 4}};
int borderWidth=原始[0]。长度+2；
int borderHeight=original.length+2；
int borderArray=新的int[borderHeight][borderWidth]；
对于（int i=0；i