java语言程序设计基础篇——多维数组（2）

63 阅读 0 评论 42 点赞

我是靠谱客的博主机智小猫咪，最近开发中收集的这篇文章主要介绍java语言程序设计基础篇——多维数组（2），觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

import java.util.Scanner;
public class Exercise8_19 {
public static boolean isConsecutiveFour(int[][] values){
int numberOfRows = values.length;
int numberOfColumns = values[0].length;
for(int i=0;i<numberOfRows;i++){//判断每一行是否有四个连续的数字
if(isConsecutiveFour(values[i]))
return true;
}
for(int j=0;j<numberOfColumns;j++){//判断每一列是否有四个连续的数字
int[] column = new int[numberOfRows];
for(int i=0;i<numberOfRows;i++)
column[i] = values[i][j];
if(isConsecutiveFour(column))
return true;
}
for(int i=0;i<numberOfRows-3;i++){判断主对角线下半部分是否有四个连续的数字
int numberOfElementsInDiagonal = Math.min(numberOfRows-i,numberOfColumns);
int[] diagonal = new int[numberOfElementsInDiagonal];
for(int k=0;k<numberOfElementsInDiagonal;k++)
diagonal[k] = values[k+i][k];
if (isConsecutiveFour(diagonal))
return true;
}
for(int j=1;j<numberOfColumns-3;j++){//判断主对角线上半部分是否有四个连续的数字
int numberOfElementsInDiagonal= Math.min(numberOfColumns-j,numberOfRows);
int[] diagonal = new int[numberOfElementsInDiagonal];
for(int k=0; k<numberOfElementsInDiagonal;k++)
diagonal[k] = values[k][k+j];
if(isConsecutiveFour(diagonal))
return true;
}
for(int j=3;j<numberOfColumns;j++){//判断副对角线左半部分是否有四个连续的数字
int numberOfElementsInDiagonal = Math.min(j+1,numberOfRows);
int[] diagonal = new int[numberOfElementsInDiagonal];
for(int k=0;k<numberOfElementsInDiagonal;k++)
diagonal[k] = values[k][j - k];
if(isConsecutiveFour(diagonal))
return true;
}
for(int i=1;i<numberOfRows-3;i++){//判断副对角线右半部份是否有四个连续的数字
int numberOfElementsInDiagonal = Math.min(numberOfRows-i,numberOfColumns);
int[] diagonal = new int[numberOfElementsInDiagonal];
for(int k=0;k<numberOfElementsInDiagonal;k++)
diagonal[k] = values[k+i][numberOfColumns-k-1];
if(isConsecutiveFour(diagonal))
return true;
}
return false;
}
//判断每一行元素中有没有四个连续的数字
//方法重载
public static boolean isConsecutiveFour(int[] values){
for(int i=0;i<values.length-3;i++){
boolean isEqual = true;
for(int j=i;j<i+3;j++){
if(values[j]!=values[j+1]){
isEqual = false;
break;
}
}
if(isEqual)
return true;
}
return false;
}
public static void main(String[] args){
Scanner input = new Scanner(System.in);
System.out.print("Enter the number of row: ");
int numOfR = input.nextInt();
System.out.print("Enter the number of column: ");
int numOfC = input.nextInt();
System.out.println("Enter the array:");
int[][] f = new int[numOfR][numOfC];
for(int i=0;i<numOfR;i++){
for(int j=0;j<numOfC;j++){
f[i][j] = input.nextInt();
}
}
System.out.println(isConsecutiveFour(f));
}
}

被重载的方法必须具有不同的参数列表。不能基于不同修饰符或返回值类型来重载方法。

（方法重载：方法名字一样，参数个数或者参数类型不同，函数的返回值类型不同不作为函数重载的标志。）

九宫格是一个9×9的网格，它分为更小的3×3的盒子，将从1到9的数字植入格子里，使每行、每列以及每个3×3盒子都包含1到9的数字。

