Java二维数组实现数字拼图效果
二维数组实现数字拼图，供大家参考，具体内容如下
二维数组可以自己随意定义大小，通过方法判断来实现对所有的数字进行随机打乱，并可以通过移动来正确还原，并可以判断0（表示空格）是否可以移动，是否在范围内。
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int[][] arrays = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 0 } };
int sum = 1;
String direction;
bianLi(arrays);
daLuanErWeiShuZu(arrays);
System.out.println("========================================");
while (true) {
bianLi(arrays);
if (isOk(arrays)) {
break;
}
sum++;
try {
Thread.sleep(500);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("请输入移动方向(W 上、S 下、A 左、D 右)");
direction = scanner.next();
switch (direction) {
case "W":
case "w":
tiHuanShuZuWeiZhi(returnX(arrays), returnY(arrays), "上", arrays);
break;
case "S":
case "s":
tiHuanShuZuWeiZhi(returnX(arrays), returnY(arrays), "下", arrays);
break;
case "A":
case "a":
tiHuanShuZuWeiZhi(returnX(arrays), returnY(arrays), "左", arrays);
break;
case "D":
case "d":
tiHuanShuZuWeiZhi(returnX(arrays), returnY(arrays), "右", arrays);
break;
default:
System.out.println("非法输入，重新输入");
break;
}
}
System.out.println("一共走了" + sum + "步");
System.out.println("挑战成功");
}
判断当前坐标是否可以移动
/**
* 判断当前坐标是否可以移动
*
* @param arrays
* @return 可以移动返回true
*/
public static boolean isYiDong(int[][] arrays) {
int returnX = returnX(arrays);
int returnY = returnY(arrays);
System.out.println(returnX + ":" + returnY);
if (returnX >= 0 && returnX + 1 < arrays.length && returnY >= 0 && returnY + 1 < arrays.length) {
return true;
}
return false;
}
获取当前0所在行的具体地址
// 获取0所在行的位置
public static int returnX(int[][] arrays) {
for (int i = 0; i < arrays.length; i++) {
for (int j = 0; j < arrays[i].length; j++) {
if (0 == arrays[i][j]) {
return i;
}
}
}
return -1;
}
获取当前0所在列的具体地址
// 获取0所在列的位置
public static int returnY(int[][] arrays) {
for (int i = 0; i < arrays.length; i++) {
for (int j = 0; j < arrays[i].length; j++) {
if (0 == arrays[i][j]) {
return j;
}
}
}
return -1;
}
二维数组随机打乱，需要判断左上角、右上角、左下角、右下角、中间、上中、下种、左中、右中，那些方向可以移动，生成随机数来确定移动方向
// 二维数组随机打乱
public static void daLuanErWeiShuZu(int[][] arrays) {
for (int i = 0; i < arrays.length; i++) {
for (int j = 0; j < arrays[i].length; j++) {
// 左上
if (i == 0 && j == 0) {
// 根据生成的随机数确定向右边边移动还是向下移动
if (ouShuOrJiShu()) {
tiHuanShuZuWeiZhi(i, j, "下", arrays);
} else {
tiHuanShuZuWeiZhi(i, j, "右", arrays);
}
}
// 右上
if (i == 0 && j == arrays[0].length - 1) {
// 根据生成的随机数确定向左边边移动还是向下移动
if (ouShuOrJiShu()) {
tiHuanShuZuWeiZhi(i, j, "下", arrays);
} else {
tiHuanShuZuWeiZhi(i, j, "左", arrays);
}
}
// 左下
if (i == arrays.length - 1 && j == 0) {
// 根据生成的随机数确定向左边边移动还是向下移动
if (ouShuOrJiShu()) {
tiHuanShuZuWeiZhi(i, j, "上", arrays);
} else {
tiHuanShuZuWeiZhi(i, j, "右", arrays);
}
}
// 右下
if (i == arrays.length - 1 && j == arrays[i].length - 1) {
// 根据生成的随机数确定向左边边移动还是向下移动
if (ouShuOrJiShu()) {
tiHuanShuZuWeiZhi(i, j, "上", arrays);
} else {
tiHuanShuZuWeiZhi(i, j, "左", arrays);
}
}
// 上中
if (i == 0 && j > 0 && j < arrays[i].length - 1) {
switch (oneToThree(3)) {
case 0:
tiHuanShuZuWeiZhi(i, j, "右", arrays);
break;
case 1:
tiHuanShuZuWeiZhi(i, j, "下", arrays);
break;
case 2:
tiHuanShuZuWeiZhi(i, j, "左", arrays);
break;
default:
break;
}
}
// 左中
if (j == 0 && i > 0 && i < arrays.length - 1) {
switch (oneToThree(3)) {
case 0:
tiHuanShuZuWeiZhi(i, j, "上", arrays);
break;
case 1:
tiHuanShuZuWeiZhi(i, j, "右", arrays);
break;
case 2:
tiHuanShuZuWeiZhi(i, j, "下", arrays);
break;
default:
break;
}
}
// 下中
if (i == arrays.length - 1 && j > 0 && j < arrays[i].length - 1) {
switch (oneToThree(3)) {
case 0:
tiHuanShuZuWeiZhi(i, j, "上", arrays);
break;
case 1:
tiHuanShuZuWeiZhi(i, j, "右", arrays);
break;
case 2:
tiHuanShuZuWeiZhi(i, j, "左", arrays);
break;
default:
break;
}
}
// 右中
if (j == arrays[i].length - 1 && i > 0 && i < arrays[i].length - 1) {
switch (oneToThree(3)) {
case 0:
tiHuanShuZuWeiZhi(i, j, "上", arrays);
break;
case 1:
tiHuanShuZuWeiZhi(i, j, "左", arrays);
break;
case 2:
tiHuanShuZuWeiZhi(i, j, "下", arrays);
break;
default:
break;
}
}
if (i > 0 && j > 0 && i < arrays.length - 2 && j < arrays[i].length - 2) {
switch (oneToThree(4)) {
case 0:
tiHuanShuZuWeiZhi(i, j, "上", arrays);
break;
case 1:
tiHuanShuZuWeiZhi(i, j, "右", arrays);
break;
case 2:
tiHuanShuZuWeiZhi(i, j, "下", arrays);
break;
case 3:
tiHuanShuZuWeiZhi(i, j, "左", arrays);
break;
default:
break;
}
}
}
}
}
该方法实现对0的位置和需要替换位置数据的替换，并对0范围进行验证，怕0出现数组下标越位。
/**
* 根据输入的数据，对二维数组进行数据替换
*
* @param i 高位坐标
* @param j 地位坐标
* @param direction 移动方向
* @param arrays 需要交换数据的数组
*/
public static void tiHuanShuZuWeiZhi(int i, int j, String direction, int[][] arrays) {
int tem = -1;
switch (direction) {
case "上":
if (i > 0) {
tem = arrays[i][j];
arrays[i][j] = arrays[i - 1][j];
arrays[i - 1][j] = tem;
}
break;
case "下":
if (i < arrays.length - 1) {
tem = arrays[i][j];
arrays[i][j] = arrays[i + 1][j];
arrays[i + 1][j] = tem;
}
break;
case "左":
if (j > 0) {
tem = arrays[i][j];
arrays[i][j] = arrays[i][j - 1];
arrays[i][j - 1] = tem;
}
break;
case "右":
if (j < arrays.length - 1) {
tem = arrays[i][j];
arrays[i][j] = arrays[i][j + 1];
arrays[i][j + 1] = tem;
}
break;
default:
break;
}
}
完整代码如下
import java.util.Random;
import java.util.Scanner;
public class Demo {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int[][] arrays = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 0 } };
int sum = 1;
String direction;
bianLi(arrays);
daLuanErWeiShuZu(arrays);
System.out.println("========================================");
while (true) {
bianLi(arrays);
if (isOk(arrays)) {
break;
}
sum++;
try {
Thread.sleep(500);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("请输入移动方向(W 上、S 下、A 左、D 右)");
direction = scanner.next();
switch (direction) {
case "W":
case "w":
tiHuanShuZuWeiZhi(returnX(arrays), returnY(arrays), "上", arrays);
break;
case "S":
case "s":
tiHuanShuZuWeiZhi(returnX(arrays), returnY(arrays), "下", arrays);
break;
case "A":
case "a":
tiHuanShuZuWeiZhi(returnX(arrays), returnY(arrays), "左", arrays);
break;
case "D":
case "d":
tiHuanShuZuWeiZhi(returnX(arrays), returnY(arrays), "右", arrays);
break;
default:
System.out.println("非法输入，重新输入");
break;
}
}
System.out.println("一共走了" + sum + "步");
System.out.println("挑战成功");
}
// /**
// * 判断当前坐标是否可以移动
// *
// * @param arrays
// * @return 可以移动返回true
// */
// public static boolean isYiDong(int[][] arrays) {
// int returnX = returnX(arrays);
// int returnY = returnY(arrays);
// System.out.println(returnX + ":" + returnY);
// if (returnX >= 0 && returnX + 1 < arrays.length && returnY >= 0 && returnY + 1 < arrays.length) {
// return true;
// }
// return false;
// }
/**
*
* @param arrays 需要验证的数据
* @return 成功返回true
*/
public static boolean isOk(int[][] arrays) {
int sum = 1;
for (int i = 0; i < arrays.length; i++) {
for (int j = 0; j < arrays.length; j++) {
if (sum == 9) {
sum = 0;
}
if (arrays[i][j] != sum) {
return false;
}
sum++;
}
}
return true;
}
// 获取0所在行的位置
public static int returnX(int[][] arrays) {
for (int i = 0; i < arrays.length; i++) {
for (int j = 0; j < arrays[i].length; j++) {
if (0 == arrays[i][j]) {
return i;
}
}
}
return -1;
}
// 获取0所在列的位置
public static int returnY(int[][] arrays) {
for (int i = 0; i < arrays.length; i++) {
for (int j = 0; j < arrays[i].length; j++) {
if (0 == arrays[i][j]) {
return j;
}
}
}
return -1;
}
// 遍历二维数组
public static void bianLi(int[][] arrays) {
for (int[] is : arrays) {
for (int is2 : is) {
System.out.print(is2 + "\t");
}
System.out.println();
}
}
// 二维数组随机打乱
public static void daLuanErWeiShuZu(int[][] arrays) {
for (int i = 0; i < arrays.length; i++) {
for (int j = 0; j < arrays[i].length; j++) {
// 左上
if (i == 0 && j == 0) {
// 根据生成的随机数确定向右边边移动还是向下移动
if (ouShuOrJiShu()) {
tiHuanShuZuWeiZhi(i, j, "下", arrays);
} else {
tiHuanShuZuWeiZhi(i, j, "右", arrays);
}
}
// 右上
if (i == 0 && j == arrays[0].length - 1) {
// 根据生成的随机数确定向左边边移动还是向下移动
if (ouShuOrJiShu()) {
tiHuanShuZuWeiZhi(i, j, "下", arrays);
} else {
tiHuanShuZuWeiZhi(i, j, "左", arrays);
}
}
// 左下
if (i == arrays.length - 1 && j == 0) {
// 根据生成的随机数确定向左边边移动还是向下移动
if (ouShuOrJiShu()) {
tiHuanShuZuWeiZhi(i, j, "上", arrays);
} else {
tiHuanShuZuWeiZhi(i, j, "右", arrays);
}
}
// 右下
if (i == arrays.length - 1 && j == arrays[i].length - 1) {
// 根据生成的随机数确定向左边边移动还是向下移动
if (ouShuOrJiShu()) {
tiHuanShuZuWeiZhi(i, j, "上", arrays);
} else {
tiHuanShuZuWeiZhi(i, j, "左", arrays);
}
}
// 上中
if (i == 0 && j > 0 && j < arrays[i].length - 1) {
switch (oneToThree(3)) {
case 0:
tiHuanShuZuWeiZhi(i, j, "右", arrays);
break;
case 1:
tiHuanShuZuWeiZhi(i, j, "下", arrays);
break;
case 2:
tiHuanShuZuWeiZhi(i, j, "左", arrays);
break;
default:
break;
}
}
// 左中
if (j == 0 && i > 0 && i < arrays.length - 1) {
switch (oneToThree(3)) {
case 0:
tiHuanShuZuWeiZhi(i, j, "上", arrays);
break;
case 1:
tiHuanShuZuWeiZhi(i, j, "右", arrays);
break;
case 2:
tiHuanShuZuWeiZhi(i, j, "下", arrays);
break;
default:
break;
}
}
// 下中
if (i == arrays.length - 1 && j > 0 && j < arrays[i].length - 1) {
switch (oneToThree(3)) {
case 0:
tiHuanShuZuWeiZhi(i, j, "上", arrays);
break;
case 1:
tiHuanShuZuWeiZhi(i, j, "右", arrays);
break;
case 2:
tiHuanShuZuWeiZhi(i, j, "左", arrays);
break;
default:
break;
}
}
// 右中
if (j == arrays[i].length - 1 && i > 0 && i < arrays[i].length - 1) {
switch (oneToThree(3)) {
case 0:
tiHuanShuZuWeiZhi(i, j, "上", arrays);
break;
case 1:
tiHuanShuZuWeiZhi(i, j, "左", arrays);
break;
case 2:
tiHuanShuZuWeiZhi(i, j, "下", arrays);
break;
default:
break;
}
}
if (i > 0 && j > 0 && i < arrays.length - 2 && j < arrays[i].length - 2) {
switch (oneToThree(4)) {
case 0:
tiHuanShuZuWeiZhi(i, j, "上", arrays);
break;
case 1:
tiHuanShuZuWeiZhi(i, j, "右", arrays);
break;
case 2:
tiHuanShuZuWeiZhi(i, j, "下", arrays);
break;
case 3:
tiHuanShuZuWeiZhi(i, j, "左", arrays);
break;
default:
break;
}
}
}
}
}
/**
* 判断是否是偶数
*
* @return 偶数返回true
*/
public static boolean ouShuOrJiShu() {
return new Random().nextInt(1000) % 2 == 0 ? true : false;
}
/**
*
* @param n 需要模的值
* @return 返回0-(n-1)的值
*/
public static int oneToThree(int n) {
return new Random().nextInt(1000) % n;
}
/**
* 根据输入的数据，对二维数组进行数据替换
*
* @param i 高位坐标
* @param j 地位坐标
* @param direction 移动方向
* @param arrays 需要交换数据的数组
*/
public static void tiHuanShuZuWeiZhi(int i, int j, String direction, int[][] arrays) {
int tem = -1;
switch (direction) {
case "上":
if (i > 0) {
tem = arrays[i][j];
arrays[i][j] = arrays[i - 1][j];
arrays[i - 1][j] = tem;
}
break;
case "下":
if (i < arrays.length - 1) {
tem = arrays[i][j];
arrays[i][j] = arrays[i + 1][j];
arrays[i + 1][j] = tem;
}
break;
case "左":
if (j > 0) {
tem = arrays[i][j];
arrays[i][j] = arrays[i][j - 1];
arrays[i][j - 1] = tem;
}
break;
case "右":
if (j < arrays.length - 1) {
tem = arrays[i][j];
arrays[i][j] = arrays[i][j + 1];
arrays[i][j + 1] = tem;
}
break;
default:
break;
}
}
}
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持我们。
相关推荐
-
Java二维数组实现数字拼图效果
二维数组实现数字拼图,供大家参考,具体内容如下 二维数组可以自己随意定义大小,通过方法判断来实现对所有的数字进行随机打乱,并可以通过移动来正确还原,并可以判断0(表示空格)是否可以移动,是否在范围内. public static void main(String[] args) { Scanner scanner = new Scanner(System.in); int[][] arrays = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 0 } }; int su
-
Java二维数组与动态数组ArrayList类详解
Java二维数组 Java 语言中提供的数组是用来存储固定大小的同类型元素. 1.二维数组初始化和声明 数组变量的声明,和创建数组可以用一条语句完成,如下所示: int a[][] = new int[2][3]; int[][] arr = {{1,2,3},{4,5,6},{7,8,9}}; 2.二维数组遍历 //遍历二维数组 public class Traverse_a_two_dimensional_array { public static void main(String[] ar
-
java二维数组基础知识详解
目录 1. 查找 2. 顺序查找 3. 二分查找 4. 多维数组 4.1 二维数组 175 4.2 二维数组细节 5. 二维数组的使用方式 176 6. 二维数组的动态初始化 1.先声明:类型 数组名[][]; 再定义(开辟空间) 数组名 = new 类型[大小][大小] 2.动态初始化-列数不确定 178 7. 二维数组的静态初始化 179 8. 二维数组练习 180 8.1 int arr[][]={{4,6},{1,4,5,7},{-2}}; 遍历该二维数组,并得到和 1. 查找 1) 顺
-
Java二维数组简单定义与使用方法示例
本文实例讲述了Java二维数组简单定义与使用方法.分享给大家供大家参考,具体如下: Java的二维数组是先创建一个一维数组,然后该数组的元素再引用另外一个一维数组.在使用二维数组的时候,通过两个中括号[]来访问每一层维度的引用,直到访问到最终的数据. public class MultiDimArray{ /** * @param args */ public static void main(String[] args) { int[][] arr = new int[3][]; arr[0]
-
Java二维数组实战案例
本文实例讲述了Java二维数组.分享给大家供大家参考,具体如下: 一 点睛 1 每行的元素个数不同的二维数组 Java定义二维数组更加灵活,允许二维数组中的每行的元素个数不相等,这点与其他编程语言不同,例如下面这个二维数组,其中第1行有4个元素,第2行有3个元素,第3行有5个元素 int [][] num={ {1,2,3,4}, {1,2,3}, {1,2,3,4,5} }; 下面的语句是声明整型的二维数组num并分配空间,其中第1行4个元素,第2行3个元素,第3行5个元素 int [][]
-
java二维数组指定不同长度实例方法
我们知道二维数组,是在一维数组的基础上进行了维度的增加.那么在实际使用的过程中,有时候我们所需要的二维数组,它们其中的维度是不同的,这就需要我们手动的进行设置.下面我们就来一起探究,二维数组在改变维度长度大小的方法,并辅以实例进行代码展示. 1.二维数组的每个元素都是一个一维数组,这些数组不一定都是等长的.声明二维数组的时候可以只指定第一维大小,空缺出第二维大小,之后再指定不同长度的数组.但是注意,第一维大小不能空缺(不能只指定列数不指定行数). public class ArrayTest4
-
java二维数组实现推箱子小游戏
本文实例为大家分享了java实现推箱子小游戏的具体代码,供大家参考,具体内容如下 二维数组 二维数组:类似于二维表格(有很多层,每一层有多个房间的楼房) 数组声明: 数据类型[][]数据名 = new 数据类型[行数][列数]; 获取二维数组的长度:数组名.lengt 得到的是行数 数组名[行下标].length 得到的是列数 推箱子小游戏 import java.util.Random; import java.util.Scanner; /* * 推箱子的小游戏 */ public clas
-
Java 二维数组创建及使用方式
目录 二维数组的创建 二维数组基本使用 1. 二维数组的使用 2. 使用方式 1: 动态初始化 3. 使用方式 2: 动态初始化 4. 使用方式 3: 动态初始化-列数不确 5. 使用方式 4: 静态初始化 6. 二维数组的应用案例 7. 二维数组使用细节和注意事项 8. 二维数组课堂练习 二维数组的创建 二维数组好比一个表格,第一个下标表示行,第二个下标表示列,数组的创建和初始化与一位数组一模一样,及二维数组就是一个把多个一维数组包起来的数组. 数组的创建: type[][] arrayNam
-
java二维数组遍历的2种代码
二维数组遍历: 思想: 1.先将二维数组中所有的元素拿到 2.再将二维数组中每个元素进行遍历,相当于就是在遍历一个一维数组 第一种方法:双重for循环 //遍历二维数组 public class Traverse_a_two_dimensional_array { public static void main(String[] args) { // TODO Auto-generated method stub int[][] arr = new int[2][3];//动态创建:2个元素(外
-
Java二维数组查找功能代码实现
题目描述: 在一个二维数组中(每个一维数组的长度相同),每一行都按照从左到右递增的顺序排序,每一列都按照从上到下递增的顺序排序.请完成一个函数,输入这样的一个二维数组和一个整数,判断数组中是否含有该整数. 题目分析: 根据二维数组的特点可知,二维数组相当于一个矩阵: 根据题意可知该数组是有序的,因此该矩阵元素相当于是从小到大排列的: 如果从左下角开始查找较方便,因为左下角的值向上是递减的,向右是递增的: 当从左下角开始比较时,如果target传入的数大于它则列数加一进行比较 ,如果小于它则行数减