在堆栈的ArrayList中，如果堆栈为空，为什么索引不正确？

Question

我有一个堆栈的ArrayList，我在其中一个堆栈中添加了一个元素，并在列表中循环打印每个堆栈的索引

然后我从上一个堆栈中删除元素，将其添加到下一个堆栈中，打印每个堆栈的索引，并对ArrayList中的所有堆栈继续此操作

然而，当任何堆栈为空时，在获取ArrayList中每个堆栈的索引时会出现非常不寻常的行为。非空的堆栈将具有正确的索引值，而空的堆栈将具有错误的索引值

此外，如果包含元素的堆栈的索引为0，则所有其他索引值都将为1。如果包含元素的堆栈位于任何其他索引，它将具有正确的索引值，并且所有其他索引值都将为0

import java.util.List;
import java.util.Stack;
import java.util.ArrayList;

public class ListOfStacks {

    // instance variables:
    List<Stack<Integer>> stacks;
    private static final int NUMBER_OF_STACKS = 3;

    // constructor:
    ListOfStacks() {
        this.stacks = new ArrayList<Stack<Integer>>(NUMBER_OF_STACKS);

        // adding the stacks to the list here:
        for (int i = 0; i < NUMBER_OF_STACKS; i++) {
            this.stacks.add(new Stack<Integer>());
        }
    }

    // instance methods:
    void addElement(int stackIndex, int element) {
        this.stacks.get(stackIndex).add(element);
    }
    void removeElement(int stackIndex) {
        this.stacks.get(stackIndex).pop();
    }
    void printIndexes(int stackIndex, int element) {
        System.out.printf("The stack at index %d now contains %d" +
            "(the other stacks are empty):%n", stackIndex, element);

        for (Stack<Integer> stack : this.stacks) {
            System.out.printf("index %d%n", this.stacks.indexOf(stack));
        }
        System.out.println();
    }

    // main method:
    public static void main(String[] args) {
        ListOfStacks list = new ListOfStacks();
        int index = 0, number = 5;

        // adding the number 5 to the stack at index 0:
        list.addElement(index, number);
        list.printIndexes(index, number);

        // now removing that element, and adding it to the stack at index 1:
        list.removeElement(index++);
        list.addElement(index, number);
        list.printIndexes(index, number);

        // now removing that element, and adding it to the stack at index 2:
        list.removeElement(index++);
        list.addElement(index, number);
        list.printIndexes(index, number);
    }
} // end of ListOfStacks

下面是输出（对于三个堆栈的ArrayList）：

The stack at index 0 now contains 5 (the other stacks are empty):
index 0
index 1
index 1

The stack at index 1 now contains 5 (the other stacks are empty):
index 0
index 1
index 0

The stack at index 2 now contains 5 (the other stacks are empty):
index 0
index 0
index 2

Answer 1

indexOf(Object o) 
          Returns the index of the first occurrence of the specified element in this list, or -1 if this list does not contain the element.

java中的堆栈基本上是一个向量，vector类将其用于equals

 /**
  969        * Compares the specified Object with this Vector for equality.  Returns
  970        * true if and only if the specified Object is also a List, both Lists
  971        * have the same size, and all corresponding pairs of elements in the two
  972        * Lists are <em>equal</em>.  (Two elements {@code e1} and
  973        * {@code e2} are <em>equal</em> if {@code (e1==null ? e2==null :
  974        * e1.equals(e2))}.)  In other words, two Lists are defined to be
  975        * equal if they contain the same elements in the same order.
  976        *
  977        * @param o the Object to be compared for equality with this Vector
  978        * @return true if the specified Object is equal to this Vector
  979        */
  980       public synchronized boolean equals(Object o) {
  981           return super.equals(o);
  982       }

因此，indexof正在寻找第一个空堆栈，将其视为相等，并返回该索引。

因此，当索引0有元素而其他没有元素时，第一个等于空堆栈的堆栈是位置1。

如果另一个元素有数据，并且第一个元素相等，并且您正在寻找一个空堆栈，它将始终停止并返回索引0。

Answer 2

获取错误索引号的原因与列表中实现indexOf的方式有关。它在下面调用堆栈。equals（）。这决定了堆栈在元素方面是否相等。当你调用列表时。indexOf对于空堆栈，它将返回列表中第一个空堆栈的索引。