Question

我正在尝试实现一个涉及堆栈数组的程序。每个堆栈都接受Integer对象，但问题是当我尝试从堆栈中获取Integer对象时：

import java.util.*;

public class Blocks
{
    public static void main(String[] args)
    {
        System.out.println();
        Scanner input = new Scanner(System.in);

        Stack[] blocks = new Stack[input.nextInt()];
        for (int i = 0; i < blocks.length; i++) {blocks[i] = new Stack<Integer>();} //initializing main array of stacks of blocks
        for (int i = 0; i < blocks.length; i++) {blocks[i].push(i);} //add first block to each stack
        Stack retainer = new Stack<Integer>(); //used for when moving stacks of blocks instead of one block.

        boolean m; //move or pile
        boolean on; //onto or over

        int fromBlock; //block being moved
        int toBlock; //block where the fromBlock is being moved

        String command = input.next();
        while (!command.equals("quit"))
        {
            m = command.equals("move");
            fromBlock = input.nextInt();
            on = input.next().equals("onto");
            toBlock = input.nextInt();

            if (m) //put back blocks on fromBlock
            {
                if (on) //put back blocks on toBlock
                {
                    int holder = blocks[fromBlock].pop().intValue(); //I get a compiler error here
                    moveOnto(blocks, holder, toBlock);
                }
                else //fromBlock goes on top of stack on toBlock
                {
                }
            }
            else //bring blocks on fromBlock
            {
                if (on) //put back blocks on toBlock
                {
                }
                else //fromBlock goes on top of stack on toBlock
                {
                }
            }

            command = input.next();
        }
    }

    void moveOnto(Stack[] array, int sBlock, int rBlock)
    {

    }
}

错误说是无法识别.intValue（）。显然这是一个Integer的方法，我从那一点发现它返回的是Object对象而不是Integer类型。如何让它返回整数类型？

Answer 1

要定义通用数组，您需要执行此操作。

@SuppressWarnings("unchecked") // to avoid warnings.
Stack<Integer>[] blocks = new Stack[n];

然后你可以写

int holder = blocks[fromBlock].pop();

是的，它确实编译并且工作正常。

编辑：为什么编译器不允许你这样做

Stack<Integer>[] blocks = new Stack<Integer>[n];

或

Stack<Integer>[] blocks = new Stack<>[n];

意味着同样的事情超出了我的范围。

Answer 2

int holder = blocks[fromBlock].pop().intValue(); //I get a compiler error here

将其更改为：

int holder = ((Stack<Integer>blocks[fromBlock]).pop().intValue();

您将收到编译器警告。

与此处的所有错误答案相反，您不能在Java中使用泛型类型的数组。

Answer 3

使用Stack的通用版本

即

Stack<Integer>[] blocks = new Stack<Integer>[input.nextInt()];

您必须在声明的类型

中包含泛型参数

即

Stack<Integer[] blocks;

Answer 4

（oops - Java不允许泛型数组） ~~更改Stack变量声明以使用Stack的通用版本：~~

~~Stack<Integer>[] blocks = new Stack<Integer>[input.nextInt()];~~

~~否则，当您访问非泛型堆栈的.pop()方法时，它只返回一个您需要将其强制转换为Integer的对象~~以便访问Integer方法比如intValue（）：

int holder = ((Integer)blocks[fromBlock].pop()).intValue();

（但如果你修改了声明，你就不需要施放。）

Answer 5

您需要将块的类型更改为Stack<Integer>[]。

编辑：代码编译正常。您会收到一个警告，提醒您在运行时仍然可能发生错误的数组赋值，因此编译器无法保证在编写错误代码时不会在运行时获得ClassCastException。但是，发布的解决方案完全符合OP的要求：

public static void main(String[] args) throws Exception {
    Stack<Integer>[] array = new Stack[] { new Stack(7) };
    Integer result = array[0].pop();
}

class Stack<T> {

    private final T foo;

    public Stack(T foo) {
        this.foo = foo;
    }

    T pop() {
        return foo;
    }
}

PS。澄清一下，警告是指出即使你没有显式地进行转换，你仍然可以在运行时获得ClassCastException，如下面的代码所示：

    public static void main(String[] args) throws Exception {
        Stack<Integer>[] array = new Stack[] { new Stack(7) };

        Stack notAnIntegerStack = new Stack<Object>(new Object());
        array[0] = notAnIntegerStack;

        Integer result = array[0].pop(); // class cast exception at runtime
    }

此代码中都有警告指出危险，但它会编译。希望能够解决问题。

堆栈返回对象而不是整数

5 个答案: