学了关于数组的知识点，这次我们一起来看一些关于数组的编程题！
思路分析：这道题有两种思路，所以提供两种解法。思路一就是func1()，思路二是func2()。
思路一：题目当中读取的整数的个数不确定，即数组的长度不固定，所以我们需要每读取一个数据，然后进行数组扩容，再填入数据，数据填入之后再进行排序，最后遍历数组依次判断数据的个数。
第一步：获取用户输入的数据，动态的扩容数组填充数据；
第二步：按照输出结果,将数据中的数据进行排序；
第三步：输出连续相等的数字；
第四步：编写代码。
思路二：借助计数排序的思想,将数组固定起来，然后进行操作。具体来看代码：
import java.util.*;
class Demo05_01{
public static void main(String[] args){
/*
思路1：数组长度不固定,需要读取一个数据,数组扩容,填入数据
数据填入之后进行排序,然后遍历数组依次判断数据的个数
连续相等
2 2 2 2 3 3 4 4 4 4 5 5 6 6 6 6 7 7
思路2：借助计数排序的思想,将数组固定起来。
*/
//func1();
func2();
}
public static void func2(){
//arr[i] 就表示数字i出现的次数
int[] arr = new int[101];
Scanner scanner = new Scanner(System.in);
System.out.print("Enter the integers between 1 and 100:");
while(true){
int num = scanner.nextInt();
if(num == 0){
break;
}
arr[num]++;
}
for(int i = 0;i < arr.length;i++){
if(arr[i] != 0){
System.out.println(i + " occurs " + arr[i] + (arr[i] > 1?" times":" time"));
}
}
}
public static void func1(){
//1.获取用户输入的数据 动态的扩容数组填充数据
int[] arr = new int[0];
Scanner scanner = new Scanner(System.in);
System.out.print("Enter the integers between 1 and 100:");
int num = 0;
while(true){
num = scanner.nextInt();
if(num == 0){
break;
}
//验证用户输入数据的正确性
if(num < 1 || num > 100){
System.out.println("有非法数据！");
return;
}
arr = copyOf(arr,arr.length + 1);
arr[arr.length - 1] = num;
}
//2.按照输出结果,将数据中的数据进行排序
insertSort(arr);
//3.输出连续相等的数字
show(arr);
}
public static int[] copyOf(int[] arr,int newLen){
int[] newArr = new int[newLen];
for(int i = 0;i < arr.length;i++){
newArr[i] = arr[i];
}
return newArr;
}
public static void insertSort(int[] arr){
for(int i = 1;i < arr.length;i++){
int e = arr[i];
int j;
for(j = i;j > 0 && arr[j - 1] > e;j--){
arr[j] = arr[j - 1];
}
arr[j] = e;
}
}
/*
Arrays Math都是属于工具类
Arrays 特殊的是数组的工具类
toString(arr) 就是将数据的每个元素进行拼接 并返回拼接后的字符串数据
"[1,2,3,4]"
*/
public static void show(int[] arr){
//System.out.println(Arrays.toString(arr));
//此时就将问题转成了如何判断连续相等的数据分别出现多少次
//[1, 1, 1, 2, 2, 2, 3, 3, 3, 3, 3, 4, 4, 5, 5, 6]
for(int i = 0;i < arr.length;){
int count = 1;
for(int j = i + 1;j < arr.length;j++){
if(arr[j] == arr[i]){
count++;
}else{
break;
}
}
System.out.println(arr[i] + " occurs " + count + (count>1?" times":" time"));
i+=count;
}
}
}运行结果：
Enter the integers between 1 and 100:2 5 6 5 4 3 23 43 2 0
2 occurs 2 times
3 occurs 1 time
4 occurs 1 time
5 occurs 2 times
6 occurs 1 time
23 occurs 1 time
43 occurs 1 time
思路分析：这道题也有两个思路，所以提供两种解法。思路一就是func1()，思路二是func2()。
思路一：在10个数全部输入之后再去重复；
第一步：循环遍历数组进行赋值；
第二步：开始对已有的数据进行去重复操作，这一步又提供了三种方法，method1、method2、method3；
第三步：编写代码。
思路二：边输入边去重复。具体来看代码：
import java.util.*;
class Demo05_02{
public static void main(String[] args){
/*
思路1
在全部输入之后去重复 func1
思路2
边输入边去重复 func2
*/
//func1();
func2();
}
public static void func2(){
int[] arr = new int[0];
Scanner scanner = new Scanner(System.in);
System.out.print("Enter ten numbers:");
for(int i = 0;i < 10;i++){
int num = scanner.nextInt();
if(!contains(arr,num)){
arr = copyOf(arr,arr.length + 1);
arr[arr.length-1] = num;
}
}
System.out.println("The number of distinct number is: " + arr.length);
System.out.println("The distinct numbers are: " + Arrays.toString(arr));
}
public static void func1(){
//1.循环遍历数组进行赋值
Scanner scanner = new Scanner(System.in);
System.out.print("Enter ten numbers:");
int[] arr = new int[10];
for(int i = 0;i < arr.length;i++){
arr[i] = scanner.nextInt();
}
//2.开始对已有的数据进行去重复操作
// 1 2 3 3 2 4 3 2 4 1
// 1 2 3 4
// method1(arr); //空间S(n) 时间O(nm)
// method2(arr); //空间S(1) 时间O(n^2)
// method3(arr);
}
public static void method3(int[] arr){
//不创建额外空间 不许改变原先的顺序
int i = 0;
int size = arr.length;
while(i < size){
for(int j = i + 1;j < size;){
if(arr[j] == arr[i]){
for(int k = j + 1;k < size;k++){
arr[k - 1] = arr[k];
}
size--;
}else{
j++;
}
}
i++;
}
for(i = 0;i < size;i++){
System.out.print(arr[i] + " ");
}
}
public static void method2(int[] arr){
//插入排序
for(int i = 1;i < arr.length;i++){
int e = arr[i];
int j;
for(j = i;j > 0 && arr[j - 1] > e;j--){
arr[j] = arr[j - 1];
}
arr[j] = e;
}
//连续相等
for(int i = 0;i < arr.length;){ //O(n)
System.out.print(arr[i] + " ");
int count = 1;
for(int j = i + 1;j < arr.length;j++){
if(arr[j] == arr[i]){
count++;
}else{
break;
}
}
i+=count;
}
}
public static void method1(int[] arr){
int[] newArr = new int[0];
for(int i = 0;i < arr.length;i++){ //O(n)
if(!contains(newArr,arr[i])){ //O(m)
newArr = copyOf(newArr,newArr.length + 1);
newArr[newArr.length - 1] = arr[i];
}
}
System.out.println(Arrays.toString(newArr));
}
public static boolean contains(int[] arr,int key){
for(int i = 0;i < arr.length;i++){
if(arr[i] == key){
return true;
}
}
return false;
}
public static int[] copyOf(int[] arr,int newLen){
int[] newArr = new int[newLen];
for(int i = 0;i < arr.length;i++){
newArr[i] = arr[i];
}
return newArr;
}
}运行结果：
Enter ten numbers:1 2 3 2 1 6 3 4 5 2
The number of distinct number is: 6
The distinct numbers are: [1, 2, 3, 6, 4, 5]
思路分析：这道题是让我们判断一个数组是不是升序序列，很简单，来看步骤。
第一步：获取用户的输入，第一个输入的数据是数据的个数(数组的长度)；
第二步：对数组进行有序的判断；
第三步：编写代码。
import java.util.*;
class Demo05_03{
public static void main(String[] args){
//1.获取用户的输入，第一个输入的数据是数据的个数(数组的长度)
Scanner scanner = new Scanner(System.in);
System.out.print("Enter a list:");
int len = scanner.nextInt();//获取的第一个数值就是数组的长度
int[] arr = new int[len];
for(int i = 0;i < arr.length;i++){
arr[i] = scanner.nextInt();
}
//2.对数组进行有序的判断
if(isSorted(arr)){
System.out.println("The list is already sorted.");
}else{
System.out.println("The list is not sorted.");
}
}
public static boolean isSorted(int[] list){
//如果不是升序排列 那么势必会出现有一组数据 左大右小的情况
for(int i = 1;i < list.length;i++){
if(list[i - 1] > list[i]){
return false;
}
}
return true;
}
}运行结果：
Enter a list:8 10 1 5 16 61 9 11 1
The list is not sorted.
Enter a list:10 1 1 3 4 4 5 7 9 11 21
The list is already sorted.
思路分析：这道题看起来挺复杂的，但是只要我们弄清楚题目到底要我们做什么，题目有什么数据，然后按照要求做就行了。
第一步：提示用户输入槽子的个数和小球的个数；
第二步：根据已有的槽子的个数去创建槽子容器；
第三步：根据已有的球和槽子的个数去随机创建一个小球下落的路径；
第四步：思考路径中经过几个钉子？路径的步骤有几步？这都和和槽子的个数有关；
第五步：思考如何通过路径的经过得知最终所落入的槽子；
第六步：编写代码。
import java.util.*;
class Demo05_04{
/*
输入的数据：槽子的个数 球的个数=路径的个数
创建槽子的具体的容器int[]
每一个小球下落的路径L R 字符串
对于每一个小球而言其路径中的步骤是随机产生L R
1.提示用户输入槽子的个数和小球的个数
2.根据已有的槽子的个数去创建槽子容器
3.根据已有的球和槽子的个数去随机创建一个小球下落的路径
4.路径中经过几个钉子？路径的步骤有几步 和槽子的个数有关
5.如何通过路径的经过得知最终所落入的槽子？
*/
public static void main(String[] args){
//1.获取球的个数和路径槽子的个数
Scanner scanner = new Scanner(System.in);
System.out.print("Enter the number of balls to drop:");
int balls = scanner.nextInt();
System.out.print("Enter the number of slots in the bean machine:");
int slots = scanner.nextInt();
//2.创建槽子具体的容器
int[] arr = new int[slots];
//3.几个球几个路径path
for(int i = 0;i < balls;i++){
String path = getPath(slots);
System.out.println(path);
//5.只要看当前路径中R的个数即可
arr[getR(path)]++;
}
//6.输出
System.out.println(Arrays.toString(arr));
show(arr);
}
public static void show(int[] arr){
int w = arr.length;
int h = 0;
for(int i = 0;i < arr.length;i++){
if(arr[i] > h){
h = arr[i];
}
}
for(int i = h - 1;i >= 0;i--){
for(int j = 0;j < w;j++){
if(i < arr[j]){
System.out.print("O");
}else{
System.out.print(" ");
}
}
System.out.println();
}
}
public static int getR(String path){
int count = 0;
for(int i = 0;i < path.length();i++){
if(path.charAt(i) == 'R'){
count++;
}
}
return count;
}
public static String getPath(int slots){
//4.根据槽子的个数计算每一个球下落的路径
Random random = new Random();
String path = "";
for(int j = 0;j < slots - 1;j++){
if(random.nextInt(2) == 0){ //向左
path+="L";
}else{ //向右
path+="R";
}
}
return path;
}
}运行结果：
LRLRRLR
LLLLLRL
LRLRRLL
LRRLRLL
RRLLLRR
[0, 1, 0, 2, 2, 0, 0, 0]
OO
O OO 
思路分析：这道题是让我们判断两个数组是否完全相同，具体来看步骤。
第一步：提示用户输入第一个数组list1，第二个数组list2，然后获取数值；
第二步：判断两个数组的长度是否相等；
第三步：紧接着再依次判断元素大小；
第四步：编写代码。
import java.util.*;
class Demo05_05{
public static void main(String[] args){
Scanner scanner = new Scanner(System.in);
//第一个数组list1
System.out.print("Enter list1:");
int len1 = scanner.nextInt();
int[] list1=new int[len1];
for(int i=0;i<list1.length;i++){
list1[i]=scanner.nextInt();
}
//第二个数组list2
System.out.print("Enter list2:");
int len2 = scanner.nextInt();
int[] list2=new int[len2];
for(int j=0;j<list2.length;j++){
list2[j]=scanner.nextInt();
}
equals(list1,list2);
}
public static void equals(int[] list1,int[] list2){
//判断两个数组是否完全相同
//1.先判断长度
if(list1.length!=list2.length){
System.out.println("Two lists are not strictly identical");
return;
}
//2.再依次判断元素大小
for(int i=0;i<list1.length;i++){
if(list1[i]!=list2[i]){
System.out.println("Two lists are not strictly identical");
return;
}
}
System.out.println("Two lists are strictly identical");
}
}运行结果：
Enter list1:5 2 5 6 1 6
Enter list2:5 2 5 6 1 6
Two lists are strictly identical
Enter list1:5 2 5 6 1 6
Enter list2:5 2 5 6 6 1
Two lists are not strictly identical 
思路分析：这道题是让用户输入一个整数列表，然后让我们判断这个列表当中是否有四个连续的具有相同值的数，然后返回true或false，这道题很简单，来看步骤：
第一步：提示用户输入列表中数字的总数和具体的数字；
第二步：判断列表中是否含有四个连续相等的数；
第三步：编写代码。
import java.util.*;
class Demo05_06{
public static void main(String[] args){
Scanner scanner = new Scanner(System.in);
//1.提示用户输入列表中数字的总数和具体的数字
System.out.print("Enter the number of values:");
int num = scanner.nextInt();
System.out.print("Enter the values:");
int[] arr = new int[num];
for(int i = 0;i < num;i++){
arr[i] = scanner.nextInt();
}
//2.判断列表中是否含有四个连续相等的数
if(isConsecutiveFour(arr) == true){
System.out.println("The list has consecutive fours");
}else{
System.out.println("The list has no consecutive fours");
}
}
public static boolean isConsecutiveFour(int[] arr){
for(int i = 0;i < arr.length;){
int count = 1;
for(int j = i + 1;j < arr.length;j++){
if(arr[i] == arr[j]){
count++;
}else{
break;
}
}
if(count >= 4){
return true;//列表中含有四个连续相等的数
}
i+=count;
}
return false;////列表中不含有四个连续相等的数
}
}运行结果：
Enter the number of values:8
Enter the values:3 4 5 5 5 5 4 5
The list has consecutive fours
Enter the number of values:9
Enter the values:3 4 5 5 6 5 5 4 5
The list has no consecutive fours
思路分析：这道题是让用户输入两个有序列表，然后让我们将这两个有序列表合并成一个有序列表，来看步骤：
第一步：提示用户输入第一个数组list1，第二个数组list2，然后获取数值；
第二步：先判断列表是否有空列表；
第三步：两个都不是null，再考虑具体操作；
第四步：编写代码。
import java.util.*;
class Demo05_07{
public static void main(String[] args){
Scanner scanner = new Scanner(System.in);
//第一个数组list1
System.out.print("Enter list1:");
int len1 = scanner.nextInt();
int[] list1 = new int[len1];
for(int i = 0;i < list1.length;i++){
list1[i] = scanner.nextInt();
}
//第二个数组list2
System.out.print("Enter list2:");
int len2 = scanner.nextInt();
int[] list2 = new int[len2];
for(int j = 0;j < list2.length;j++){
list2[j] = scanner.nextInt();
}
System.out.println("The merged list is " + Arrays.toString(merge(list1,list2)));
}
/*
有序数组的合并
最主要的问题在于 数组之间有长有短
*/
public static int[] merge(int[] list1,int[] list2){
if(list1 == null && list2 == null){
return null;
}
if(list1 == null){
return list2;
}
if(list2 == null){
return list1;
}
//只有两个都不是null，再考虑具体操作
int[] list3 = new int[list1.length + list2.length];
int p1 = 0;
int p2 = 0;
int p3 = 0;
while(true){
if(p1 == list1.length && p2 == list2.length){
break;
}
if(p1 < list1.length && p2 == list2.length){
list3[p3++] = list1[p1++];
}else if(p1 == list1.length && p2 < list2.length){
list3[p3++] = list2[p2++];
}else{
if(list1[p1] <= list2[p2]){
list3[p3++] = list1[p1++];
}else{
list3[p3++] = list2[p2++];
}
}
}
return list3;
}
}运行结果：
Enter list1:5 1 5 16 61 111
Enter list2:4 2 4 5 6
The merged list is [1, 2, 4, 5, 5, 6, 16, 61, 111]
思路分析，这道题很有意思，也有一定的难度，考虑的比较多，我们来看步骤：
第一步：创建一个单词表；
第二步：随机从单词表中抽取一个单词；
第三步：创建一个该单词的状态表 默认值是false(密文)；
第四步：开始猜一个单词，根据单词和状态表决定密文形式；
第五步：输出密文并提示用户输入字母；
第六步：判断单词中是否有该字母；
第七步：改变单词状态表，看是否结束；
第八步：最后再去做多单词猜测；
第九步：编写代码。
import java.util.*;
class Demo05_08{
/*
数据 一组单词的明文 单词的密文 单词的状态
program
1000000 r r
pr**r**
*/
public static void main(String[] args){
Scanner scanner=new Scanner(System.in);
Random random=new Random();
//1.创建一个单词表
String[] words={"apple","banana","orange","watermelon","java","program"};
//10.最后再去做多单词猜测
while(true){
//2.随机从单词表中抽取一个单词
String word=words[random.nextInt(words.length)];
//3.创建一个该单词的状态表 默认值是false(密文)
boolean[] status=new boolean[word.length()];
int miss=0; //猜错的个数
//4.开始猜一个单词
while(true){
//5.根据单词和状态表 决定密文形式
String ciphertext=getCipherText(word,status);
//6.输出密文并提示用户输入字母
System.out.print("Enter a letter in word "+ciphertext+" >");
char letter=scanner.nextLine().charAt(0);//"p".charAt(0)
//7.判断单词中是否有该字母
if(isContainsLetter(word,letter)){
//8.改变单词状态表 已修改/未修改
//true 表示从未修改 第一次来的
//false 表示已修改 不是第一次来 提示已经存在
if(!changeWordStatus(word,status,letter)){
System.out.println("\t "+letter+" is already in the word");
}
}else{
System.out.println("\t "+letter+" is not in the word");
miss++;
}
//9.是否结束
if(isFinish(status)){
System.out.println("The word is "+word+". You miss "+miss+" time");
break;
}
}
System.out.print("Do you want to guess another word?Enter y or n:");
String choice=scanner.nextLine();
if(choice.equals("n")){
System.out.println("Welcome!Thank you! FUCK PROGRAM!");
break;
}
}
}
public static boolean isFinish(boolean[] status){
for(int i=0;i<status.length;i++){
if(!status[i]){
return false;
}
}
return true;
}
public static boolean changeWordStatus(String word,boolean[] status,char letter){
for(int i=0;i<word.length();i++){
if(word.charAt(i)==letter){
if(status[i]){
return false; //说明已经修改
}else{
status[i]=true;
}
}
}
return true;
}
public static boolean isContainsLetter(String word,char letter){
for(int i=0;i<word.length();i++){
if(word.charAt(i)==letter){
return true;
}
}
return false;
}
public static String getCipherText(String word,boolean[] status){
String ciphertext="";
for(int i=0;i<status.length;i++){
if(status[i]){
ciphertext+=word.charAt(i);
}else{
ciphertext+="*";
}
}
return ciphertext;
}
}运行结果：
Enter a letter in word ***** >a
Enter a letter in word a**** >p
Enter a letter in word app** >l
Enter a letter in word appl* >e
The word is apple. You miss 0 time
思路分析：这道题是让我们求二维数组中特定列的所有元素之和，我们只需要记住一个原则：累加行的时候，行不动列动，累加列的时候，列不动行动。
第一步：提示用户输入一个3*4的矩阵；
第二步：打印每列的和；
第三步：编写代码。
import java.util.*;
class Demo05_09{
public static void main(String[] args){
/*
(0,0) (0,1) (0,2) (0,3)
(1,0) (1,1) (1,2) (1,3)
(2,0) (2,1) (2,2) (2,3)
累加行的时候 行不动 列动
累加列的时候 列不动 行动
*/
//1.输入一个3*4的矩阵
Scanner scanner = new Scanner(System.in);
System.out.println("Enter a 3-by-4 matrix row by row:");
double[][] matrix = new double[3][4];
//System.out.println(matrix.length);
for(int i = 0;i < matrix.length;i++){
for(int j = 0;j < matrix[i].length;j++){
matrix[i][j] = scanner.nextDouble();
}
}
//2.打印每列的和
for(int col = 0;col < matrix[0].length;col++){
System.out.println("Sum of the elements at column " + col + " is " + sumColumn(matrix,col));
}
}
public static double sumColumn(double[][] m,int columnIndex){
double sum = 0;
for(int row = 0;row < m.length;row++){
sum+=m[row][columnIndex];
}
return sum;
}
}运行结果：
Enter a 3-by-4 matrix row by row:
1.5 2 3 4
5.5 6 7 8
9.5 1 3 1
Sum of the elements at column 0 is 16.5
Sum of the elements at column 1 is 9.0
Sum of the elements at column 2 is 13.0
Sum of the elements at column 3 is 13.0
思路分析：这道题其实和上一道题有相似之处，只不过这一道题是让我们求对角线的所有元素之和。
第一步：提示用户输入一个4*4的矩阵；
第二步：计算对角线之和，这里我把刚开始用的方法注释掉了，因为比较耗费内存。又写了另一种方法；
第三步：编写代码。
import java.util.*;
class Demo05_10{
public static void main(String[] args){
//1.输入一个4*4的矩阵
Scanner scanner = new Scanner(System.in);
System.out.println("Enter a 4-by-4 matrix row by row:");
double[][] m = new double[4][4];
//System.out.println(m.length);
for(int i = 0;i < m.length;i++){
for(int j = 0;j < m[i].length;j++){
m[i][j] = scanner.nextDouble();
}
}
System.out.println("Sum of the elements in the major diagonal is " + sumMajorDiagonal(m));
}
//2.求对角线之和
public static double sumMajorDiagonal(double[][] m){
//①主对角线
double sum = 0;
for(int i = 0;i < m.length;i++){
sum+=m[i][i];
}
return sum;
/*②副对角线
int subsum = 0;
for(int i = 0;i < m.length;i++){
subsum+=m[i][m.length - 1 - i];
}
System.out.println(subsum);
*/
/*我们首先能想到的就是这种方法，但是此方法不是很好，需要遍历数组中每一个元素，有点"大材小用"。
for(int i = 0;i < m.length;i++){
for(int j = 0;j < m[i].length;j++){
if(i==j){
sum+=m[i][j];
}
}
}
*/
}
}运行结果：
Enter a 4-by-4 matrix row by row:
1 2 3 4.0
5 6.5 7 8
9 10 11 12
13 14 15 16
Sum of the elements in the major diagonal is 34.5 
思路分析：像这种数学上的一些运算，如果直接通过看，计算流程还是比较麻烦的，这个时候推荐使用已知公式计算！步骤还是跟上面题目步骤一样，我们直接来看代码。
import java.util.*;
class Demo05_11{
public static void main(String[] args){
//m*n n*p m*p 矩阵相乘 前者的列 必须等于 后者的行
/*
1 2 3 1 2 1*1+2*3+3*5 1*2+2*4+3*6
× 3 4 =
4 5 6 5 6 4*1+5*3+6*5 4*2+5*4+6*6
对于数学上的一些运算公式 如果直接通过看计算流程还是比较麻烦的
此时推荐使用已知公式计算！
*/
//1.提示用户输入两个3*3的矩阵
Scanner scanner = new Scanner(System.in);
System.out.print("Enter matrix1:");
double[][] a = new double[3][3];
for(int i = 0;i < a.length;i++){
for(int j = 0;j < a[i].length;j++){
a[i][j] = scanner.nextDouble();
}
}
System.out.print("Enter matrix2:");
double[][] b = new double[3][3];
for(int i = 0;i < b.length;i++){
for(int j = 0;j < b[i].length;j++){
b[i][j] = scanner.nextDouble();
}
}
multiplyMatrix(a,b);
}
//2.计算它们的乘积
public static void multiplyMatrix(double[][] a,double[][] b){
double[][] c = new double[a.length][b[0].length];//m*n
for(int i = 0;i < c.length;i++){
for(int j = 0;j < c[i].length;j++){
double sum = 0;
for(int k = 0;k < b.length;k++){
sum+=a[i][k] * b[k][j];
}
//c[i][j] = sum;
System.out.printf("%.2f ",sum);
}
System.out.println();
}
}
}运行结果：
Enter matrix1:1 2 3 4 5 6 7 8 9
Enter matrix2:0 2 4 1 4.5 2.2 1.1 4.3 5.2
5.30 23.90 24.00
11.60 56.30 58.20
17.90 88.70 92.40
思路分析：这道题是让用户输入一个方阵的长度，随机的在矩阵中填入0和1，然后让我们找出整行、整列或者对角线都是0或1的行、列和对角线，很简单，来看步骤。
第一步：输入方针的尺寸 创建方阵；
第二步：随机的给方阵中填入0或1；
第三步：让行，列，对角线累加,累加为0说明都是0,累加为size说明都是1,即都相等；
第四步：编写代码。
import java.util.*;
class Demo05_12{
public static void main(String[] args){
//1.输入方针的尺寸 创建方阵
Scanner scanner = new Scanner(System.in);
System.out.print("Enter the size for the matrix:");
int size = scanner.nextInt();
int[][] m = new int[size][size];
//2.随机的给方阵中填入0或1
Random random = new Random();
for(int i = 0;i < size;i++){
for(int j = 0;j < size;j++){
m[i][j] = random.nextInt(2);
System.out.print(m[i][j]+" ");
}
System.out.println();
}
//3.让行，列，对角线累加,累加为0说明都是0,累加为size说明都是1,即都相等 sum==0 sum==size
checkRow(m);
checkCol(m);
checkMajorDiagonal(m);
checkSubDiagonal(m);
}
public static void checkSubDiagonal(int[][] m){
int sum = 0;
for(int i = 0;i < m.length;i++){
sum+=m[i][m.length - 1 - i];
}
if(sum==m.length || sum==0){
System.out.printf("副主对角线全相等且是%d\n",sum==0?0:1);
}else{
System.out.println("No same numbers on the sub-diagonal");
}
}
public static void checkMajorDiagonal(int[][] m){
int sum = 0;
for(int i = 0;i < m.length;i++){
sum+=m[i][i];
}
if(sum==m.length || sum==0){
System.out.printf("主对角线全相等且是%d\n",sum==0?0:1);
}else{
System.out.println("No same numbers on the major diagonal");
return;
}
}
public static void checkRow(int[][] m){
for(int i = 0;i < m.length;i++){
int sum = 0;
for(int j = 0;j < m[i].length;j++){
sum+=m[i][j];
}
if(sum==m.length || sum==0){
System.out.printf("第%d行全相等且是%d\n",i + 1,sum==0?0:1);
return;
}
}
System.out.println("No same numbers on a row");
}
public static void checkCol(int[][] m){
for(int j = 0;j < m.length;j++){
int sum = 0;
for(int i = 0;i < m.length;i++){
sum+=m[i][j];
}
if(sum==m.length || sum==0){
System.out.printf("第%d列全相等且是%d\n",j + 1,sum==0?0:1);
return;
}
}
System.out.println("No same numbers on a column");
}
}运行结果：
Enter the size for the matrix:5
0 0 0 0 0
0 0 0 1 0
1 1 1 0 1
0 0 1 0 1
0 1 1 0 0
第1行全相等且是0
No same numbers on a column
No same numbers on the major diagonal
No same numbers on the sub-diagonal 
思路分析：这道题其实是上面那道题的进阶版，难度提升了一点。创建完二维数组之后，我们需要看右边、下边、右下和右上四种情况，具体来看：
import java.util.*;
class Demo05_13{
public static void main(String[] args){
Scanner scanner = new Scanner(System.in);
System.out.print("Enter row and col:");
int row = scanner.nextInt();
int col = scanner.nextInt();
int[][] m = new int[row][col];
System.out.println("请输入数组中的数字：");
for(int i = 0;i < row;i++){
for(int j = 0;j < col;j++){
m[i][j] = scanner.nextInt();
}
}
System.out.println(isConsecutiveFour(m));
}
public static boolean isConsecutiveFour(int[][] m){
for(int i = 0;i < m.length;i++){
for(int j = 0;j < m[i].length;j++){
//向右
if(j<=m[i].length - 4){
boolean flag = true;
for(int c = j + 1;c<=j+3;c++){
if(m[i][j] != m[i][c]){
flag = false;
break;
}
}
if(flag){
return true;
}
}
//向下
if(i<=m.length - 4){
boolean flag = true;
for(int r = i + 1;r<=i + 3;r++){
if(m[i][j]!=m[r][j]){
flag = false;
break;
}
}
if(flag){
return true;
}
}
//向右下
if(i<=m.length-4 && j<=m[i].length-4){
boolean flag = true;
for(int r = i + 1,c = j + 1;r<=i + 3;r++,c++){
if(m[i][j] != m[r][c]){
flag = false;
break;
}
}
if(flag){
return true;
}
}
//向右上
if(i>=3 && j<=m[i].length-4){
boolean flag = true;
for(int r = i - 1,c = j + 1 ;c<=j + 3;r--,c++){
if(m[i][j] != m[r][c]){
flag = false;
break;
}
}
if(flag){
return true;
}
}
}
}
return false;//四个方向都没有连续的
}
}运行结果：
Enter row and col:5 5
请输入数组中的数字：
1 2 3 4 5
2 1 5 4 3
3 2 1 5 4
2 5 4 1 3
8 5 6 1 2
true好了，关于数组的练习题我们就说到这里，拜拜！
