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("挑战成功");

}

判断当前坐标是否可以移动



 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出现数组下标越位。



 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("挑战成功");

 }

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

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

 
 public static boolean ouShuOrJiShu() {
  return new Random().nextInt(1000) % 2 == 0 ? true : false;
 }

 
 public static int oneToThree(int n) {
  return new Random().nextInt(1000) % n;
 }

 
 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二维数组实现数字拼图效果

软考中级精品资料免费领

相关文章

猜你喜欢

Java二维数组实现数字拼图效果

Java二维数组怎么实现数字拼图效果

基于JavaScript实现年份数字拼图效果

js实现数字拼图

python 实现二维数组的索引、删除、拼接操作

Java 数组之二维数组扫雷实例

改写函数实现PHP二维/三维数组转字符串

Java如何实现二维数组与稀疏数组互转

Java轻松实现二维数组与稀疏数组互转

Java二维数组实例分析

js如何实现数字拼图

Java实现二维数组和稀疏数组之间的转换

Java技巧函数方法实现二维数组遍历

java二维数组行列互换怎么实现

Java二维数组与稀疏数组相互转换实现详解

js实现图片数组中图片切换效果

Java数据结构实现二维数组与稀疏数组转换详解

java实现二维数组转置的方法示例

Vue组件实现数字滚动抽奖效果

如何使用JAVA实现二维数组遍历求和

文章详情

Java二维数组实现数字拼图效果

软考中级精品资料免费领

相关文章

猜你喜欢

Java二维数组实现数字拼图效果

Java二维数组怎么实现数字拼图效果

基于JavaScript实现年份数字拼图效果

js实现数字拼图

python 实现二维数组的索引、删除、拼接操作

Java 数组 之 二维数组 扫雷实例

改写函数实现PHP二维/三维数组转字符串

Java如何实现二维数组与稀疏数组互转

Java轻松实现二维数组与稀疏数组互转

Java二维数组实例分析

js如何实现数字拼图

Java实现二维数组和稀疏数组之间的转换

Java技巧函数方法实现二维数组遍历

java二维数组行列互换怎么实现

Java二维数组与稀疏数组相互转换实现详解

js实现图片数组中图片切换效果

Java数据结构实现二维数组与稀疏数组转换详解

java实现二维数组转置的方法示例

Vue组件实现数字滚动抽奖效果

如何使用JAVA实现二维数组遍历求和

Java 数组之二维数组扫雷实例