在堆栈的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在列表中实现的方式做。在它下面拨打Stack.equals()。这决定了堆栈是否等于元素明智。当您用空栈调用list.indexOf时，它将返回列表中第一个空栈的索引。

Answer 2

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堆栈基本上是一个向量，向量类有此为等于

/** 
    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.