Question

在提出我的问题之前，我想先澄清一些事情。首先，我是Java和编程的新手。第二，这是我的第二篇文章，如果我做错了什么，请放轻松。最后，我想解释为什么我所做的是错误的，而不仅仅是在对这篇文章的任何回复中的粘贴解决方案。为了更好地理解这个问题，我将编写赋值信息，然后是给出的Driver类，然后是Driver类访问的类代码。

我的问题：

如何才能在我的建筑物的左下方找到＆＃39;在我的2D阵列上是[0] [0]？ Here's一个for循环的例子，用于将2D数组的左下角改为[0] [0]，但我尝试将其实现到我的searchRoom方法中（其中玩家角色设置为myHidingPlaces索引）我无法将myHidingPlaces [0] [0]作为2D数组的左下角。我相信我需要以某种方式使用for循环来编辑toString方法，但我无法弄清楚我应该如何去做。

以下是作业：

你要设计一个类“LostPuppy.java”，它代表一个在多层建筑中丢失的小狗每层楼的房间数量相同。在实例化（或创建）此类对象的过程中，每层楼的每个房间都会被初始化为空（你实际上会使用空格''字符目的）并且将选择一个随机的房间，在那里小狗失踪。为此，字符“P”将被放置在这个随机位置。有关构造函数的更多详细信息如下所示。

这个类的一个对象被用作两个玩家的游戏轮流搜索小狗，一个房间在一个时间，直到发现不幸的小犬。将执行此对象的实例化和搜索通过提供给您的“驱动程序”程序，您只需专注于开发类（驱动程序在文件“PuppyPlay.java”中）

字段（当然，所有字段都是私有的）：

名为myHidingPlaces的字符（char）数组。这表示行是地板的建筑物每个楼层的柱子都是房间（这栋楼有一个不寻常的编号系统;楼层和楼层房间都从零开始。
两个整数将占据失去小狗的地板和房间，名为myFloorLocation和 myRoomLocation。
一个名为myWinner的char，当玩家找到小狗时，该角色将被分配给玩家的角色（司机程序使用数字'1'和'2'来更清楚地区分玩家和小狗。）
名为myFound的布尔值，在找到小狗时设置为true。

构造

接收两个整数参数作为用户对建筑物楼层数和房间数的输入小狗失踪了。
构造函数将2D数组“myHidingPlaces”实例化为带有第一个参数的字符数组对于行（theFloors）和第二个参数作为列（theRooms）。
初始化myHidingPlaces的单元格，每个单元格都包含一个空格''（用单引号完成）
使用第一个参数
使用第二个参数
将myHidingPlaces [myFloorLocation] [myRoomLocation]设置为char'P'
将myWinner设置为单个空格
将myFound设为false

方法：

roomSearched已经收到要搜索的楼层和房间，如果房间有，则返回true 已被搜查，否则为假。
puppyLocation接收要搜索的楼层和房间，如果楼层和房间都是，则返回true 小狗丢失的地方，否则就是假的。此方法不应更改任何字段。
indicesOK接收要搜索的楼层和房间，如果楼层和房间值是，则返回true 在数组索引范围内，否则为false（用于检查这些索引不会导致错误）应用于数组时。）
numberOfFloors返回建筑物中的楼层数（第一层从零开始）。
numberOfRooms返回建筑物每层楼的房间数量（第一个房间开始于零和所有楼层都有相同数量的房间。）
searchRoom接收要搜索的楼层和房间以及当前播放器（作为字符类型）如果找到小狗则返回true，否则返回false。如果没有找到小狗searchRoom也将收到的楼层和房间位置的myHidingPlaces数组设置为收到的播放器值（'1' 或者'2'）OR，当找到时，将myWinner字段设置为当前播放器并将myFound设置为true。
toString显示当前的hidePlaces数组及其内容除了小狗的位置在他/她被发现之前，它将保持隐藏状态.string将被调用（由驱动程序）和两者找到小狗的玩家和'P'将显示在同一个单元格中......
现在，也许是toString输出的尴尬部分。通常，在显示2D数组时， [0] [0]单元格与矩阵一样显示在左上角。但是，因为小狗决定迷失在建筑物而不是矩阵中，一楼的视觉感觉会更加明显（第0行）显示在它上面的底部，第二层......最后是顶层，好......顶部！至保存单词，仔细查看下一页提供的示例运行。你的输出应该看起来像与样本运行中下一页的内容相同。

以下是驱动程序：

import java.util.Random;
import java.util.Scanner;

/**
 * This program is used as a driver program to play the game from the
 * class LostPuppy.  Not to be used for grading!
 *
 * A puppy is lost in a multi-floor building represented in the class 
 * LostPuppy.class.  Two players will take turns searching the building
 * by selecting a floor and a room where the puppy might be.
 *
 * @author David Schuessler
 * @version Spring 2015
 */