import java.util.Arrays;
import java.util.Scanner;
public class Exercise8_24 {
public static void main(String[] args){
int[][] grid = readASolution();
System.out.println(isValid(grid) ? "Valid solution":"Invalid solution");
}
private static int[][] readASolution() {
// TODO Auto-generated method stub
Scanner input = new Scanner(System.in);
System.out.println("Enter a Sudoku puzzle solution:");
int[][] grid = new int[9][9];
for(int i=0;i<9;i++){
for(int j=0;j<9;j++){
grid[i][j] = input.nextInt();
}
}
return grid;
}
private static boolean isValid(int[][] grid) {
// TODO Auto-generated method stub
for(int i=0;i<9;i++){//判断每一行是否具有数字1到9
if(!is1To9(grid[i]))
return false;
}
for(int j=0;j<9;j++){//判断每一列是否具有数字1到9
int[] column = new int[9];
for(int i=0;i<9;i++){
column[i] = grid[i][j];
}
if(!is1To9(column))
return false;
}
for(int i=0;i<3;i++){//判断每一个小的方盒是否具有数字1到9
for(int j=0;j<3;j++){
int k=0;
int[] list = new int[9];
for(int row = i*3;row<i*3+3;row++){
for(int column = j*3;column<j*3+3;column++){
list[k++] = grid[row][column];
}
}
if(!is1To9(list))
return false;
}
}
return true;
}
private static boolean is1To9(int[] list) {
// TODO Auto-generated method stub
int[] temp = new int[list.length];
//使用java.lang.System类中的静态方法arraycopy复制数组
System.arraycopy(list, 0, temp, 0, list.length);
Arrays.sort(temp);
for(int i=0;i<9;i++){
if(temp[i]!=i+1)
return false;
}
return true;
}
}

复制数组的方法：

1.(java.lang.)System.arraycopy(sourceArray , src_pos , targetArray , tar_pos , length)；

参数src_pos和tar_pos分别表示在源数组sourceArray和目标数组targetArray中的起始位置。从sourceArray复制到targetArray中的元素个数由参数length指定。

注意：arraycopy方法没有给目标数组分配内存空间。复制前必须创建目标数组以及分配给它的内存空间。复制完成后，sourceArray和targetArray具有相同的内容，但占有独立的内存空间。

2.Cloneable接口：实现Cloneable接口的类标记为可克隆的，而且它的对象可以使用在Object类中定义的clone()方法克隆；

Java库中的很多类（Data、Calendar、ArrayList）实现Cloneable。这样，这些类的实例可以被克隆。

使用clone方法克隆一个数组：

int[] list1 = {1,2};
int[] list2 = list1.clone();

3.使用循环语句逐个地复制数组元素

import java.util.Arrays;
import java.util.Scanner;
public class Exercise8_36 {
public static void main(String[] args){
Scanner input = new Scanner(System.in);
System.out.print("Enter number n: ");
int n = input.nextInt();
char[] letters = new char[n];//在字符数组letters里面按照字母顺序存储从A开始的n个字母
for(int i=0;i<n;i++)
letters[i] = (char)('A'+i);
char[][] f = new char[n][n];
System.out.println("Enter "+n+" rows of letters separated by spaces:");
for(int i=0;i<n;i++){
if(i==0){//nextLine():取到一个换行符前面的数据，所以一开始程序已经从控制台读入Enter...的字符串内容，长度为1
//只能设置一个字符串s1将以上字符串读入不进行任何其他操作。
String s1 = input.nextLine();
}
String s = input.nextLine();
String[] items = s.split("[ .+]");//分割字符串
if(items.length!=n){
System.out.println("Wrong input: you need to enter exactly "+n+" letters");
System.exit(1);//System.exit(status)，status表示退出的状态码，非零表示异常终止
}
for(int j=0;j<items.length;j++){
if(items[j].length()!=1){
System.out.println("Wrong input: you need to enter single letters");
System.exit(2);
}
f[i][j] = items[j].charAt(0);
}
char[] clonedRow = f[i].clone();//复制每一行到clonedRow数组里面
Arrays.sort(clonedRow);
if(!Arrays.equals(clonedRow, letters)){
System.out.println("Wrong input: the letters must be from "+letters[0]+" to "+letters[letters.length-1] );
}
}
char[][] transposedMatrix = getTransposed(f);
for(int i=0;i<f.length;i++){
Arrays.sort(transposedMatrix[i]);
if(!Arrays.equals(letters, transposedMatrix[i])){
System.out.println("The input array is not a Latin square");
System.exit(4);
}
}
System.out.println("The input array is a Latin square");
}
private static char[][] getTransposed(char[][] f) {//将数组进行转置
// TODO Auto-generated method stub
char[][] result = new char[f.length][f.length];
for(int j=0;j<f.length;j++){
for(int i=0;i<f.length;i++){
result[i][j] = f[j][i];
}
}
return result;
}
}