本文目录一览：

1. java 定义一个并二维数组矩阵输出
2. 用java声明Matrix类表示矩阵，使用二维数组存储矩阵元素，实现以下方法：
3. java 中任意输入一个二维数组，然后再以矩阵的形式输出此数组。
4. java 二维数组，输入如下的方阵
5. java定义一个二维数组,通过数组法输出一个九乘九(九行九列的方阵图)

java 定义一个并二维数组矩阵输出

1. int类型定义的数组，初始化默认是0
2. String类型定义的数组，默认值是null
3. char类型定义的数组，默认值是0对应的字符
4. double类型定义的数组，默认值是0.0
5. float类型定义的数组，默认值是0.0

用java声明Matrix类表示矩阵，使用二维数组存储矩阵元素，实现以下方法：

public class Matrix {
    private static String matrix_A;
    private int mx[][], m, n;
    public Matrix(int r, int c) {
        m = r;
        n = c;
        mx = new int[m][n];
        iniMatrix();
    }
    public Matrix() {
        m = 3;
        n = 3;
        mx = new int[3][3];
        iniMatrix();
    }
    public void iniMatrix() // 随机取数
    {
        int i, j;
        for (i = 0; i <= m - 1; i++)
            for (j = 0; j <= n - 1; j++)
                mx[i][j] = (int) (Math.random() * 100);
    }
    public void tranMatrix() // 转置矩阵
    {
        int i, j, t;
        int mt[][] = new int[m][n];
        for (i = 0; i <= m - 1; i++)
            for (j = 0; j <= n - 1; j++)
                mt[i][j] = mx[i][j];
        t = m;
        m = n;
        n = t;
        mx = new int[m][n];
        for (i = 0; i <= m - 1; i++)
            for (j = 0; j <= n - 1; j++)
                mx[i][j] = mt[j][i];
    }
    public void printMatrix() // 输出矩阵所有值
    {
        int i, j;
        for (i = 0; i <= m - 1; i++) {
            for (j = 0; j <= n - 1; j++)
                System.out.print(" " + mx[i][j]);
            System.out.println();
        }
    }
    // 判断一个矩阵是否为上三角矩阵
    public boolean isUpperTriangularMatrix() {
        int i, j = 0;
        int c = this.mx[1][0];
        for (i = 1; i < this.mx.length; i++)
            for (j = 0; j < i; j++)
                if (this.mx[i][j] != c)
                    break;
        if (i == this.mx.length)
            return true;
        return false;
    }
    public void addMatrix(Matrix b) // 矩阵相加
    {
        int i, j;
        for (i = 0; i <= m - 1; i++)
            for (j = 0; j <= n - 1; j++)
                mx[i][j] = mx[i][j] + b.mx[i][j];
    }
    public static void main(String args[]) {
        Matrix ma = new Matrix(4, 3);
        Matrix mb = new Matrix(4, 3);
        System.out.println("The matrix_A:");
        ma.printMatrix();
        System.out.println("The matrix_B:");
        mb.printMatrix();
        if (ma.isUpperTriangularMatrix())
            System.out.println("上三角矩阵：\n" + ma.isUpperTriangularMatrix());
        System.out.println("Matrix_A + Matrix_B:");
        ma.addMatrix(mb);
        ma.printMatrix();
        System.out.println("Transpose Matrix_A:");
        mb.tranMatrix();
        mb.printMatrix();
        System.out.println("Transpose Matrix_A+Matrix_B:");
        mb.tranMatrix();
        mb.printMatrix();
    }
}

java 中任意输入一个二维数组，然后再以矩阵的形式输出此数组。

import java.util.Scanner;
public class Main1 {
    public static void main(String ars[]) {
        Scanner s = new Scanner(System.in);
        System.out.println("请输入数组行数和列数");
        int x = s.nextInt();
        int y = s.nextInt();
        int[][] awarry = new int[x][y]; // 初始化数组
        System.out.println("请输入数组元素");
        for (int i = 0; i < x; i++) // 循环输入
            for (int j = 0; j < y; j++)
                awarry[i][j] = s.nextInt();
        System.out.println("你输入的数组为");
        for (int i = 0; i < x; i++) { // 循环输出
            for (int j = 0; j < y; j++)
                System.out.print(awarry[i][j] + "\t");
            System.out.println();
        }
    }
}

运行示例：

请输入数组行数和列数
2 3
请输入数组元素
1 2 3 4 5 6
你输入的数组为
1 2 3
4 5 6

java 二维数组，输入如下的方阵

int maze[][] = { { 1, 2, 6 }, { 3, 5, 7 }, { 4, 8, 9 } };
int i, j;
// 无论你输入多少下面的嵌套语句也会如愿的把你数组里面的数据按照你想要的形式输出
for (i = 0; i < 3; i++) {
    for (j = 0; j < 3; j++) {
        System.out.print(" " + maze[i][j] + " ");
    }
    System.out.println();
}

java定义一个二维数组,通过数组法输出一个九乘九(九行九列的方阵图)

/*
 * java定义一个二维数组,通过数组法输出一个九乘九(九行九列的方阵图)
 * 定义一个二维数组，通过数组法输出一个九乘九（九行九列的方阵图）。使对角线为值的“B”，其他值为“A”。
 */
public class Demo4 {
    public static void main(String[] args) {
        int[][] arr = new int[9][9];
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0, k = arr.length - 1; j < arr[i].length; j++) {
                if (i == j) {
                    System.out.print("B");
                } else if (j == k - i) {
                    System.out.print("B");
                } else {
                    System.out.print("A");
                }
            }
            System.out.println();
        }
    }
}