数组
数组是一个对象,在计算机中存入堆内存。
数组的定义
数组是在堆内存中开辟的一片空间大小相等且地址连续的存储空间。
在程序中出现大量数据时,我们创建变量,十分麻烦,所以我们使用数组对数据进行存储。
注意:
1、数组中所存储的数据是必须保证类型一致。
2、数组在堆内存中,是对象
3、数组通过下标来访问数组元素,数组下标从0开始
4、数组变量存放的是数组在堆内存中的首地址
5、数组通过下标访问元素地址计算公式为:被访问元素的地址=首地址+下标*数据类型大小
6、数组被定义之后长度就不可改变
7、创建时必须规定元素内容或者数组大小
数组的三种创建方式
1、数据类型[] 数组名=new 数据类型[数组长度]
2、数据类型[] 数组名=new 数据类型[] {1,2,3,4}
3、数据类型[] 数组名={1,2,3,4}
注意: 当有一个[]时表示这是一个一维数组,当有两个[]时,表示这是一个二维数组
数组常见错误
ArrayIndexOutOfBoundsException 数组角标越界
这时候注意如果是循环,那么看自己的循环退出条件,如果使用的是<=那么后面的数组长度就需要-1,如果使用的是<那么数组长度不-1
NullPointerException 空指针异常
表示空指针异常,即数组变量指向了nul
数组的遍历
我们通常使用for循环来遍历数组
class Number{
public static void main(String[] args){
int[] a={1,2,3,4,5,6};
for(int i=0;i<6;i++){
System.out.println(a[i]);
}
}
}
运行结果
1
2
3
4
5
6
数组的赋值
import java.util.Scanner;
class Number{
public static void main(String[] args){
Scanner scanner=new Scanner(System.in);
int[] a=new int[6];
for(int i=0;i<6;i++){
a[i]=scanner.nextInt();
}
}
}
数组查找
线性查找
从第一个元素开始到最后一个元素结束,从头到尾依次遍历一遍。
//使用线性查找,找出数组1,2,3,4,5,6中的4,并返回下标
class Number{
public static void main(String[] args){
int[] a={1,2,3,4,5,6};
for(int i=0;i<6;i++){
if(a[i]==4){
System.out.println(i);
}
}
}
}
时间复杂度为O(n)
二分查找
利用二分树的原理进行查找
条件: 数组必须是有序的
原理:取数组中间的数和所要查找的数进行比较,如果所要查的数等于数组最中间的数那直接输出,如果所要查的数大于数组中间的数那么数组中间的数的前面的数就不需要考虑了,将后面的数看为一个新数组继续进行这样的操作,反之亦然。
class Search{
public static void main(String[] args){
//二分查找
binarySearch();
}
public static void binarySearch(){
int[]arr={12,17,21,32,38,41,46,49,50,50,51,59,60};
int key=46;
int index=-1;
int min_index=0;
int max_index=arr.length-1;
int mid_index=(min_index+max_index)/2;
while(arr[mid_index]!=key){
if(key<arr[mid_index]){
max_index=mid_index-1;
}
if(arr[mid_index]<key){
min_index=mid_index+1;
}
if(min_index>max_index){
index=-1;
break;
}
mid_index=(min_index+max_index)/2;
}
System.out.println(mid_index);
}
}
时间复杂度为:O(log2 n)
二维数组
有两个维度的数组
二维数组的定义:
int[][] arr=new int[i][j]
int[][] arr={{1,2 3},{2,3,4},{6,7,8}}
int[][] arr=new int[][]{{1,2 3},{2,3,4},{6,7,8}}
访问二维数组的元素是根据元素的行角标和列角标来访问的
二维数组的存储
在计算机中只要是数组就是一维存储,对于二维数组而言,二维数组是一个以一维数组为元素的一维数组
二维数组注意
矩阵一定是二维数组,但是二维数组不一定是矩阵
例:
是二维数组但是不是矩阵
当二维数组的行列相等时称之为方阵
习题
一维数组
1、
/*
数据:用户输入的一组数 这组数中(0,100]的数出现的次数
指令:提示用户输入一组数 将各数字出现的次数存入数组中 输出
步骤;
1、提示用户输入一组数
2、将各数字出现的次数存入数组中
3、输出
*/
import java.util.Scanner;
class ProblemOne{
public static void main(String[] args){
Scanner scanner=new Scanner(System.in);
//1、提示用户输入一组数
System.out.print("请输入一组数以0结尾: ");
int []a=new int[100];
int []b=new int[100];
//2、将各数字出现的次数存入数组中
while(true){
int i=0;
a[i]=scanner.nextInt();
if(a[i]==0){
break;
}else if(a[i]>=1&&a[i]<=100){
b[a[i]-1]+=1;
}
i+=1;
}
//3、输出
for(int j=0;j<100;j++){
if(b[j]>0){
System.out.println((j+1)+" 出现了 "+b[j]+" 次。");
}
}
}
}
运行结果
请输入一组数以0结尾: 3 4 5 6 7 8 0
3 出现了 1 次。
4 出现了 1 次。
5 出现了 1 次。
6 出现了 1 次。
7 出现了 1 次。
8 出现了 1 次。
2、
/*
数据:从控制台读入的10个数 不同数的个数 不同的数是什么
指令:提示用户输入10个数 将未出现存入数组中 输出不同的数及有多少个
步骤:
1、提示用户输入10个数
2、将未出现存入数组中
3、输出不同的数及有多少个
*/
import java.util.Scanner;
class ProblemTwo{
public static void main(String[] args){
Scanner scanner=new Scanner(System.in);
//1、提示用户输入10个数
System.out.print("请输入十个数:");
int []a=new int [10];
int count=0;
//2、将未出现存入数组中
for(int i=0;i<10;i++){
a[i]=scanner.nextInt();
for(int j=0;j<i;j++){
if(a[j]==a[i]){
a[i]=0;
break;
}
}
}
//3、输出不同的数及有多少个
System.out.print("出现的数分别是:");
for(int k=0;k<10;k++){
if(a[k]!=0){
System.out.print(a[k]+" ");
count+=1;
}
}
System.out.println();
System.out.println("出现的数的个数为: "+count);
}
}
运行结果
请输入十个数:1 2 3 4 5 6 7 8 7 9
出现的数分别是:1 2 3 4 5 6 7 8 9
出现的数的个数为: 9
3、
/*
数据:用户输入的一组数
指令:提示用户输入一组数 调用函数isSorted() 输出数组是否是升序的
步骤:
1、提示用户输入一组数
2、使用循环将数放入数组中
3、调用isSorted()函数
4、并输出数组是否是升序的
*/
import java.util.Scanner;
class ProblemThree{
public static void main(String[] args){
Scanner scanner=new Scanner(System.in);
System.out.print("输入这组数的个数:");
int number=scanner.nextInt();
//1、提示用户输入一组数
System.out.print("Enter list: ");
int[] list=new int[number];
for(int i=0;i<number;i++){
list[i]=scanner.nextInt();
}
boolean flag=isSorted(list);
if(flag){
System.out.println("The list is already isSorted");
}else{
System.out.println("The list is not isSorted");
}
}
public static boolean isSorted(int[] list){
for(int j=list.length-1;j>=0;j--){
for(int k=0;k<j;k++){
if(list[k]>list[j]){
return false;
}
}
}
return true;
}
}
运行结果
输入这组数的个数:6
Enter list: 1 2 3 5 3 6
The list is not isSorted
输入这组数的个数:6
Enter list: 2 3 5 6 7 9
The list is already isSorted
4、
/*
数据:小球个数number 槽数a 每个槽的小球个数m 每个槽内的小球数
指令:提示用户输入小球个数和槽数 调用函数isWhat()判断小球会落到那个槽和输出路径 统计每个槽的小球个数 输出
步骤:
1、提示用户输入小球个数和槽数
2、调用函数isWhat()判断小球会落到那个槽和输出路径 统计每个槽的小球个数
3、输出小球落到槽内的图
*/
import java.util.Scanner;
class ProblemFour{
public static void main(String[] args){
Scanner scanner=new Scanner(System.in);
//1、提示用户输入小球个数和槽数
System.out.print("请输入小球个数和槽数: ");
int number=scanner.nextInt();
int m=scanner.nextInt();
int[] a=new int[m];//使用数组存放每个槽内的小球数
System.out.println();//输出一个回车避免分不清楚
//2、调用函数isWhat()判断小球会落到那个槽和输出路径 统计每个槽的小球个数
for(int i=0;i<number;i++){
a[(int)(isWhat(m))]++;
}
System.out.println();//输出一个回车避免分不清楚
//3、输出
int b=0;//存放 最多的小球个数 即最终需要打印的小球图案的层数
for(int j=0;j<m;j++){
if(b<a[j]){
b=a[j];
}
}
for(int k=b;k>0;k--){
for(int l=0;l<m;l++){//有球就是o没有球就是空格
if(a[l]==k){
System.out.print("o");
a[l]-=1;
}else{
System.out.print(" ");
}
}
System.out.println();
}
}
public static double isWhat(int m){//m是槽数
double seat;//中间槽的位置 即小球初始位置
if(m%2==0){//偶数个槽
seat=m/2;
}else{//奇数个槽
seat=m/2+1.0/2;
}
for(int i=0;i<m-1;i++){//m-1表示m个槽需要选择m-1次就可以使小球落入槽中
if((int)(Math.random()*2)==0){//随机数为0表示向左,为1表示向右
System.out.print("L");//向左就输出L
seat-=1.0/2;
}else{
System.out.print("R");//向右就输出R
seat+=1.0/2;
}
}
System.out.println();
return seat;
}
}
运行结果
请输入小球个数和槽数: 5 6
LRRRL
LLLRR
LRLRR
LLRRR
LRRLL
o
oo
oo
请输入小球个数和槽数: 4 9
RRLLRRLR
LLLRLRRR
RRRRLRLL
RRRRLLRR
o
ooo
5、
/*
数据:用户输入数组长度 两个数组
指令:提示用户输入数组长度 提示用户输入两个数组 调用函数equals() 输出
步骤:
1、提示用户输入数组长度
2、提示用户输入两个数组
3、调用函数equals(),并输出
*/
import java.util.Scanner;
class ProblemFive{
public static void main(String[] args){
Scanner scanner=new Scanner(System.in);
//1、提示用户输入数组长度
System.out.print("请输入数组长度:");
int length=scanner.nextInt();
//2、提示用户输入两个数组
System.out.print("第一个数组list1: ");
int[] list1=new int[length];
for(int i=0;i<length;i++){
list1[i]=scanner.nextInt();
}
System.out.print("第一个数组list2: ");
int[] list2=new int[length];
for(int j=0;j<length;j++){
list2[j]=scanner.nextInt();
}
if(equals(list1,list2)){
System.out.println("两个数组是完全相同的");
}else{
System.out.println("两个数组不是完全相同的");
}
}
public static boolean equals(int[] list1,int[] list2){
for(int i=0;i<list1.length;i++){
if(list1[i]!=list2[i]){
return false;
}
}
return true;
}
}
运行结果
请输入数组长度:8
第一个数组list1: 1 2 3 4 5 6 7 8
第一个数组list2: 1 2 3 4 5 6 7 8
两个数组是完全相同的
请输入数组长度:8
第一个数组list1: 1 2 3 4 5 6 7 8
第一个数组list2: 1 3 5 7 9 2 4 6
两个数组不是完全相同的
6、
/*
数据:用户输入的列表长度 用户输入的列表
指令:提示用户输入列表长度 提示用户输入列表 调用函数isConsecutiveFour()并输出列表是否有四个连续的数
步骤:
1、提示用户输入一个列表的长度
2、提示用户输入列表
3、调用函数并输出
*/
import java.util.Scanner;
class ProblemSix{
public static void main(String[] args){
Scanner scanner=new Scanner(System.in);
//1、提示用户输入列表长度
System.out.print("Enter the number of values:");
int length=scanner.nextInt();
//2、提示用户输入列表
System.out.print("Enter the values:");
int[] values=new int[length];
for(int i=0;i<length;i++){
values[i]=scanner.nextInt();
}
//3、调用函数isConsecutiveFour(),并输出列表是否有四个连续的数
if(isConsecutiveFour(values)){
System.out.println("The list has consecutive four");
}else{
System.out.println("The list has no consecutive four");
}
}
public static boolean isConsecutiveFour(int[] values){
int count=1;
for(int i=1;i<values.length;i++){
if(values[i]==values[i-1]){
count+=1;
}else{
count=1;
}
if(count==4){
return true;
}
}
return false;
}
}
运行结果
Enter the number of values:8
Enter the values:1 2 3 3 3 3 4 5
The list has consecutive four
Enter the number of values:8
Enter the values:1 2 3 4 5 6 7 8
The list has no consecutive four
7、
/*
数据:用户输入的两个列表的长度和内容
指令:提示用户输入两个有序列表长度和内容 调用函数merge() 输出合并之后的列表
步骤:
1、提示用户输入两个列表长度和内容
2、调用函数merge()得到合并后的列表
3、输出合并之后的列表
*/
import java.util.*;
class ProblemSeven{
public static void main(String[] args){
Scanner scanner=new Scanner(System.in);
//1、提示用户数如两个有序列表
System.out.print("Enter list1(第一个代表列表长度): ");
int length1=scanner.nextInt();
int[] list1=new int[length1];
for(int i=0;i<length1;i++){
list1[i]=scanner.nextInt();
}
System.out.print("Enter list2: ");
int length2=scanner.nextInt();
int[] list2=new int[length2];
for(int j=0;j<length2;j++){
list2[j]=scanner.nextInt();
}
//2、调用函数merge
//3、输出合并后的数组
System.out.print("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;
}
int[] list3=new int[list1.length+list2.length];
int maxlength;
int i=0;
int j=0;
int k=0;
while(true){
if(list1[i]<=list2[j]){
list3[k]=list1[i];
i++;
}else{
list3[k]=list2[j];
j++;
}
k++;
if(i==list1.length||j==list2.length){
break;
}
}
if(list1.length==i&&list2.length==j){
return list3;
}else if(list1.length==i){
for(j=j;j<list2.length;j++){
list3[k]=list2[j];
k++;
}
}else{
for(i=i;i<list1.length;i++){
list3[k]=list1[i];
k++;
}
}
return list3;
}
}
运行结果
Enter list1(第一个代表列表长度): 5 1 2 3 4 5
Enter list2: 7 1 3 4 6 8 9 11
The merged list is [1, 1, 2, 3, 3, 4, 4, 5, 6, 8, 9, 11]
8、
import java.util.*;
class ProblemEight{
public static void main(String[] args){
Scanner scanner=new Scanner(System.in);
//1、创建一个字符串数组,存5个单词
String[] word={"program","airplane","apple","monkey","person"};
//2、随机产生一个数,表示第几个单词
int number=(int)(Math.random()*word.length);
//3、调用函数猜第一次词
guess(word[number]);
//4、通过循环确定是否继续猜词
while(true){
System.out.print("Do you want to guess other words? Enter y or n: ");
String choice=scanner.nextLine();
if(choice.charAt(0)=='y'){
guess(word[(int)(Math.random()*word.length)]);
}else{
break;
}
}
}
public static void guess(String word){
Scanner scanner=new Scanner(System.in);
char[] cipher=new char[word.length()];
int miss=0;
for(int i=0;i<word.length();i++){//初始化数组为*
cipher[i]='*';
}
while(true){
int number=word.length();
System.out.print("(Guess) Enter a letter in word: ");
show(cipher);
System.out.print(" > ");
char letter=scanner.nextLine().charAt(0);
for(int j=0;j<word.length();j++){//遍历单词看是单词中否有用户输入的字母
if(letter==word.charAt(j)&&letter!=cipher[j]){
cipher[j]=letter;
}else if(letter==word.charAt(j)&&letter==cipher[j]){
break;
}else{
number--;
}
if(number==0){
System.out.println(letter+" is not in word ");
miss++;
break;
}
}
int k;
for(k=0;k<word.length();k++){
if(cipher[k]!=word.charAt(k)){
break;
}
}
if(k==word.length()){
System.out.println("The word is "+word+" .You x=missed it "+miss+" time");
return;
}
}
}
public static void show(char[] cipher){//展示数组
for(int i=0;i<cipher.length;i++){
System.out.print(cipher[i]);
}
}
}
运行结果
(Guess) Enter a letter in word: ****** > q
q is not in word
(Guess) Enter a letter in word: ****** > p
p is not in word
(Guess) Enter a letter in word: ****** > a
a is not in word
(Guess) Enter a letter in word: ****** > m
(Guess) Enter a letter in word: m***** > o
(Guess) Enter a letter in word: mo**** > o
o is already in the word
(Guess) Enter a letter in word: mo**** > l
l is not in word
(Guess) Enter a letter in word: mo**** > k
(Guess) Enter a letter in word: mo*k** > e
(Guess) Enter a letter in word: mo*ke* > y
(Guess) Enter a letter in word: mo*key > n
The word is monkey .You x=missed it 4 time
Do you want to guess other words? Enter y or n: n
(Guess) Enter a letter in word: ****** > m
(Guess) Enter a letter in word: m***** > o
(Guess) Enter a letter in word: mo**** > n
(Guess) Enter a letter in word: mon*** > k
(Guess) Enter a letter in word: monk** > r
r is not in word
(Guess) Enter a letter in word: monk** > e
(Guess) Enter a letter in word: monke* > y
The word is monkey .You x=missed it 1 time
Do you want to guess other words? Enter y or n: y
(Guess) Enter a letter in word: ***** > h
h is not in word
(Guess) Enter a letter in word: ***** > d
d is not in word
(Guess) Enter a letter in word: ***** > f
f is not in word
(Guess) Enter a letter in word: ***** > a
(Guess) Enter a letter in word: a**** > p
(Guess) Enter a letter in word: app** > r
r is not in word
(Guess) Enter a letter in word: app** > l
(Guess) Enter a letter in word: appl* > e
The word is apple .You x=missed it 4 time
Do you want to guess other words? Enter y or n: n
二维数组
1、
import java.util.*;
class ProblemNine{
public static void main(String[] args){
Scanner scanner=new Scanner(System.in);
//1、定义一个矩阵,二维数组
double[][] column=new double[3][4];
//提示用户输入有一个数组
System.out.println("Enter a 3-by-4 matrix row by row: ");
for(int i=0;i<3;i++){
for(int j=0;j<4;j++){
column[i][j]=scanner.nextDouble();
}
}
//调用函数返回每列的和,并输出
for(int k=0;k<4;k++){
System.out.println("Sum of elements at column "+k+" is "+sumColumn(column,k));
}
}
public static double sumColumn(double[][] column,int columnIndex){
double sum=0;
for(int i=0;i<column.length;i++){
sum+=column[i][columnIndex];
}
return sum;
}
}
运行结果
Enter a 3-by-4 matrix row by row:
1 2 3 4
2 3 4 5
3 4 5 6
Sum of elements at column 0 is 6.0
Sum of elements at column 1 is 9.0
Sum of elements at column 2 is 12.0
Sum of elements at column 3 is 15.0
2、
import java.util.Scanner;
class ProblemTen{
public static void main(String[] args){
Scanner scanner=new Scanner(System.in);
System.out.println("Enter a 4-by-4 matrix row by row:");
double[][] matrix=new double[4][4];
//初始化矩阵
for(int row=0;row<matrix.length;row++){
for(int col=0;col<matrix[row].length;col++){
matrix[row][col]=scanner.nextDouble();
}
}
double sum=0;
for(int j=0;j<matrix.length;j++){
sum+=matrix[j][j];
}
System.out.println("Sum of the elements in the major diagonal is "+sum);
}
}
运行结果
Enter a 4-by-4 matrix row by row:
1 2 3 4
1 2 3 4
1 2 3 4
1 2 3 4
Sum of the elements in the major diagonal is 10.0
3、
/*
数据:用户输入进来的两个矩阵matrix1和matrix2 矩阵相乘之后的得到的新矩阵newMatrix
指令:提示用户输入两个矩阵 调用multiplyMatrix()方法;
步骤:
1、先提示用户输入两个矩阵matrix1和matrix2
2、调用multiplyMatrix()
*/
import java.util.Scanner;
class ProblemEleven{
public static void main(String[] args){
Scanner scanner=new Scanner(System.in);
System.out.print("Enter matrix1:");
double[][] matrix1=new double[3][3];
double[][] matrix2=new double[3][3];
for(int i=0;i<3;i++){
for(int j=0;j<3;j++){
matrix1[i][j]=scanner.nextDouble();
}
}
System.out.print("Enter matrix2:");
for(int k=0;k<3;k++){
for(int l=0;l<3;l++){
matrix2[k][l]=scanner.nextDouble();
}
}
multiplyMatrix(matrix1,matrix2);
}
public static void multiplyMatrix(double[][] matrix1,double[][] matrix2){
double[][] newMatrix=new double[matrix1.length][matrix2[0].length];
for(int i=0;i<newMatrix.length;i++){
for(int j=0;j<newMatrix[i].length;j++){
double sum=0;
for(int k=0;k<matrix2.length;k++){
sum+=matrix1[i][k]*matrix2[k][j];
}
newMatrix[i][j]=sum;
System.out.printf("%4.2f ",newMatrix[i][j]);
}
System.out.println();
}
}
}
运行结果
Enter matrix1:1 2 3 4 5 6 7 8 9
Enter matrix2:0 2 3 5 6 7 8 4 2
34.00 26.00 23.00
73.00 62.00 59.00
112.00 98.00 95.00
4、
/*
数据:用户输入的方阵长度 随机产生的方阵
指令:提示用户输入方阵大小
*/
import java.util.*;
class ProblemTwelve{
public static void main(String[] args){
//1.输入方针的尺寸 创建方阵
Scanner scanner=new Scanner(System.in);
System.out.print("Enter size:");
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.让行,列,对角线累加 sum==0 sum==size 表示全相等
checkRow(m);
checkCol(m);
checkDiagonal(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);
}
}
public static void checkDiagonal(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);
}
}
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);
}
}
}
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);
}
}
}
}
运行结果
Enter size:6
0 1 0 0 1 1
0 0 1 0 0 0
0 0 0 0 1 1
1 0 1 1 1 1
1 0 0 1 1 0
0 1 1 0 0 1
0 0 1
1 1 1
0 0 0
第2行全相等且是1
第3行全相等且是0
5、
import java.util.*;
class ProblemThirteen{
public static void main(String[] args){
Scanner scanner=new Scanner(System.in);
System.out.print("Enter row ,col:");
int row=scanner.nextInt();
int col=scanner.nextInt();
int[][] m=new int[row][col];
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[0].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[0].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;//四个方向都没有连续的
}
}
运行结果
1 2 3 4
2 3 4 5
1 2 4 5
false
Enter row ,col:6 6
1 1 1 1 1 1
2 11 1 1 1 1
1 2 3 4 5 6
1 2 3 4 56 1
1 1 2 3 4 5
1 6 7 3 2 1
true
6、
import java.util.*;
class ProblemFifteen{
/*
五子棋 黑白棋 谁先连成5个子 谁就赢
棋盘 我们用什么去表示棋盘
+++++++
+++++++
+++++++
那也就是说我们需要创建一个String的二维数组来表示棋盘
如何下棋呢?
目前我们的程序是控制台程序,不能说是用点击的方式进行下棋
只能是输入棋子的坐标进行下棋
输入 1,1 指的就是在(0,0)处下一个棋子
初始化棋盘 initBoard()
打印棋盘 printBoard()
开始游戏 startGame()
下棋(黑白) putDownChess()
判断输赢 isGameOver()
上述方法都会去调用棋盘board数据
如果每次讲board当做参数传递个函数的时候 会显得比较麻烦
我们可以将board数据定义为全局变量 任何函数都可以访问的变量
全局变量定义在函数的外面 类的里面 必须public static开头
*/
//全局变量 棋盘 方便函数直接调用 而不需要依次传参
public static String[][] board; //定义为是15*15的棋盘
public static String BLACK_CHESS="O"; //黑棋
public static String WHITE_CHESS="X"; //白棋
public static Scanner scanner=new Scanner(System.in);
public static void main(String[] args){
//1.初始化棋盘
initBoard();
//2.打印棋盘
printBoard();
//3.开始游戏
startGame();
}
public static void startGame(){
/*
黑方 白方 轮流 下棋
*/
int player=0; //player 偶数 黑 ;奇数 白
while(true){
if(player%2==0){ //黑方下棋
System.out.print(">>>请黑方下棋:");
if(!putDownChess(BLACK_CHESS)){
continue;
}
}else{ //白方下棋
System.out.print(">>>请白方下棋:");
if(!putDownChess(WHITE_CHESS)){
continue;
}
}
if(isGameOver()){
break;
}
player++;
}
System.out.println("游戏结束");
}
public static boolean isGameOver(){
int i;
int j;
int k;
//向右判断
for(i=0;i<15;i++){
for(j=0;j<11;j++){
for(k=j;k<j+5;k++){
if(board[i][j]!=board[i][k]){
break;
}
}if((k-j)==4&&board[i][k].charAt(0)=='X'){
System.out.println("白方胜");
return true;
}else if((k-j)==4&&board[i][k].charAt(0)=='O'){
System.out.println("黑方胜");
return true;
}else{
break;
}
}
}
//向下判断
for(i=0;i<15;i++){
for(j=0;j<11;j++){
for(k=j;k<j+5;k++){
if(board[j][i]!=board[k][i]){
break;
}
}if((k-j)==4&&board[j][k].charAt(0)=='X'){
System.out.println("白方胜");
return true;
}else if((k-j)==4&&board[j][k].charAt(0)=='O'){
System.out.println("黑方胜");
return true;
}else{
break;
}
}
}
//向右下判断
for(i=0;i<11;i++){
for(j=0;j<11;j++){
for(k=0;k<5;k++){
if(board[i][j]!=board[i+1][j+1]){
break;
}
}
if(k==4&&board[i][j].charAt(0)=='X'){
System.out.println("白方胜");
return true;
}else if(k==4&&board[i][j].charAt(0)=='O'){
System.out.println("黑方胜");
return true;
}else{
break;
}
}
}
//向左下判断
for(i=14;i>4;i--){
for(j=14;j>4;j--){
for(k=0;k<5;k++){
if(board[i][j]!=board[i-1][j+-1]){
break;
}
}
if(k==4&&board[i][j].charAt(0)=='X'){
System.out.println("白方胜");
return true;
}else if(k==4&&board[i][j].charAt(0)=='O'){
System.out.println("黑方胜");
return true;
}else{
break;
}
}
}
return false;
}
public static boolean putDownChess(String chess){
//用户输入的 (1,1) -> (0,0)
//1 B
int x=scanner.nextInt()-1;
int y=scanner.next().charAt(0)-'A';
if(!board[x][y].equals("+")){
System.out.println(">>>此处已有棋子,请重新下棋");
//另外一种处理方式 就是讲player定义为全局 此处player--即可
return false;//意味着下棋不成功
}
board[x][y]=chess;
printBoard();
return true; //意味着下棋成功
}
public static void printBoard(){
System.out.print(" ");
for(int i=0;i<=14;i++){
System.out.print((char)('A'+i)+" ");
}
System.out.println();
for(int i=0;i<board.length;i++){
System.out.printf("%2d ",i+1);
for(int j=0;j<board[i].length;j++){
System.out.print(board[i][j]+" ");
}
System.out.println();
}
}
public static void initBoard(){
board=new String[15][15];
for(int i=0;i<board.length;i++){
for(int j=0;j<board[i].length;j++){
board[i][j]="+";
}
}
}
}
运行结果
1 2 3
1 1 1
1 1 1
Wrong input:the letters must be from A to C
Enter number n: 3
Enter 3 rows of letters separated by spaces:
1 2 3
2 3 1
3 1 2
The input array is a Latin square