我会尝试轻松清楚地解释我所得到的以及我需要的东西。
我有一个2维的数组，制作一个char元素板。我必须从底部拍摄，然后用'·'显示它。镜头从底部（a.length-1）到顶部（0），在墙壁上反弹，具体取决于镜头方向。
if (dirDisp == 3){
for(int x = 3, y = 0; x < 5 & y < 2; x++, y++) {
if(a[(a.length-1) - y][(a[x].length-1) / 2 + x] == EMPTY)
a[(a.length-1) - y][(a[x].length-1) / 2 + x] = '·';
}
for(int x = 0, y = 1; x < 9 & y < 11; x++, y++) {
if(a[(a.length-1) - y][(a[x].length-1) - x] == EMPTY)
a[(a.length-1) - y][(a[x].length-1) - x] = '·';
}
for(int x = 0, y = 9; x < 5 & y < 14; x++, y++) {
if(a[(a.length-1) - y][x] == EMPTY)
a[(a.length-1) - y][x] = '·';
}
}
我已经把镜头方向的代码放在上面= 3.EMPTY常量是''。问题是我也在阵列中使用其他字符，例如“a”，“b”等。
我想要的是，如果没有EMPTY则停止循环。它实际上做的是：
g g b g g y y r r
y o y a r y g o b
g o r a b r a a b
g y o a y a g o b
g a b b b o o b g
·
·
r r r r r r r r r
·
·
·
·
·
·
当镜头到达与EMPTY不同的第一个字符时，必须停止。我试图使用break并继续。还使用firstLoop：{}。我也尝试在循环的每个部分使用布尔值，但我没有让它工作。我需要一些帮助。
如果不清楚，请问。
PD：镜头，有3'代表'循环，第一个是从底部填充阵列到第一个墙，第二个是填充墙和墙之间的空间，第三个是对面墙到顶端。 PD2：'r'行可以让你看到实际发生的事情。使用布尔值后：
a b a b y a r y y
y a o y g r o g g
g o y o a y y a y
y o a a g o o b a
o o r a o r g y y
r r r r r r r r r
·
·
import java.util.Scanner;
import java.util.ArrayList;
import java.util.Stack;
public class BobbleTexto {
public static Scanner sc = new Scanner(System.in);
public static char RED = 'r';
public static char GREEN = 'g';
public static char BLUE = 'b';
public static char ORANGE = 'o';
public static char YELLOW = 'y';
public static char GRAY = 'a';
public static char PURPLE = 'p';
public static char EMPTY = ' ';
public static char IZQUIERDA = 'A';
public static char DERECHA = 'D';
public static char DISPARO = 'S';
public static char SALIR = 'Q';
public static char [][] generarTablero (){
char [][] a = new char [14][9];
for (int x = 0; x < a.length; x++){
for (int y = 0; y < a[x].length;y++){
a [x][y] = EMPTY;
}
}
for(int x = 0; x < 5; x++){
for(int y = 0; y < a[y].length; y++){
a[x][y] = generarBurbuja();
a[7][y] = RED;
}
}
return a;
}
public static char [][] limpiarTablero (char [][] a){
for (int x = 0; x < a.length; x++){
for (int y = 0; y < a[x].length;y++){
if (a [x][y] == '·')
a[x][y] = EMPTY;
}
}
return a;
}
public static void imprimirDisparo (char [][] a,int dirDisp,char Burbuja){
if (dirDisp == 1){
for(int x = 1, y = 0; x < 5 & y < 4; x++, y++){
if(a[(a.length-1) - y][(a[x].length-1) / 2 + x] == EMPTY){
a[(a.length-1) - y][(a[x].length-1) / 2 + x] = '·';
}
else{
break;
}
}
for(int x = 0, y = 3; x < 9 & y < 11; x++, y++){
if(a[(a.length-1) - y][(a[x].length-1) - x] == EMPTY){
a[(a.length-1) - y][(a[x].length-1) - x] = '·';
}
else{
}
}
for(int x = 0, y = 11; x < 4 & y < 14; x++, y++){
if(a[(a.length-1) - y][x] == EMPTY){
a[(a.length-1) - y][x] = '·';
}
else{
break;
}
}
}
if (dirDisp == 2){
for(int x = 2, y = 0; x < 5 & y < 3; x++, y++){
if(a[(a.length-1) - y][(a[x].length-1) / 2 + x] == EMPTY){
a[(a.length-1) - y][(a[x].length-1) / 2 + x] = '·';
}
else {
}
}
for(int x = 0, y = 2; x < 9 & y < 11; x++, y++){
if(a[(a.length-1) - y][(a[x].length-1) - x] == EMPTY){
a[(a.length-1) - y][(a[x].length-1) - x] = '·';
}
else {
}
}
for(int x = 0, y = 10; x < 4 & y < 14; x++, y++){
if(a[(a.length-1) - y][x] == EMPTY){
a[(a.length-1) - y][x] = '·';
}
else {
}
}
}
if (dirDisp == 3){
boolean foundObstacle = false;
for(int x = 3, y = 0; x < 5 & y < 2 && !foundObstacle; x++, y++){
if(a[(a.length-1) - y][(a[x].length-1) / 2 + x] == EMPTY)
a[(a.length-1) - y][(a[x].length-1) / 2 + x] = '·';
else {
foundObstacle = true;
break;
}
}
if(!foundObstacle) {
for(int x = 0, y = 1; x < 9 & y < 11 && !foundObstacle; x++, y++){
if(a[(a.length-1) - y][(a[x].length-1) - x] == EMPTY)
a[(a.length-1) - y][(a[x].length-1) - x] = '·';
else {
foundObstacle = true;
break;
}
}
}
if(!foundObstacle) {
for(int x = 0, y = 9; x < 5 & y < 14 && !foundObstacle; x++, y++){
if(a[(a.length-1) - y][x] == EMPTY)
a[(a.length-1) - y][x] = '·';
else break;
}
}
}
if (dirDisp == 4){
for(int x = 4, y = 0; x < 5 & y < 1; x++, y++){
if(a[(a.length-1) - y][(a[x].length-1) / 2 + x] == EMPTY)
a[(a.length-1) - y][(a[x].length-1) / 2 + x] = '·';
}
for(int x = 0, y = 0; x < 9 & y < 11; x++, y++){
if(a[(a.length-1) - y][(a[x].length-1) - x] == EMPTY)
a[(a.length-1) - y][(a[x].length-1) - x] = '·';
}
for(int x = 0, y = 8; x < 6 & y < 14; x++, y++){
if(a[(a.length-1) - y][x] == EMPTY)
a[(a.length-1) - y][x] = '·';
}
}
if (dirDisp == 0) {
for (int x = 0; x < a.length; x++)
if(a[x][(a[x].length - 1) / 2] == EMPTY)
a[x][(a[x].length - 1) / 2] = '·';
}
if (dirDisp == -1){
for(int x = 1, y = 0; x < 5 & y < 4; x++, y++){
if(a[(a.length-1) - y][(a[x].length-1) / 2 - x] == EMPTY)
a[(a.length-1) - y][(a[x].length-1) / 2 - x] = '·';
}
for(int x = 1, y = 3; x < 11 & y < 12; x++, y++){
if(a[(a.length-1) - y][x-1] == EMPTY)
a[(a.length-1) - y][x-1] = '·';
}
for(int x = 0, y = 11; x < 4 & y < 14; x++, y++){
if(a[(a.length-1) - y][(a[x].length-1) - x] == EMPTY)
a[(a.length-1) - y][(a[x].length-1) - x] = '·';
}
}
if (dirDisp == -2){
for(int x = 2, y = 0; x < 5 & y < 4; x++, y++){
if( a[(a.length-1) - y][(a[x].length-1) / 2 - x] == EMPTY)
a[(a.length-1) - y][(a[x].length-1) / 2 - x] = '·';
}
for(int x = 1, y = 2; x < 10 & y < 12; x++, y++){
if(a[(a.length-1) - y][x-1] == EMPTY)
a[(a.length-1) - y][x-1] = '·';
}
for(int x = 0, y = 10; x < 4 & y < 14; x++, y++){
if(a[(a.length-1) - y][(a[x].length-1) - x] == EMPTY)
a[(a.length-1) - y][(a[x].length-1) - x] = '·';
}
}
if (dirDisp == -3){
for(int x = 3, y = 0; x < 5 & y < 4; x++, y++){
if(a[(a.length-1) - y][(a[x].length-1) / 2 - x] == EMPTY)
a[(a.length-1) - y][(a[x].length-1) / 2 - x] = '·';
}
for(int x = 1, y = 1; x < 10 & y < 12; x++, y++){
if(a[(a.length-1) - y][x-1] == EMPTY)
a[(a.length-1) - y][x-1] = '·';
}
for(int x = 0, y = 9; x < 5 & y < 14; x++, y++){
if(a[(a.length-1) - y][(a[x].length-1) - x] == EMPTY)
a[(a.length-1) - y][(a[x].length-1) - x] = '·';
}
}
if (dirDisp == -4){
for(int x = 4, y = 0; x < 5 & y < 4; x++, y++){
if(a[(a.length-1) - y][(a[x].length-1) / 2 - x] == EMPTY)
a[(a.length-1) - y][(a[x].length-1) / 2 - x] = '·';
}
for(int x = 1, y = 0; x < 10 & y < 12; x++, y++){
if(a[(a.length-1) - y][x-1] == EMPTY)
a[(a.length-1) - y][x-1] = '·';
}
for(int x = 0, y = 8; x < 6 & y < 14; x++, y++){
if(a[(a.length-1) - y][(a[x].length-1) - x] == EMPTY)
a[(a.length-1) - y][(a[x].length-1) - x] = '·';
}
}
for (int x = 0; x < a.length; x++){
System.out.println();
for (int y = 0; y < a[x].length; y++){
System.out.print(" "+a [x][y]+" ");
}
}
System.out.println("\nDirección de disparo ["+dirDisp+"]");
System.out.println("Burbuja ["+Burbuja+"]");
}
public static int getDirDisp(){
int dirDisp = sc.nextInt();
while (dirDisp < -4 || dirDisp > 4){
System.out.println("Introduzca una dirección de disparo válida(-1,-2,-3,0,1,2,3)");
dirDisp = sc.nextInt();
}
return dirDisp;
}
public static char generarBurbuja(){
char burbuja = EMPTY;
int azar = (int) (Math.random() * 6);
switch (azar){
case 0 : burbuja = RED; break;
case 1 : burbuja = GREEN; break;
case 2 : burbuja = BLUE; break;
case 3 : burbuja = ORANGE; break;
case 4 : burbuja = YELLOW; break;
case 5 : burbuja = GRAY; break;
case 6 : burbuja = PURPLE; break;
}
return burbuja;
}
public static char obtenerAccionJugador (){
System.out.println("Acción?");
String aux = sc.next();
char accion = aux.charAt(0);
while (accion != IZQUIERDA && accion != DERECHA && accion != DISPARO && accion != SALIR){
System.out.println("Introduzca una acción válida:");
aux = sc.next();
accion = aux.charAt(0);
}
System.out.println("***************************");
return accion;
}
public static void obtenerTrayectoria (char [][] a){
System.out.println("Posiciones:");
for (int x = 0; x < a.length; x++){
for (int y = 0; y < a[x].length;y++){
if(a [x][y] == '·'){
Posicion pos = new Posicion(x,y);
ArrayList<Posicion> aListPos = new ArrayList<Posicion>();
aListPos.add(pos);
for(Posicion ii : aListPos){
System.out.println("(" + pos.getFila() + "," + pos.getColumna()+")");
}
}
}
}
}
public static char [][] realizarDisparo (char [][] a,char Burbuja){
int c [] = new int [a.length];
int w = 0;
for (int x = 0; x < a.length; x++){
for (int y = 0; y < a[x].length;y++){
if (a [x][y] == '·'){
w++;
c [w]= x;
}
if(a[c[1]][y] == '·'){
a[c[1]][y] = Burbuja;
}
}
}
return a;
}
public static int moverDerecha (int dirDisp, char [][] a){
if(dirDisp == -4)
dirDisp = -3;
else if (dirDisp == -3)
dirDisp = -2;
else if (dirDisp == -2)
dirDisp = -1;
else if (dirDisp == -1)
dirDisp = 0;
else if (dirDisp == 0)
dirDisp = 1;
else if (dirDisp == 1)
dirDisp = 2;
else if (dirDisp == 2)
dirDisp = 3;
else if(dirDisp == 3)
dirDisp = 4;
return dirDisp;
}
public static int moverIzquierda (int dirDisp, char [][] a){
if(dirDisp == 4)
dirDisp = 3;
else if (dirDisp == 3)
dirDisp = 2;
else if (dirDisp == 2)
dirDisp = 1;
else if (dirDisp == 1)
dirDisp = 0;
else if (dirDisp == 0)
dirDisp = -1;
else if (dirDisp == -1)
dirDisp = -2;
else if (dirDisp == -2)
dirDisp = -3;
else if(dirDisp == -3)
dirDisp = -4;
else{}
return dirDisp;
}
public static boolean existenBurbujas (char [][] a){
boolean result = true;
int contadorBurbujas = 0;
for (int x = 0; x < a.length; x++){
for (int y = 0; y < a[x].length;y++){
if(a [x][y] != EMPTY){
contadorBurbujas++;
}
}
}
if(contadorBurbujas > 0){
return true;
}
return result;
}
public static void borrarBurbujasAgrupadas(char [][] b, Posicion p) {
if(b[p.fila][p.columna] != EMPTY)
vecinos(b, p.fila, p.columna, b[p.fila][p.columna]);
}
private static void vecinos(char [][] b, int i_comienzo, int j_comienzo, char destino) {
Stack<Integer> ic = new Stack<Integer>();
Stack<Integer> jc = new Stack<Integer>();
ic.add(i_comienzo);
jc.add(j_comienzo);
int t = 0;
boolean [][] visitados = new boolean[b.length][b[0].length];
while( !ic.isEmpty() ) {
int i = ic.pop();
int j = jc.pop();
visitados[i][j] = true;
t++;
if(j-1 >= 0) {
if(b[i][j-1] == destino && !visitados[i][j-1]) {
ic.push(i);
jc.push(j-1);
}
}
if(j+1 < b[0].length) {
if(b[i][j+1] == destino && !visitados[i][j+1]) {
ic.push(i);
jc.push(j+1);
}
}
if(i-1 >=0) {
if(b[i-1][j] == destino && !visitados[i-1][j]) {
ic.push(i-1);
jc.push(j);
}
}
if(i+1 < b.length) {
if(b[i+1][j] == destino && !visitados[i+1][j]) {
ic.push(i+1);
jc.push(j);
}
}
if(j-1 >=0 && i-1 >=0) {
if(b[i-1][j-1] == destino && !visitados[i-1][j-1]) {
ic.push(i-1);
jc.push(j-1);
}
}
if(j+1 < b[0].length && i-1 >= 0 ) {
if(b[i-1][j+1] == destino && !visitados[i-1][j+1]) {
ic.push(i-1);
jc.push(j+1);
}
}
if(j-1>=0 && i+1<b.length) {
if(b[i+1][j-1] == destino && !visitados[i+1][j-1]) {
ic.push(i+1);
jc.push(j-1);
}
}
if(j+1<b[0].length && i+1<b.length) {
if(b[i+1][j+1] == destino && !visitados[i+1][j+1]) {
ic.push(i+1);
jc.push(j+1);
}
}
}
if(t >= 3)
for(int i=0; i<visitados.length; i++)
for(int j=0; j<visitados[i].length; j++)
if(visitados[i][j])
b[i][j] = EMPTY;
}
public static void jugar (){
Posicion p = new Posicion();
char [][] a = generarTablero();
System.out.println("Introduzca la dirección de disparo(-1,-2,-3,-4,0,1,2,3,4)");
int dirDisp = getDirDisp();
char Burbuja = generarBurbuja();
imprimirDisparo(a,dirDisp,Burbuja);
char accion = obtenerAccionJugador();
while(true){
if (accion == IZQUIERDA){
dirDisp = moverIzquierda(dirDisp,a);
limpiarTablero(a);
imprimirDisparo(a,dirDisp,Burbuja);
accion = obtenerAccionJugador();
}
else if(accion == DERECHA) {
dirDisp = moverDerecha(dirDisp,a);
limpiarTablero(a);
imprimirDisparo(a,dirDisp,Burbuja);
accion = obtenerAccionJugador();
}
else if(accion == DISPARO){
realizarDisparo(a,Burbuja);
borrarBurbujasAgrupadas(a,p);
Burbuja = generarBurbuja();
imprimirDisparo(a,dirDisp,Burbuja);
obtenerTrayectoria(a);
accion = obtenerAccionJugador();
}
else if (accion == SALIR){
System.out.println("GAME OVER");
}continue;
}
}
public static void main (String[] args){
jugar();
}
}
另一个具有对象的类
public class Posicion {
int fila;
int columna;
public Posicion(int fila,int columna) {
this.fila = fila;
this.columna = columna;
}
public int getFila(){
return this.fila;
}
public int getColumna(){
return this.columna;
}
public Posicion(){}
在你完成所有答案后，我已经完成了一种新的射击方法，比第一种方法更容易，使用while循环和更多常量名称使其易于理解。
Position类仍然是相同的。
我会把这些代码放在正向拍摄方向：
public static void getTrayectory (char [][] a,int shootDirection){
int x = 0, y = 0;
START = ((RIGHT_WALL)/2) + shootDirection;
a [BOTTOM][START] = SHOT;
if(shootDirection > 0){
while (!isOut(BOTTOM-x,START+y) && emptyCell(BOTTOM-x,START+y)){
b [BOTTOM - x][START + y] = SHOT;
x++; y++;
}
y = 0; x=x-1;
while (!isOut(BOTTOM-x,RIGHT_WALL-y) && emptyCell(BOTTOM-x,RIGHT_WALL-y)){
b [BOTTOM-x][RIGHT_WALL-y] = SHOT;
x++; y++;
}
y = 0; x=x-1;
while (!isOut(BOTTOM-x,LEFT_WALL+y) && emptyCell(BOTTOM-x,LEFT_WALL+y)){
b [BOTTOM-x][LEFT_WALL+y] = SHOT;
x++; y++;
}
y = 0;
while (!isOut(BOTTOM-x,RIGHT_WALL-y) && emptyCell(BOTTOM-x,RIGHT_WALL-y)){
b [BOTTOM-x][RIGHT_WALL-y] = SHOT;
x++; y++;
}
}
}
public static char [][] b = new char [25][9];
public static char EMPTY = '-';
public static char SHOT = 'x';
public static Scanner sc = new Scanner(System.in);
public static int shootDirection;
public static int BOTTOM = b.length - 1;
public static int RIGHT_WALL = b[0].length - 1;
public static int LEFT_WALL = 0;
public static int TOP = 0;
public static int CENTER = ((RIGHT_WALL)/2);
public static int START = ((RIGHT_WALL)/2) + shootDirection;
public static void fill (char [][] b){
for (int x = 0; x < b.length; x++){
for (int y = 0; y < b[x].length;y++){
b [x][y] = EMPTY;
b [10][y] = 'A';
}
}
}
public static void show (char [][] b){
for (int x = 0; x < b.length; x++){
System.out.println();
for (int y = 0; y < b[x].length; y++){
System.out.print(" "+b [x][y]+" ");
}
}
}
public static boolean isOut (int x,int y){
if(x < TOP)return true;
if(y > RIGHT_WALL)return true;
if(y < LEFT_WALL)return true;
return false;
}
static boolean emptyCell(int x, int y){
return b [x-1][y] == EMPTY;
}
问题是，它有效，但是，emptyCell方法有一个错误。它返回b [x-1] [y] == EMPTY，因为如果我使用return b [x] [y]它会得到一个OutOfBounds错误。由于x-1，循环在它应该停止之前停止一行，我不知道如何修改它以使其正常工作。
另一件事是，我想做一个更简单的方法，但即使用下面的小例子，我也无法弄清楚如何用我的常量来做。我希望你可以为我做，它一定很容易，但我不知道：S使用isOut方法和emptyCell方法，答案必须接近。谢谢你，抱歉这个长篇大论。
答案 0 :(得分：1)
就我所理解的代码而言，最接近您所拥有的解决方案是在else支票上加EMPTY，然后将其告诉break从第一个可能被中断的循环。然后，设置一个告诉它停止的变量，然后使其余的for循环对该变量有条件，这样它就不会从那里选择。
所以，它可能会像这样（但请记住，以下是一个不好的解决方法，此代码的整体结构应该在之后立即改进）：
if (dirDisp == 3){
boolean foundObstacle = false;
for(int x = 3, y = 0; x < 5 & y < 2; x++, y++){
if(a[(a.length-1) - y][(a[x].length-1) / 2 + x] == EMPTY)
a[(a.length-1) - y][(a[x].length-1) / 2 + x] = '·';
else {
foundObstacle = true;
break;
}
}
if(!foundObstacle) {
for(int x = 0, y = 1; x < 9 & y < 11; x++, y++){
if(a[(a.length-1) - y][(a[x].length-1) - x] == EMPTY)
a[(a.length-1) - y][(a[x].length-1) - x] = '·';
else {
foundObstacle = true;
break;
}
}
}
if(!foundObstacle) {
for(int x = 0, y = 9; x < 5 & y < 14; x++, y++){
if(a[(a.length-1) - y][x] == EMPTY)
a[(a.length-1) - y][x] = '·';
else break;
}
}
}
一旦解决了您的问题，请考虑对代码进行一些更改，因为如果您知道循环过早结束，则首先使用for循环被认为是不好的做法。在这些情况下，我们通常使用while循环。其次，硬编码这样的东西并不是一个好主意。你可以想出一个算法来完成任何给定方向的工作，一旦你掌握了这个。
希望这有帮助。
修改
if (dirDisp == 3){
boolean foundObstacle = false;
for(int x = 3, y = 0; x < 5 & y < 2 && !foundObstacle; x++, y++){
if(a[(a.length-1) - y][(a[x].length-1) / 2 + x] == EMPTY)
a[(a.length-1) - y][(a[x].length-1) / 2 + x] = '·';
else {
foundObstacle = true;
break;
}
}
if(!foundObstacle) {
// At its first iteration, this loop finds the '·' symbol placed by the previous one.
// So I've made it start from the second.
for(int x = 1, y = 2; x < 9 & y < 11 && !foundObstacle; x++, y++){
if(a[(a.length-1) - y][(a[x].length-1) - x] == EMPTY)
a[(a.length-1) - y][(a[x].length-1) - x] = '·';
else {
foundObstacle = true;
break;
}
}
}
if(!foundObstacle) {
for(int x = 0, y = 9; x < 5 & y < 14 && !foundObstacle; x++, y++){
if(a[(a.length-1) - y][x] == EMPTY)
a[(a.length-1) - y][x] = '·';
else break;
}
}
}
请记住，您调试此问题的原因是，正如其他人所建议的那样，代码非常模糊。无论多么有经验，这 是一个非常难以调试的东西。
这就是为什么每个人都建议我们应该编写干净的代码。记住，每个人都会犯错误。一旦你理解了如何用一种语言编写一个程序（你个人就这么做了），最重要的是你自己对代码的理解程度，这样你就可以更容易地看到你的错误。永远不要认为你只是因为自己写了一段代码而理解了一段代码。创建大量变量，赋予它们有意义的名称，分解程序，创建与程序必须处理的实体相对应的许多类型，给它们提供有意义的名称，找到重复的代码模式，将它们转换为函数/方法（有或没有参数化部分）并给它们有意义的名称。
即使您在此时找不到错误，其他人也至少可以帮助您。 ;）
答案 1 :(得分：1)
如果您的休息条件很复杂，我建议使用while循环。使用漂亮的方法名称也会使您的代码更具可读性。
while (!outOfBounds(x,y) && emptyCell(x,y) {
a[x][y] = '.';
moveCursor(direction);
}
...
boolean emptyCell(int x, int y){
return a[x][y] == EMPTY;
}
boolean outOfBounds(int x, int y){
if (x<0) return true;
if (y<0) return true;
if (x>LIMIT_X) return true;
if (y>LIMIT_Y) return true;
return false;
}
void moveCursor(direction){
if (direction==DOWN_RIGHT){
x++;
y++;
if (x > X_LIMIT){
x-=2;
direction = DOWN_LEFT;
}
...
}
答案 2 :(得分：0)
我刚刚写了这个小方法，它正在做你想要的。但它填充了一个rnd char数组。看到我的休息状况
private void shot() {
char charArray[][] = new char[100][20];
Random r = new Random();
for(int i = 0;i<charArray.length;++i) {
for(int j = 0;j<charArray[0].length;++j) {
if(r.nextInt(5) == 0) {
charArray[i][j] = (char) (r.nextInt(26)+65);
}
}
}
boolean shotRight = false;
for(int i = charArray.length-1,j = charArray[0].length-1;i>0;--i) {
System.out.println(i + " " + j);
// break condition
if(charArray[i][j] != '\u0000') break;
if(shotRight) {
charArray[i][j] = '.';
++j;
}
else {
charArray[i][j] = '.';
--j;
}
if(j <= 0) {
shotRight = true;
}
if(j >= charArray[0].length-1) {
shotRight = false;
}
}
for(int i = 0;i<charArray.length;++i) {
for(int j = 0;j<charArray[0].length;++j) {
System.out.print(((charArray[i][j] == '\u0000') ? " ":charArray[i][j] + " ") + " ");
}
System.out.println();
}
}
它会中断，因为char ='\ u0000'
的默认值