Java数字拼图-二维数组实现，控制台可以对空格进行移动

最新推荐文章于 2021-02-23 22:11:34 发布
原创 最新推荐文章于 2021-02-23 22:11:34 发布 · 638 阅读 · 4 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java

本文介绍了一款基于二维数组的数字拼图游戏实现方法。游戏使用3x3矩阵表示拼图，通过随机打乱和玩家操作来还原原始顺序。文章详细讲解了如何判断0（空格）的移动范围，实现数字的随机打乱和玩家输入控制，以及如何验证拼图是否完成。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

二维数组实现数字拼图

二维数组可以自己随意定义大小，通过方法判断来实现对所有的数字进行随机打乱，并可以通过移动来正确还原，并可以判断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;
		}
	}

}
【C#、C++ 和 Java 】实现华容道游戏
走向CTO的路上...
05-18 594
华容道是一款经典的滑动拼图游戏，玩家需通过移动不同大小的方块，将最大的方块（曹操）移至出口。实现华容道需要精确管理方块的位置和尺寸，并判断移动是否合法。本文介绍了在C#、C++和Java中实现华容道的环境准备和核心逻辑。盘面可用二维数组表示，每个方块需记录其位置、尺寸和身份。核心逻辑包括判断方块是否可移动、执行移动及判断游戏是否完成。代码示例展示了盘面和方块的表示，以及移动判断和执行的实现。
JAVA数字拼图代码
05-21
NetBeans IDE 实现的 JAVA数字拼图代码
JAVA数字拼图游戏
06-27
JAVA数字拼图游戏
java 数字拼图
07-03
5*5的数字拼图
java 数字拼图游戏
09-24
此程序运用算法自动完成杂乱的数字拼图，完成后停止。
我最喜欢的Java拼图2 + 1 = 4
最佳 Java 编程
05-26 144
这是我当前最喜欢的Java难题。 您如何获取代码来执行此操作？ Integer b = 2; Integer c = 1; System.out.println("b+c : " + (b+c) ); // output: 'b+c : 4' !! Sytem.out.println（）没有技巧，即您将能够在调试器中看到相同的值。 提示：您需要在程序中的某处之前添加几行代码。 向下滚动...
自己用java做的数字拼图游戏
03-30
这是我自己写的一个关于数字拼图的游戏程序，程序中包括计时器显示和计步显示。并且有初始可完成验证和拼图完成验证，文件是jar格式，可以运行看下效果，jar里有源代码，代码中有我写的详细的程序注释，感兴趣的朋友可以看一样，水平有限，有不好的地方，希望大家提建议！
Java控制台实现15拼图游戏，简单入门指南
此外，它可能使用了数据结构来有效地管理游戏板的状态，如二维数组来表示拼图的格子，并实现算法来检测获胜条件和随机生成游戏板。 7. 可解决性问题： 描述中提到生成的板不一定是可解决的。这表明算法在生成游戏板...
Java实现8拼图算法的完整代码解析
1. 数据结构：通常需要一个二维数组来表示拼图的状态，其中空格可以使用特定的值表示（比如0或null）。 2. 拼图的移动：实现一个方法来模拟玩家的移动操作，更新拼图的状态。 3. 检查是否成功：实现一个方法来检查...
基于C语言的拼图游戏设计与代码实现
06-22
在C语言中，我们可以使用二维数组来表示拼图的各个部分，并用结构体来封装这些信息，包括位置、旋转状态等。 1. **数据结构设计**： - 定义一个结构体`Piece`，包含以下字段：原始图像的子区域（一个二维数组）、...
C语言数字拼图游戏：实现并显示成功步数
- 定义了两个二维整型数组 `a[SNUM][SNUM]` 用于存储完整的拼图，`a` 可能是 100x100 的大小，但这里仅用于示例。 - `line` 和 `max` 可能是游戏中的临时变量，未在给定的部分中具体使用。 - `c` 和 `d` 是用于...
Java课程设计数字模板拼图游戏
10-18
JAVA面向对象的程序设计课程设计的一个项目，我做的是一个数字模板拼图游戏。分为3X3和4X4的难度，同时还包含游戏的选择菜单，完成游戏时的成绩，利用Sqlite数据库进行游戏成绩的保存。还能在菜单中查看游戏成绩排名。整个工程项目已经打包。由于自己能力有限，代码有很多的不足。有能力的可以自己优化代码。
数字拼图游戏java原代码
01-06
用java实现了数字拼图游戏.本程序对于刚学java的新手很有帮助,程序中用到的java基础知识较多,可以锻炼自己的编程能力,掌握java基础知识.
数字拼图
02-23
有点小问题的数字拼图游戏。若有哪位大侠解决了，请告诉我。
java，简单数字拼图
11-15
16放个排序游戏设计。4*4的案件，只有15个按键，，最后一个按钮没有数字，当程序启动时这15个数字是随机排列的。单击某个按钮，这个按钮会移动。开始时候数字随机，当15个数字成顺序或者逆序排列时 弹出消息框 提示排列成功。并重新排列着15个数字在按钮网格上的位置。 《Java 程序设计教程》雍俊海 第八章 课后第九题
java数字拼图代码_实战-Swing实现数字拼图
weixin_39843847的博客
02-16 551
实战-Swing实现数字拼图1 Swing实现数字拼图我们可以借助Swing和事件处理功能来开发Java数字拼图游戏。让我们看看在Java中创建Java数字拼图游戏的代码。package com.yiidian;import java.awt.*;import javax.swing.*;import java.awt.event.*;public class puzzle extends JFr...
java游戏设计:3×3数字拼图代码_BFSAlgorithm.java
weixin_39922004的博客
02-23 386
package test;import java.math.BigInteger;import java.util.ArrayList;import java.util.Arrays;import java.util.HashMap;public class BFSAlgorithm {//private static int[] tState = {7,8,5,3,2,6,0,4,1};//初始...
二维数组
wanluan_3035790的博客
06-21 344
二维数组 二维数组：就是元素为一维数组的一个数组。 格式1：     数据类型[][] 数组名 = new 数据类型[m][n];             m:表示这个二维数组有多少个一维数组。             n:表示每一个一维数组的元素有多少个。 注意：            A:以下格式也可以表示二维数组            a:数据类型 数组名[]
Java拼图游戏
Remoa的休闲茶馆
01-30 2480
总结： 1）添加事件处理要掌握； 2）强制类型转换时若转换的是一个表达式，要记得整体括号括起来转换； 3）静态成员变量的使用 4）实现了某个事件监听器接口时，要记得实现接口中的抽象方法 5）形如 java.lang.Object→ java.awt.Component→ java.awt.Container→ java.awt.Window→ java.awt.Frame→
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值