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;
	}

	 
}

nextLine()读取一行文本（按下回车键为结束标志），取到一个换行符前面的数据

next()读取一个字符串，该字符在一个空白符前结束，取到一个间隔符前面的数据