Java、探索矩阵

        编写程序，提示用户输入一个方阵的长度，随机地在矩阵中填入0和1，打印这个矩阵，然后找出整行、整列或者对角线都是1或0的行、列和对角线。

---

package pack2;

import java.security.SecureRandom;
import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;

public class ExplorationOfMatrix {

	public static void main(String[] args) {
		explorationOfMatrix();
	}

	/**探索矩阵*/
	public static void explorationOfMatrix() {
		try(Scanner input = new Scanner(System.in);) {
			System.out.print("Enter the size for the matrix: ");
			int size = input.nextInt();
			
			int[][] matrix = new int[size][size];
			initial(matrix);
			printMatrix(matrix);
			
			System.out.print(getMessge(matrix));
			System.out.println(getMessageFoeMajorAndSubDiagonal(matrix));
		}
	}
	
	/**获取信息*/
	public static String getMessge(int[][] matrix) {
		StringBuffer message = new StringBuffer();
		int rowSum, columnSum;	//行、列和
		rowSum = columnSum = 0;
		
		for (int i = 0; i < matrix.length; i++) {
			rowSum = columnSum = 0;	//每次循环置为0
			
			for (int j = 0; j < matrix[i].length; j++) {
				rowSum += matrix[i][j];
				columnSum += matrix[j][i];
			}
			
			if(rowSum == 0) message.append("All 0s on row " + i + "\n");	//全0行
			if(rowSum == matrix[0].length) message.append("All 1s on row " + i + "\n");	        
                     //全1行
			
			if(columnSum == 0) message.append("All 0s on column " + i + "\n");	//全0列
			if(columnSum == matrix.length) message.append("All 1s on column " + i 
                    + "\n");	//全1列
		}
		
		if(message.indexOf("row") == -1)	//不存在整行为0或1时
			message.append("No same numbers on a row\n");
		if(message.indexOf("column") == -1)	//不存在整列为0或1时
			message.append("No same numbers on a column\n");
		
		return message.toString();
	}
	
	/**获取对角线信息*/
	public static String getMessageFoeMajorAndSubDiagonal(int[][] matrix) {
		StringBuffer message = new StringBuffer();
		int majorDiagonal, subDiagonal;	//主、次对角线和
		majorDiagonal = subDiagonal = 0;
		
		for (int i = 0, k = matrix.length - 1; i < matrix.length; i++, k--) {
			majorDiagonal += matrix[i][i];
			subDiagonal += matrix[i][k];
		}
		
             //主对角线全0时
		if(majorDiagonal == 0) message.append("All 0s on the major diagonal");	
		else if(majorDiagonal == matrix.length) message.append(
                "All 1s on the major diagonal");	//主对角线全1时
		else message.append("No same numbers on the major diagonal");//主对角线非全0全1时
		message.append("\n");
		
		if(subDiagonal == 0) message.append("All 0s on the sub-diagonal");//次对角线全0时
		else if(subDiagonal == matrix.length) message.append(
                "All 1s on the sub-diagonal");	//次对角线全0时
		else message.append("No same numbers on the sub-diagonal");	//次对角线非全0全1时
		
		return message.toString();
	}

	/**随机赋值矩阵*/
	public static void initial(int[][] matrix) {
		for (int i = 0; i < matrix.length; i++) 
			for (int j = 0; j < matrix[i].length; j++) 
				matrix[i][j] = new SecureRandom().nextInt(2);
	}
	
	/**打印矩阵*/
	public static void printMatrix(int[][] matrix) {
		for (int i = 0; i < matrix.length; i++) {
			for (int j = 0; j < matrix[i].length; j++) 
				System.out.print(" " + matrix[i][j]);
			
			System.out.println();
		}
	}
}

---

 

---

package test;

import java.security.SecureRandom;
import java.util.*;

/**
 * @create: 2023/3/25
 * @Description:
 * @FileName: Main
 */
public class Main {
    public static void main(String[] args) {
        int n = 4;
        int[][] matrix = initiate(n);
        print(matrix);

        // 行和列
        List<List<Integer>> list = count(matrix);
        System.out.println("全0/1行：" + list.get(0));
        System.out.println("全0/1列：" + list.get(1));

        // 主次对角线
        boolean[] diagonals = diagonal(matrix);
        System.out.println("主对角线：" + diagonals[0]);
        System.out.println("次对角线：" + diagonals[1]);
    }

    /** 初始化矩阵 */
    private static int[][] initiate(int n) {
        int[][] matrix = new int[n][n];
        SecureRandom random = new SecureRandom();

        // 矩阵赋值
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                matrix[i][j] = random.nextInt(2);
            }
        }
        return matrix;
    }

    /** 返回全0/1的行和列的数目 */
    private static List<List<Integer>> count(int[][] matrix) {
        List<List<Integer>> list = new ArrayList<>();
        list.add(new ArrayList<>(matrix.length));   // 行
        list.add(new ArrayList<>(matrix.length));   // 列

        for (int i = 0; i < matrix.length; i++) {
            // 使用集合对行列数据计数（集合内元素不重复）
            Set<Integer> rowCount = new HashSet<>(matrix.length);
            Set<Integer> columnCount = new HashSet<>(matrix.length);
            // 集合添加元素
            for (int j = 0; j < matrix.length; j++) {
                rowCount.add(matrix[i][j]);
                columnCount.add(matrix[j][i]);
            }

            // 集合大小为1时，存在全0/1的行/列
            if (1 == rowCount.size())
                list.get(0).add(i);
            if (1 == columnCount.size())
                list.get(1).add(i);
        }
        return list;
    }

    /** 返回主次对角线 */
    private static boolean[] diagonal(int[][] matrix) {
        boolean[] diagonal = new boolean[2];    // 0: 主对角线  1：次对角线
        Set<Integer> major = new HashSet<>();   // 主对角线集合
        Set<Integer> sub = new HashSet<>();     // 次对角线集合

        // 集合添加主次对角线元素
        for (int i = 0; i < matrix.length; i++) {
            major.add(matrix[i][i]);
            sub.add(matrix[i][matrix.length - 1 - i]);
        }

        // 判断集合大小，等于1表示存在全0/1
        diagonal[0] = (1 == major.size());
        diagonal[1] = (1 == sub.size());
        return diagonal;
    }

    /** 打印矩阵 */
    private static void print(int[][] matrix) {
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix.length; j++) {
                System.out.printf("%5d", matrix[i][j]);
            }
            System.out.println();
        }
    }
}