public class PuppyPlay
{
  /**
   * Driver program to play LostPuppy.
   *
   * @param theArgs may contain file names in an array of type String
   */
  public static void main(String[] theArgs)
  {
    Scanner s = new Scanner(System.in);
    LostPuppy game; 
    int totalFloors;
    int totalRooms;
    int floor;
    int room;
    char[] players = {'1', '2'};
    int playerIndex;
    boolean found = false;
    Random rand = new Random();

    do 
    {
      System.out.print("To find the puppy, we need to know:\n"
                       + "\tHow many floors are in the building\n"
                       + "\tHow many rooms are on the floors\n\n"
                       + "             Please enter the number of floors: ");
      totalFloors = s.nextInt();
      System.out.print("Please enter the number of rooms on the floors: ");
      totalRooms = s.nextInt();
      s.nextLine();    // Consume previous newline character    

      // Start the game: Create a LostPuppy object:
      game = new LostPuppy(totalFloors, totalRooms);

      // Pick starting player
      playerIndex = rand.nextInt(2);

      System.out.println("\nFloor and room numbers start at zero '0'");

      do 
      {

        do 
        {
          System.out.println("\nPlayer " + players[playerIndex]
                             + ", enter floor and room to search separated by a space: ");
          floor = s.nextInt();
          room = s.nextInt();

          //for testing, use random generation of floor and room
          //floor = rand.nextInt(totalFloors);
          //room = rand.nextInt(totalRooms);
        } while (!game.indicesOK(floor, room) 
                 || game.roomSearchedAlready(floor, room));


        found = game.searchRoom(floor, room, players[playerIndex]);
        playerIndex = (playerIndex + 1) % 2;
        System.out.println("\n[" + floor + "], [" + room + "]");
        System.out.println(game.toString());
        s.nextLine();
      } while (!found);

      playerIndex = (playerIndex + 1) % 2;
      System.out.println("Great job player " + players[playerIndex] +"!");
      System.out.println("Would you like to find another puppy [Y/N]? ");
    } 
    while (s.nextLine().equalsIgnoreCase("Y"));
  }
}

最后，这是我的测试代码：

import java.util.Random;
import java.util.Scanner;

public class LostPuppy
{
   int value;
   char[][] myHidingPlaces;
   int myFloorLocation;
   int myRoomLocation;
   char myWinner;
   boolean myFound;
   Random random = new Random();

   public LostPuppy(int theFloors, int theRooms)
   {
      myHidingPlaces = new char[theFloors][theRooms];

      for (int i = theFloors - 1; i >= 0; i--)
      {
         for (int j = 0; j <= theRooms - 1; j++)
         {
            myHidingPlaces[i][j] = ' ';
         }
      }

      myFloorLocation = random.nextInt(theFloors);
      myRoomLocation = random.nextInt(theRooms);
      myHidingPlaces[myFloorLocation][myRoomLocation] = 'P';
      myWinner = ' ';
      myFound = false;  
   }
   public boolean roomSearchedAlready(int floor, int room)
   {
      return (myHidingPlaces[floor][room] == '1' || 
              myHidingPlaces[floor][room] == '2');
   }

   public boolean puppyLocation(int floor, int room)
   {
      return (myHidingPlaces[floor][room] == 'P');
   }

   public boolean indicesOK(int floor, int room)
   {
      return (floor <= myHidingPlaces.length && room <= myHidingPlaces[0].length);
   }

   public int numberOfFloors()
   {
      return myHidingPlaces.length - 1;
   }
   public int numberOfRooms()
   {
      return myHidingPlaces[0].length - 1;
   }

   public boolean searchRoom(int floor, int room, char player)
   {
      if (puppyLocation(floor, room))
      {
         myFound = true;
         myWinner = player;
         return true;
      }
      else
      {
         myHidingPlaces[floor][room] = player;
         return false;
      }
   }

   public String toString()
   {
      int rooms = myHidingPlaces[0].length;
      int floors = myHidingPlaces.length;

      System.out.print(" ");
      for (int x = 0; x < rooms; x++)
      {
         System.out.print("___");
      }

      for (int y = 0; y < rooms - 1; y++)
      {
         System.out.print("_");
      }
      System.out.print("\n");

      for (int r = 0; r < floors; r++)
      {
         System.out.print("| ");
         for (int c = 0; c < rooms; c++)
         {

            if (myHidingPlaces[r][c] == 'P' && myFound)
            {
               System.out.print("" + myWinner + "" + myHidingPlaces[r][c] + "| ");
            }
            else if (myHidingPlaces[r][c] == 'P' && !myFound)
            {
               System.out.print("  | ");
            }
            else
            {
               System.out.print(myHidingPlaces[r][c] + " | ");
            }

            //System.out.print(myHidingPlaces[r][c] + " | ");

         }
         System.out.print("\n");
         for (int i = 0; i < rooms; i++)
         {
            System.out.print("|___");
         }
         System.out.print("|\n");
      }
      return "";

   }

}

Answer 1

你无法用Java制作一个反转阵列，但你不需要它。您需要考虑建筑物并使用它进行操作，就像使用矩阵一样。但是你需要颠倒打印它。此外，您提供的链接不会更改数组中的位置，它只是从最后一个索引到第一个索引的数组遍历。

所以你需要颠倒打印数组，这很容易。您需要在toString方法中更改一行，然后更改

for (int r = 0; r < floors; r++)

到

for (int r = floors - 1; r >= 0; r--)

你会得到正确的结果！

同样在这种情况下，您不需要从最后到第一个填充数组（至少因为您使用相同的值填充它），就像您一样

for (int i = theFloors - 1; i >= 0; i--) {
    for (int j = 0; j <= theRooms - 1; j++) {
        ...
    }
}

如果你这样做会更好（最好阅读你的代码）

for (int i = 0; i < theFloors; i++) {
    for (int j = 0; j < theRooms; j++) {
        ...
    }
}

正如@Dante所说，您还需要更正indicesOK方法，因为数组的最后一个索引是length - 1，所以当您访问myHidingPlaces.length或myHidingPlaces[i].length元素时，异常{ {1}}将被抛出。

ArrayIndexOutOfBoundsException

Java - 复杂程序中的二维数组索引操作

1 个答案: