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

Posted 2023-04-14

【中文标题】Java：如何打印没有方括号和逗号的数组

【英文标题】：Java: how to print array without square brackets and commas

【发布时间】：2018-05-27 05:36:34

【问题描述】：

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

    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();

【问题讨论】：

能否请您向我们展示您当前代码给出的输出 - 啊，太好了，我现在看到了。 - 你基本上得到了一个包含在数组中的数组。

@LucyIsabelle 我设法以金字塔方式打印它，但是当我从堆栈中移动元素并显示它时，它不相符，它给了我原始图片，它又是金字塔照片.

您使用的是java.util.Stack 类吗？在那种情况下，恐怕你不能改变它的toString 方法。当您执行combine[i] + " " 时，这就是隐含的调用。解决方案包括编写自己的printStack 方法并像printStack(combine[i]) + " " 一样使用它。不过，完全不确定它是否会为您提供真正想要的东西。

尝试使用嵌套的 for 循环。例如 for (int i = 0; i

@LucyIsabelle 好的，露西，我会试试的。

【参考方案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
    #    
   ###   
  #####  
 ####### 
#########

【参考方案2】：

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

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

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

【讨论】：

很好解释的答案。 +1。

【参考方案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 如果您希望堆栈从底部开始增长，您可能应该先推最宽的元素并以相反的顺序打印行。你很快就会知道的。

【参考方案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 以进行相反的顺序。在最后一个循环中，我只是弹出并打印了堆栈。

【讨论】：

它是如何工作的？请解释。这是一个令人惊讶的解决方案。

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