Лучший способ сделать границу для 2D-массива?
Добрый день / ночь. В настоящее время я работаю с 2D-массивами, и, хотя я считаю их простыми в работе, я часто сталкиваюсь с проблемами при создании для них границ и шагов по их приближению. Например, я переделываю игру Battleship, созданную на Python. Версия python не имеет рамки, но для версии java я хочу решить эту проблему.
Я попытался создать границу в методе инициализации платы, но это привело к проблемам с форматированием, когда я вызвал доску в основном методе. Теперь я обрабатываю границу в основном с помощью вложенного цикла for, и, хотя результаты улучшились, граница все еще не завершена. Я пытаюсь создать эту границу, которую нашел в Интернете:
+---+| |+---+ Но я не добился успеха. Вот мой код:
public static String[][] Battlefield(){
int row;
int col;
int cap_start = 65;
//Makes board
String[][] BattleBoard = new String[11][11];
for(row = 0; row < BattleBoard.length; row++){
for(col = 0; col < BattleBoard[row].length; col++){
if(row == 0){
BattleBoard[row][col] = " " + Character.toString((char)cap_start) + " ";//System.out.print(" " + Character.toString((char)cap_start) + " ");
cap_start++;
} else if(col==0){
BattleBoard[row][col] = (Integer.toString(row-1)) + " ";//System.out.print(Integer.toString(row-1) + " "); //Gives us 0-9
} else{
BattleBoard[row][col] = " ";//System.out.print(" ");
}
}
}
return BattleBoard;
}
public static void main(String[] args){
Scanner userInput = new Scanner(System.in);
Scanner colInput = new Scanner(System.in);
Scanner rowInput = new Scanner(System.in);
String player_col = "";
String player_row = "";
String[][] gameBoard = Battlefield();
for(int row = 0; row < gameBoard.length; row++){
for (int col = 0; col < gameBoard[row].length; col++){
System.out.print(gameBoard[row][col] + " |");
if (row <= gameBoard.length-1)
System.out.print("+---+");
}
System.out.println();
}
}
2 ответа
Вот кое-что, что я собрал.
A B C D E F G H I J K
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
1 + + + + + + + + + + + +
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
2 + + + + + + + + + + + +
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
3 + + + + + + + + + + + +
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
4 + + + + + S + + + + + + +
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
5 + + + + + S + + + + + + +
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
6 + + + + + S + + + + + + +
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
7 + + + + + S + + + + + + +
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
8 + + + + + S + + + + + + +
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
9 + + + + + + + + + + + +
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
10 + + + + + + + + + + + +
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
11 + + + + + + + + + + + +
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
Я создал двухмерный
Я использовал несколько
Я поместил один корабль в сетку, чтобы вы могли видеть, как он выглядит.
Я сломал
В Java имена классов начинаются с заглавной буквы. Имена полей и методов начинаются с строчной буквы. Имена классов обычно представляют собой комбинации существительного и глагола. Имена методов обычно представляют собой комбинации глаголов и существительных. Как правило, рекомендуется как можно быстрее выбраться из статичного мира.
Вот полный исполняемый код.
public class BattleshipDisplay {
public static void main(String[] args) {
BattleshipDisplay bd = new BattleshipDisplay();
char[][] grid = bd.createGrid();
System.out.println(bd.displayGrid(grid));
}
public char[][] createGrid() {
char[][] grid = new char[11][11];
for (int i = 0; i < grid.length; i++) {
for (int j = 0; j < grid[i].length; j++) {
grid[i][j] = ' ';
}
}
grid[3][4] = 'S';
grid[4][4] = 'S';
grid[5][4] = 'S';
grid[6][4] = 'S';
grid[7][4] = 'S';
return grid;
}
public String displayGrid(char[][] grid) {
StringBuilder builder = new StringBuilder();
String section = "+-----";
builder.append(printHeaderLine(grid));
builder.append(printDashedLine(grid, section));
builder.append(printGrid(grid, section));
return builder.toString();
}
private StringBuilder printHeaderLine(char[][] grid) {
StringBuilder builder = new StringBuilder();
builder.append(" ");
for (int i = 0; i < grid.length; i++) {
builder.append((char) ((int) 'A' + i));
builder.append(" ");
}
builder.append(System.lineSeparator());
return builder;
}
private StringBuilder printGrid(char[][] grid, String section) {
StringBuilder builder = new StringBuilder();
for (int i = 0; i < grid.length; i++) {
builder.append(String.format("%3d", (i + 1)));
builder.append(" ");
for (int j = 0; j < grid[i].length; j++) {
builder.append("+ ");
builder.append(grid[i][j]);
builder.append(" ");
}
builder.append("+");
builder.append(System.lineSeparator());
builder.append(printDashedLine(grid, section));
}
return builder;
}
private StringBuilder printDashedLine(char[][] grid, String section) {
StringBuilder builder = new StringBuilder();
builder.append(" ");
for (int i = 0; i < grid.length; i++) {
builder.append(section);
}
builder.append("+");
builder.append(System.lineSeparator());
return builder;
}
}
Вы можете представить каждую ячейку поля в виде почти квадрата , состоящего из двух строк: верхней границы и элемента с правой границей, используя символы рисования прямоугольника :
───┼
X │
Скриншот:
Вывод состоит из трех частей: верхнего ряда букв, затем поля с левым столбцом цифр и нижнего граничного ряда. В результате все поле с кораблями может выглядеть так:
│ A │ B │ C │ D │ E │ F │ G │ H │ I │ J │
───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┤
1 │ │ │ X │ │ │ │ X │ X │ X │ │
───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┤
2 │ X │ │ │ │ │ │ │ │ │ │
───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┤
3 │ │ │ X │ X │ X │ X │ │ │ │ │
───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┤
4 │ │ │ │ │ │ │ │ │ │ X │
───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┤
5 │ │ │ │ │ │ │ │ │ │ X │
───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┤
6 │ │ │ X │ │ │ │ X │ │ │ X │
───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┤
7 │ X │ │ │ │ │ │ X │ │ │ │
───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┤
8 │ X │ │ │ │ │ │ │ │ │ │
───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┤
9 │ │ │ │ │ X │ │ │ │ │ X │
───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┤
10 │ │ │ │ │ X │ │ │ │ │ │
───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┘
Скриншот:
public static String[] outputField(String[][] field, int n) {
return Stream.of(
// upper row of letters
Stream.of(IntStream.range(-1, n)
// first an empty square
.mapToObj(i -> i < 0 ? " │" :
// then squares with letters
" " + Character.toString('A' + i) + " │")
.collect(Collectors.joining())),
// field with a left column of numbers
IntStream.range(0, n)
// row of the field, line of squares
.mapToObj(i -> IntStream.range(0, n)
// first a square with a number, then squares of the field
.mapToObj(j -> new String[]{
// upper row of square with an upper border
(j == 0 ? "───┼" : "")
+ "───" + (j < n - 1 ? "┼" : "┤"),
// lower row of square with element and right border
(j == 0 ? String.format("%2d", (i + 1)) + " │" : "")
+ " " + field[i][j] + " │"})
// reduce Stream<String[]> to a single array String[]
.reduce((arr1, arr2) -> IntStream.range(0, 2)
.mapToObj(j -> arr1[j] + arr2[j])
.toArray(String[]::new))
.orElse(new String[]{}))
.flatMap(Arrays::stream),
// lower border row
Stream.of(IntStream.range(-1, n)
.mapToObj(i -> i < n - 1 ? "───┴" : "───┘")
.collect(Collectors.joining())))
.flatMap(Function.identity())
.toArray(String[]::new);
}
public static void main(String[] args) {
int n = 10;
String[][] field = IntStream.range(0, n)
.mapToObj(i -> new String[n])
.peek(row -> Arrays.fill(row, " "))
.toArray(String[][]::new);
// four-pipe ship
field[2][2] = field[2][3] = field[2][4] = field[2][5] = "X";
// three-pipe ships
field[0][6] = field[0][7] = field[0][8] = "X";
field[3][9] = field[4][9] = field[5][9] = "X";
// two-pipe ships
field[5][6] = field[6][6] = "X";
field[8][4] = field[9][4] = "X";
field[6][0] = field[7][0] = "X";
// one-pipe ships
field[0][2] = "X";
field[1][0] = "X";
field[5][2] = "X";
field[8][9] = "X";
// output
Arrays.stream(outputField(field, n)).forEach(System.out::println);
}
См. Также:
• Форматирование 2-мерного массива чисел
• Как нарисовать лестницу на Java?