1


Stacks の ArrayList があり、Stacks の 1 つに要素を追加し、各 Stacks のインデックスを出力するリストを反復処理します。

次に、前の Stack から要素を削除して次の Stack に追加し、各 Stack のインデックスを出力して、ArrayList 内のすべての Stack についてこれを続けます。

ただし、いずれかのスタックが空の場合、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


...そしてここに出力があります（3つのスタックの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


4

2 に答える 2

6

間違ったインデックス番号を取得する理由はindexOf、リストに実装されている方法と関係があります。その下で。を呼び出しますStack.equals()。これにより、スタックが要素ごとに等しいかどうかが決まります。空のスタックで呼び出すlist.indexOfと、リストの最初の空のスタックのインデックスが返されます。

于 2013-03-23T20:19:36.810 に答える
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のスタックは基本的にベクトルであり、ベクトルクラスにはこれが等しい

 /**
  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 を返します。

于 2013-03-23T20:23:38.583 に答える