泛型如何在java中解决这个不可压缩类型错误？

Question

当我试图将linkedList中最后一个或第一个元素的值赋给一个新项时，出现了一个错误，Item result = lastItem.previousNode.value;它表示不可压缩类型，必选项，find java。朗，反对。我做错了什么？我该如何解决这个问题？谢谢

这是我的代码：

import java.util.Iterator;
import java.util.NoSuchElementException;

public class Deque<Item> implements Iterable<Item> {

private int size;
private node<Item> firstItem  = new node<>();
private node<Item> lastItem = new node<>();

public Deque() {
    firstItem.previousNode = null;
    firstItem.nextNode = lastItem;
    lastItem.previousNode = firstItem;
    lastItem.nextNode = null;
    size = 0;
}                          // construct an empty deque

public boolean isEmpty() { return firstItem.nextNode == lastItem;}                // is the deque empty?

public int size() { return size;}                        // return the number of items on the deque

public void addFirst(Item item) {
    if(item == null){
        throw new NullPointerException("cant add null to deque");
    }

    if(firstItem.nextNode == lastItem){
        node nextItem = new node();
        nextItem.value = item;
        firstItem.nextNode = nextItem;
        nextItem.previousNode = firstItem;
        lastItem.previousNode = nextItem;
        nextItem.nextNode = lastItem;
    }
    else{
        node nextItem = new node();
        nextItem.value = item;
        firstItem.nextNode.previousNode = nextItem;
        nextItem.previousNode = firstItem;
        nextItem.nextNode = firstItem.nextNode;
        firstItem.nextNode = nextItem;
    }
    size++;
}         // add the item to the front

public void addLast(Item item) {
    if(item == null){
        throw new NullPointerException("cant add null to deque");
    }

    if(lastItem.previousNode == firstItem){
        node nextItem = new node();
        nextItem.value = item;
        firstItem.nextNode = nextItem;
        nextItem.previousNode = firstItem;
        lastItem.previousNode = nextItem;
        nextItem.nextNode = lastItem;
    }
    else {
        node nextItem = new node();
        nextItem.value = item;
        nextItem.previousNode = lastItem.previousNode;
        lastItem.previousNode = nextItem;
        nextItem.nextNode = lastItem;
        lastItem.previousNode.nextNode = nextItem;
    }
    size++;
}          // add the item to the end

public Item removeFirst(){
    if (firstItem.nextNode == lastItem) {
        throw new NoSuchElementException("Client tries to remove an Item from empty deque.");
    }
    node result = firstItem.nextNode;
    firstItem.nextNode = firstItem.nextNode.nextNode;
    firstItem.nextNode.nextNode.previousNode = firstItem;
    size--;
    return result.value;
}                // remove and return the item from the front

public Item removeLast() {
    if(lastItem.previousNode == firstItem){
        throw new NoSuchElementException("Client tries to remove an Item from empty deque.");
    }
    Item result = lastItem.previousNode.value;
    lastItem.previousNode = lastItem.previousNode.previousNode;
    lastItem.previousNode.nextNode = lastItem;
    size--;
    return result;
}                // remove and return the item from the end

public Iterator<Item> iterator() {
    return new dequeIterator();
}        // return an iterator over items in order from front to end

    private class dequeIterator implements Iterator<Item>{
        private node<Item> nextNode = firstItem;

        @Override
        public boolean hasNext(){
            return nextNode.nextNode != lastItem;
        }

        @Override
        public Item next() {
            if (!hasNext()) {
                throw new NoSuchElementException("No next element available. Reached end of deque.");
            }

            Item returnValue = nextNode.value;
            nextNode = nextNode.nextNode;
            return returnValue;
        }

        @Override
        public void remove() {
            throw new UnsupportedOperationException("Remove is not supported");
        }
    }


    public static void main(String[] args){}   // unit testing (optional)

    private class node<Item>{
        private Item value;
        private node previousNode;
        private node nextNode;
    }
}

Answer 1

你的node类正在重新定义你想要使用的泛型。不要这样做。只需在node内使用泛型Item来声明值。您不需要声明node<Item>。所以，你的node类变成了这样：

