Java：如何打印没有方括号和逗号的数组

Question

这是我用于我的程序的代码。我很难以我想要的方式显示它，即没有括号和逗号。 我希望它像金字塔一样：

    X                                              #      
   XXX                                            ###     
  XXXXX                                          #####    
 XXXXXXX                                        #######   
XXXXXXXXX                                      #########  

我的代码给出了我不想要的方括号和逗号。我明白了：

[    X    ,    XXX   ,   XXXXX  ,  XXXXXXX , XXXXXXXXX]  
[]  
[]  
[]  
[]  
[    #    ,    ###   ,   #####  ,  ####### , #########]  

我的代码：

Stack stackA = new Stack();   
stackA.push("    X    ");
stackA.push("   XXX   ");
stackA.push("  XXXXX  ");
stackA.push(" XXXXXXX ");
stackA.push("XXXXXXXXX");

Stack stackB = new Stack();
Stack stackC = new Stack();
Stack stackD = new Stack();
Stack stackE = new Stack();

Stack stackF = new Stack();
stackF.push("    #    ");
stackF.push("   ###   ");
stackF.push("  #####  ");
stackF.push(" ####### ");
stackF.push("#########");

Stack[] combine = new Stack[6];
combine[0] = stackA;
combine[1] = stackB;
combine[2] = stackC;
combine[3] = stackD;
combine[4] = stackE;
combine[5] = stackF;

for (int i = 0; i < combine.length; i++)
{
    System.out.print(combine[i] + "  ");
    System.out.println();
}

Answer 1

你需要第二个 for 循环：

for (int i = 0; i < combine.length; i++) {
    if (combine[i].size() > 0) {
        for (Object obj : combine[i]) {
            System.out.println(obj);
        }
    }
}

这将打印：

    X    
   XXX   
  XXXXX  
 XXXXXXX 
XXXXXXXXX
    #    
   ###   
  #####  
 ####### 
#########

Answer 2

您的方括号 [] 似乎来自空的 Stacks。

所以在您的for 循环中确保不要打印空堆栈。

为避免使用逗号，请勿使用自动 toString() 打印堆栈，而是自己对其进行迭代。

Answer 3

    for (int line = 0; line <= 5; line++)
    {
        for (int i = 0; i < combine.length; i++) {
            Stack st = combine[i];
            if (st.size() > line) {
                System.out.print(st.get(line) + "  ");
            } else {
                System.out.print("           ");
            }
        }
        System.out.println();
    }

打印出来

    X                                              #      
   XXX                                            ###     
  XXXXX                                          #####    
 XXXXXXX                                        #######   
XXXXXXXXX                                      #########  

挑战包括：

• 您只能将 行 打印到System.out，因此一次打印一个金字塔不会为您提供您想要的并排的金字塔输出。相反，在每一行上，我们需要从每个堆栈中打印一个元素，该元素足够高以在该行上有一个元素。对于不够高的堆栈，我会打印一个空白字符串以确保以下堆栈正确排列。
• 我假设没有任何金字塔高于 5，并且所有金字塔元素的宽度正好为 9 个字符。如果需要，可以改进代码以考虑其他大小。

为了更好地使用 Java 库类，您可以考虑以下方法。不是你问的，不想用的请忽略。

• 使用泛型。例如Stack<String> stackA = new Stack<>();。这将允许您以 String 对象的形式处理从堆栈中获取的元素，而不仅仅是 Objects。
• 由于泛型类在数组中并不总是能很好地工作，您可以使用List 代替您的数组，例如List<Stack<String>> combine = new ArrayList<>();（可选地给出建议的容量：new ArrayList<>(6)）。

• Stack 类被视为遗留类。文档说你应该更喜欢Deque 接口。我推荐ArrayDeque 类，它实现了接口。喜欢：

  Deque<String> stackA = new ArrayDeque<>(5);
  
  List<Deque<String>> combine = new ArrayList<>(6);
  combine.add(stackA);
  

  要将Deque 用作堆栈，您可以使用其addFirst 方法进行推送，使用其removeFirst 方法进行弹出。在the documentation 中有解释。

• 您可以使用增强的for 循环，例如for (Deque<String> pyramid : combine)。

PS 如果您希望堆栈从底部开始增长，您可能应该先推最宽的元素并以相反的顺序打印行。你很快就会知道的。

Answer 4

如果您不需要 combine 堆栈数组，此代码可能会有所帮助。

    while (!stackA.empty()) {
        stackB.push(stackA.pop());
        stackC.push(stackF.pop());
    }

    while (!stackB.empty()) {
        System.out.println(stackB.pop() + "        " + stackC.pop());
    }

输出：

    X                #    
   XXX              ###   
  XXXXX            #####  
 XXXXXXX          ####### 
XXXXXXXXX        #########

两个堆栈的大小相同。所以循环时间是一样的。您知道 LIFO（后进先出）是堆栈基础。在第一个循环中，我弹出了两个 Stacks 以进行相反的顺序。在最后一个循环中，我只是弹出并打印了堆栈。