Java 堆栈反向和排序

我有一个数据结构堆栈。堆栈中的堆栈

Stack<Stack<Integer>> stack = new Stack<>();
Stack<Integer> stackI1 = new Stack<>();
Stack<Integer> stackI2 = new Stack<>();
Stack<Integer> stackI3 = new Stack<>();

Stack Stack=新堆栈（）；
Stack stackI1=新堆栈（）；
Stack stackI2=新堆栈（）；
Stack stackI3=新堆栈（）；

我已经加入了一些元素，看起来像[[1,2,3]，[4,5,6]，[7,8,9]]

---

现在我想对这些元素进行排序，第一个值是指1，4，7。怎么可能？找不到内置函数。无法使用Collection.sort进行排序。那么备选方案在哪里呢？也希望在排序后进行反转。但无法使用内置函数Collection.reverse进行反转。请帮助我

堆栈

扩展

向量

，这样您就可以使用

列表#排序

求助于

堆栈

（如评论中所述，这是非常“不寻常的”）。您提供的值产生了一个已经“排序”的堆栈，因此我更改了它以显示代码对它的影响：

import java.util.Stack;

public class StackSort {

    public final static void main(String[] args) {
        Stack<Stack<Integer>> stacks = new Stack<>();
        Stack<Integer> stackI1 = new Stack<>();
        stackI1.push(Integer.valueOf(1));
        stackI1.push(Integer.valueOf(2));
        stackI1.push(Integer.valueOf(3));
        Stack<Integer> stackI2 = new Stack<>();
        stackI2.push(Integer.valueOf(7));
        stackI2.push(Integer.valueOf(8));
        stackI2.push(Integer.valueOf(9));
        Stack<Integer> stackI3 = new Stack<>();
        stackI3.push(Integer.valueOf(4));
        stackI3.push(Integer.valueOf(5));
        stackI3.push(Integer.valueOf(6));

        stacks.push(stackI1);
        stacks.push(stackI2);
        stacks.push(stackI3);

        System.out.println(stacks);

        stacks.sort((stack1, stack2) -> {
            if (stack1.isEmpty()) {
                return stack2.isEmpty() ? -1 : 0;
            }
            if (stack2.isEmpty()) {
                return 1;
            }

            return stack1.get(0).compareTo(stack2.get(0));
        });

        System.out.println(stacks);
    }
}

import java.util.Stack；
公共类堆栈排序{
公共最终静态void main（字符串[]args）{
堆栈=新堆栈（）；
Stack stackI1=新堆栈（）；
stackI1.push（Integer.valueOf（1））；
stackI1.push（Integer.valueOf（2））；
stackI1.push（Integer.valueOf（3））；
Stack stackI2=新堆栈（）；
stackI2.push（Integer.valueOf（7））；
stackI2.push（Integer.valueOf（8））；
stackI2.push（Integer.valueOf（9））；
Stack stackI3=新堆栈（）；
stackI3.push（Integer.valueOf（4））；
stackI3.push（Integer.valueOf（5））；
stackI3.push（Integer.valueOf（6））；
stacks.push（stackI1）；
stacks.push（stackI2）；
stacks.push（stackI3）；
系统输出打印LN（堆栈）；
stacks.sort（（stack1，stack2）->{
if（stack1.isEmpty（））{
返回stack2.isEmpty（）？-1:0；
}
if（stack2.isEmpty（））{
返回1；
}
返回stack1.get（0）.compareTo（stack2.get（0））；
});
系统输出打印LN（堆栈）；
}
}

如果要排序，则不需要堆栈。不，我需要堆栈，然后对该堆栈进行排序。这没有多大意义-堆栈的定义是先进先出的行为；你为什么要分类呢？把东西拿出来，分类，把它们放回原处。我不记得曾经为一个*分类过一堆东西。您探索路径的方式应该以排序的顺序添加所有内容HIII！！！它不工作，无法排序。排序前将堆栈值返回给我。@RimaSur Here[TM]我从代码中的两个

系统.out.println

中获得以下输出：

[[1,2,3]，[7,8,9]，[4,5,6]]

之前和

[[1,2,3]，[4,5,6]，[7,8,9]]

调用

排序后。那么你说“不工作”到底是什么意思呢？我在上一篇文章中写道。这个很好。谢谢现在，如果我想把整个答案颠倒过来，或者按相反的顺序排序，我该怎么办？请帮助我。@RimaSur若要反向排序，请取消排序功能，您可以使用
返回stack2.get（0）.compareTo（stack1.get（0））用于部分it@RimaSur对比较块中返回的值求反。而不是
1
返回
-1
，反之亦然。并在最后一行前放置一个
-
，以否定
比较调用的结果