private class node {
    private Item value;
    private node previousNode;
    private node nextNode;
}

由于泛型Item的重新声明，它无法将node.Item转换为Deque.Item。这就是你犯错误的原因

此外，在实例化node对象时，需要删除所有泛型：

比如

node<Item> firstItem  = new node<>();

将成为：

node firstItem  = new node();

---

这将是你的整个Deque课程：

public class Deque<Item> implements Iterable<Item> {

    private int size;
    private node firstItem = new node();
    private node lastItem = new node();

    public Deque() {
        firstItem.previousNode = null;
        firstItem.nextNode = lastItem;
        lastItem.previousNode = firstItem;
        lastItem.nextNode = null;
        size = 0;
    } // construct an empty deque

    public boolean isEmpty() {
        return firstItem.nextNode == lastItem;
    } // is the deque empty?

    public int size() {
        return size;
    } // return the number of items on the deque

    public void addFirst(Item item) {
        if (item == null) {
            throw new NullPointerException("cant add null to deque");
        }

        if (firstItem.nextNode == lastItem) {
            node nextItem = new node();
            nextItem.value = item;
            firstItem.nextNode = nextItem;
            nextItem.previousNode = firstItem;
            lastItem.previousNode = nextItem;
            nextItem.nextNode = lastItem;
        } else {
            node nextItem = new node();
            nextItem.value = item;
            firstItem.nextNode.previousNode = nextItem;
            nextItem.previousNode = firstItem;
            nextItem.nextNode = firstItem.nextNode;
            firstItem.nextNode = nextItem;
        }
        size++;
    } // add the item to the front

    public void addLast(Item item) {
        if (item == null) {
            throw new NullPointerException("cant add null to deque");
        }

        if (lastItem.previousNode == firstItem) {
            node nextItem = new node();
            nextItem.value = item;
            firstItem.nextNode = nextItem;
            nextItem.previousNode = firstItem;
            lastItem.previousNode = nextItem;
            nextItem.nextNode = lastItem;
        } else {
            node nextItem = new node();
            nextItem.value = item;
            nextItem.previousNode = lastItem.previousNode;
            lastItem.previousNode = nextItem;
            nextItem.nextNode = lastItem;
            lastItem.previousNode.nextNode = nextItem;
        }
        size++;
    } // add the item to the end

    public Item removeFirst() {
        if (firstItem.nextNode == lastItem) {
            throw new NoSuchElementException("Client tries to remove an Item from empty deque.");
        }
        node result = firstItem.nextNode;
        firstItem.nextNode = firstItem.nextNode.nextNode;
        firstItem.nextNode.nextNode.previousNode = firstItem;
        size ;
        return result.value;
    } // remove and return the item from the front

    public Item removeLast() {
        if (lastItem.previousNode == firstItem) {
            throw new NoSuchElementException("Client tries to remove an Item from empty deque.");
        }
        Item result = lastItem.previousNode.value;
        lastItem.previousNode = lastItem.previousNode.previousNode;
        lastItem.previousNode.nextNode = lastItem;
        size ;
        return result;
    } // remove and return the item from the end

    public Iterator<Item> iterator() {
        return new dequeIterator();
    } // return an iterator over items in order from front to end

    private class dequeIterator implements Iterator<Item> {
        private node nextNode = firstItem;

        @Override
        public boolean hasNext() {
            return nextNode.nextNode != lastItem;
        }

        @Override
        public Item next() {
            if (!hasNext()) {
                throw new NoSuchElementException("No next element available. Reached end of deque.");
            }

            Item returnValue = nextNode.value;
            nextNode = nextNode.nextNode;
            return returnValue;
        }

        @Override
        public void remove() {
            throw new UnsupportedOperationException("Remove is not supported");
        }
    }

    public static void main(String[] args) {
    } // unit testing (optional)

    private class node {
        private Item value;
        private node previousNode;
        private node nextNode;
    }

}

PS：我建议使用E、K、I等单个字母来定义泛型，而不是像Item这样的名称。它很容易被误解为一门课

---

希望这有帮助