java.lang.ArrayIndexOutOfBoundsException: 4 at javaapplication19.Board.getRow(Ja
ID: 3675677 • Letter: J
Question
java.lang.ArrayIndexOutOfBoundsException: 4
at javaapplication19.Board.getRow(JavaApplication19.java:115)
at javaapplication19.Board.canMove(JavaApplication19.java:278)
at javaapplication19.Board.move(JavaApplication19.java:256)
at javaapplication19.Game.play(JavaApplication19.java:422)
at javaapplication19.JavaApplication19.main(JavaApplication19.java:26)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
at java.lang.reflect.Method.invoke(Method.java:597)
at edu.rice.cs.drjava.model.compiler.JavacCompiler.runCommand(JavacCompiler.java:272)
>
This is my code, how do I fix this error?
/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package javaapplication19;
/**
*
* @author mukesh
*/
import java.util.Random;
import java.util.Scanner;
public class JavaApplication19 {
public static void main(String[] args) {
Board b = new Board(5);
int x[][] = new int[5][5];
b.setBoard( x);
b.getRow(Direction.UP, 2);
Game g = new Game();
g.play();
// TODO code application logic here
}
}
enum Direction {UP,DOWN,LEFT,RIGHT};
/**
* @author ajundt
* Board maintains all values stored in the 2048 board.
* You can use this class to get access to individual rows or
* the whole shebang.
*/
class Board {
private static void swapNumbers(int[] row, int i, int i0) {
throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
}
private int[][] board = null;
private int boardSize =0;
private Random rand;
/**
* Creates a default board of size [4][4]
*/
public Board() {
this(4);
}
/**
* Creates the board of size [size][size]
*
* @param size - the size of the board
*/
public Board(int size) {
boardSize = size;
board = new int[boardSize][boardSize];
rand = new Random();
for (int i = 0; i < boardSize; i++) {
for (int j = 0; j < boardSize; j++) {
board[i][j] = 0;
}
}
}
/**
* initialize board for testing purposes
*
* @param board 2D array representing the 2048 board
*/
public void setBoard(int[][] board) {
this.board = board;
}
/**
* return an individual row translated based on direction, e.g.
* [1, 2, 3
* 4, 5, 6
* 7, 8, 9]
* getRow(LEFT, 0) => [1,2,3]
* getRow(UP, 0) => [1,4,7]
* getRow(RIGHT,0) => [3,2,1]
* getRow(DOWN, 1) => [8,5,2]
*
* @param dir - the direction the row will be translated to
* @param rowNumber - the row number
*/
public int[] getRow(Direction dir, int rowNumber) {
int[] row = new int[board.length];
int i = 0;
switch (dir) {
case LEFT:
for (i = 0; i<boardSize; i++) {
row[i] = board[rowNumber][i];
}
break;
case RIGHT:
for (i = boardSize; i >0; i--) {
row[i] = board[rowNumber][boardSize];
}
break;
case UP:
for (i = 0; i <boardSize; i++) {
row[i] = board[rowNumber][i];
}
break;
case DOWN:
for (i = boardSize; i>0; i--) {
row[i] = board[rowNumber][i];
}
break;
default:
System.out.println("Invalid direction provided");
break;
}
return row;
}
/**
* put an individual row translated based on direction into the board, e.g.
* [1, 2, 3
* 4, 5, 6 q
* 7, 8, 9]
* putRow(LEFT, [3,4,5], 0) => board = [3,4,5
* 4,5,6
* 7,8,9]
* putRow(Right, [3,4,5], 0)=> board = [5,4,3
* 4,5,6
* 7,8,9]
* putRow(UP, [3,4,5], 1) => board = [1,3,3
* 4,4,6
* 7,5,9]
* putRow(DOWN, [3,4,5], 1) => board = [1,5,3
* 4,4,6
* 7,3,9]
* getRow(UP, 0) => [1,4,7]
* getRow(RIGHT,0) => [3,2,1]
* getRow(DOWN, 1) => [8,5,2]
*
* @param dir - the direction the row will be translated to
* @param row - the row to be inserted into the board (untranslated)
* @param rowNumber - the row number
* @return
*/
public void putRow(Direction dir, int[] row, int rowNumber) {
int i;
switch (dir) {
case LEFT:
for (i = 0; i<boardSize; i++) {
board[rowNumber][i] = row[i];
}
break;
case RIGHT:
for (i = 0; i<boardSize; i++) {
board[rowNumber][boardSize - 1 - i] = row[i];
}
break;
case UP:
for (i = 0; i < boardSize; i++) {
board[i][rowNumber] = row[i];
}
break;
case DOWN:
for (i = 0; i <boardSize; i++) {
board[boardSize - 1 - i][rowNumber] = row[i];
}
break;
default:
System.out.println("Invalid direction provided");
break;
}
return;
}
public int[][] getBoard() {
return board;
}
/**
* inserts a 2 into a random open space on the board
*
* @return false if no open slots, true otherwise
*/
public boolean insertNumber() {
int numSlots = getNumSlots();
int nextSlot = 0;
int slots = 0;
if (numSlots != 0) {
nextSlot = rand.nextInt(numSlots);
for (int i = 0; i <boardSize; i++) {
for (int j = 0; j <boardSize; j++) {
if (board[i][j] == 0 && nextSlot == slots) {
board[i][j] = 2;
return true;
} else if (board[i][j] == 0) {
slots++;
}
}
}
}
return false; //unable to fill a slot
}
/**
*
* @return Number of slots with no number
*/
private int getNumSlots() {
int slots = 0;
for (int i = 0; i <boardSize; i++) {
for (int j = 0; j <boardSize; j++) {
if (board[i][j] == 0)
slots++;
}
}
return slots;
}
/**
* Move the board in the given direction
*
* @param dir Direction to move
*/
public boolean move(Direction dir) {
int[] row;
boolean canMove = canMove(dir);
if (canMove) {
for (int i = 0; i <boardSize; i++) {
row = getRow(dir, i);
transform(row);
putRow(dir, row, i);
}
}
return canMove;
}
/**
* Can anything on the board move in the specified direction?
* @param dir Direction to check
* @return
*/
public boolean canMove(Direction dir) {
boolean rowCanMove = false;
int[] row;
for (int i = 0; i <boardSize; i++) {
row = getRow(dir, i);
rowCanMove = checkRow(row);
if (rowCanMove)
return true;
}
return false;
}
/**
* Test that this row can be moved to the left
* @param row Row/column already translated by getRow
*/
public static boolean checkRow(int[] row) {
boolean nonEmpty = false;
//if row is empty, return false... we cant move this row
for (int i = 0; i <=row.length; i++) {
if (row[i] != 0) nonEmpty = true;
}
if (!nonEmpty)
return false;
//Row isn't empty
for (int i = 1; i < row.length; i++) {
if (row[i - 1] == 0) {
return true; //previous slot is empty, we can go left
} else if (row[i - 1] == row[i] && row[i] != 0) {
return true; //2 numbers are the same, can go left and merge
}
}
return false;
}
/**
* Operate on a single row, always shifting to left if possible
* this is where the magic actually happens and is the hardest
* part of the problem
*
* @param row One row or column, already translated by getRow
*/
public static void transform(int[] row) {
boolean nonEmpty = false;
int index = 1;
//if row is empty, return, nothing to do
for (int i = 0; i <=row.length; i++) {
if (row[i] != 0)
nonEmpty = true;
}
if (!nonEmpty)
return;
//There is at least one entry in the board
for (int i = 0; i < row.length ; i++) {
if (row[index - 1] == 0) {
shift(row, index); //previous spot is blank, move everything left
} else if (row[index] == 0 && ((index + 1) < row.length)) {
shift(row, index + 1); //current is blank, shift toward current
} else if (row[index - 1] == row[index]) {
row[index - 1] *= 2; //Merge 2 numbers
shift(row, index);
index++;
} else {
index++;
}
}
}
/**
* Shift everything in a row left, starting at a given index
* The element at index-1 will be destroyed
*
* e.g.
* 2 0 0 2, index=1
* -->
* 0 0 2 0
*
*
*
* @param row row to shift
* @param index Shift all elements starting from here onwards to the
* left by 1 spot
* Must have index > 0
*/
public static void shift(int[] row, int index) {
int i=index;
for ( i = index;i<row.length; i++)
{
// swapNumbers1(row,index--,i);
row[i--] = row[i];
}
}
public static void swapNumbers1(int [] row, int pos1, int pos2){
int temp = row[pos2];
row[pos2] = row[pos1];
row[pos1] = temp;
}
}
class Game {
private Board board;
/**
* Creates a new board
*/
public Game() {
this(new Board());
}
/**
*
* @param b already initialized board to use
*/
public Game(Board b) {
this.board = b;
}
/**
* Start the game
* Take input and dish out the moves
*/
public void play() {
char input;
boolean move_result = false;
printControls();
board.insertNumber();
board.insertNumber();
printBoard();
while ((input = takeInput()) != 'q') {
move_result = false;
if (input == 'w') { //UP
move_result = board.move(Direction.UP);
} else if (input == 's') { //DOWN
move_result = board.move(Direction.DOWN);
} else if (input == 'a') { // LEFT
move_result = board.move(Direction.LEFT);
} else if (input == 'd') { // RIGHT
move_result = board.move(Direction.RIGHT);
} else { //invalid char
printControls();
}
if (move_result) {
board.insertNumber();
} else {
System.out.println("nothing's changed");
}
printBoard();
}
}
private char takeInput() {
Scanner scnr = new Scanner(System.in);
System.out.print(">");
return scnr.next().charAt(0);
}
/**
* print the current state of the board
*/
private void printBoard() {
int[][] a = board.getBoard();
String current;
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < a.length; j++) {
if (a[i][j] == 0)
current = " -";
else
current = String.format("%5d", a[i][j]);
System.out.print(current);
}
System.out.println();
}
}
/**
* Print out the control menu for the game
* What keys map to what
*/
private void printControls() {
System.out.println("Controls:");
System.out.println(" w - Move UP");
System.out.println(" s - Move Down:");
System.out.println(" a - Move Left");
System.out.println(" d - Move Right");
System.out.println(" q - Quit");
}
}
Explanation / Answer
I have executed in the shell prompt,and after execution the result is,
An error free result is here :
sh-4.3$ javac JavaApplication19.java
sh-4.3$ java JavaApplication19
Controls:
w - Move UP
s - Move Down:
a - Move Left
d - Move Right
q - Quit
2 - - -
- - - -
2 - - -
- - - -
>
Controls:
w - Move UP
s - Move Down:
a - Move Left
d - Move Right
q - Quit
nothing's changed
2 - - -
- - - -
2 - - -
- - - -
>
sh-4.3$ javac JavaApplication19.java
sh-4.3$ java JavaApplication19
Controls:
w - Move UP
s - Move Down:
a - Move Left
d - Move Right
q - Quit
- - - -
- - - 2
- - - -
2 - - -
>
Controls:
w - Move UP
s - Move Down:
a - Move Left
d - Move Right
q - Quit
nothing's changed
- - - -
- - - 2
- - - -
2 - - -
>
Related Questions
Navigate
Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.