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

尝试将linkedList中最后一个或第一个元素的值赋给新项时出错，

Item result=lastItem.previousNode.value它表示不可压缩类型、必填项、已找到java.lang.Object。我做错了什么？我该如何解决这个问题？多谢各位

这是我的密码：

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;
    }
}

import java.util.Iterator；
导入java.util.NoSuchElementException；
公共类Deque实现了Iterable{
私有整数大小；
私有节点firstItem=新节点（）；
私有节点lastItem=新节点（）；
公共部门（）{
firstItem.previousNode=null；
firstItem.nextNode=lastItem；
lastItem.previousNode=firstItem；
lastItem.nextNode=null；
尺寸=0；
}//构造一个空的deque
public boolean isEmpty（）{return firstItem.nextNode==lastItem；}//数据是否为空？
public int size（）{return size；}//返回数据块上的项数
公共无效添加第一个（项目）{
如果（项==null）{
抛出新的NullPointerException（“不能将null添加到deque”）；
}
if（firstItem.nextNode==lastItem）{
node nextItem=新节点（）；
nextItem.value=项目；
firstItem.nextNode=nextItem；
nextItem.previousNode=firstItem；
lastItem.previousNode=nextItem；
nextItem.nextNode=lastItem；
}
否则{
node nextItem=新节点（）；
nextItem.value=项目；
firstItem.nextNode.previousNode=nextItem；
nextItem.previousNode=firstItem；
nextItem.nextNode=firstItem.nextNode；
firstItem.nextNode=nextItem；
}
大小++；
}//将项目添加到前面
公共无效addLast（项目）{
如果（项==null）{
抛出新的NullPointerException（“不能将null添加到deque”）；
}
if（lastItem.previousNode==firstItem）{
node nextItem=新节点（）；
nextItem.value=项目；
firstItem.nextNode=nextItem；
nextItem.previousNode=firstItem；
lastItem.previousNode=nextItem；
nextItem.nextNode=lastItem；
}
否则{
node nextItem=新节点（）；
nextItem.value=项目；
nextItem.previousNode=lastItem.previousNode；
lastItem.previousNode=nextItem；
nextItem.nextNode=lastItem；
lastItem.previousNode.nextNode=nextItem；
}
大小++；
}//将项目添加到末尾
公共项目移除优先（）{
if（firstItem.nextNode==lastItem）{
抛出新的NoSuchElementException（“客户端试图从空的deque中删除一个项”）；
}
节点结果=firstItem.nextNode；
firstItem.nextNode=firstItem.nextNode.nextNode；
firstItem.nextNode.nextNode.previousNode=firstItem；
大小--；
返回result.value；
}//从前面取出并返回项目
公共项目removeLast（）{
if（lastItem.previousNode==firstItem）{
抛出新的NoSuchElementException（“客户端试图从空的deque中删除一个项”）；
}
项目结果=lastItem.previousNode.value；
lastItem.previousNode=lastItem.previousNode.previousNode；
lastItem.previousNode.nextNode=lastItem；
大小--；
返回结果；
}//从末尾删除并返回项目
公共迭代器迭代器（）{
返回新的dequeIterator（）；
}//按从头到尾的顺序返回项的迭代器
私有类dequeIterator实现迭代器{
私有节点nextNode=firstItem；
@凌驾
公共布尔hasNext（）{
返回nextNode.nextNode！=lastItem；
}
@凌驾
公共项目下一步（）{
如果（！hasNext（））{
抛出新的NoSuchElementException（“没有下一个元素可用。已到达deque结尾。”）；
}
Item returnValue=nextNode.value；
nextNode=nextNode.nextNode；
返回值；
}
@凌驾
公共空间删除（）{
抛出新的UnsupportedOperationException（“不支持删除”）；
}
}
公共静态void main（字符串[]args）{}//单元测试（可选）
私有类节点{
私人物品价值；
私有节点优先节点；
私有节点nextNode；
}
}
您的
节点
类正在重新定义要使用的泛型。不要这样做。只需使用
节点内的通用
项
来声明值。您不需要声明
节点
。因此，您的
节点
类变为：

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

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

此外，在实例化
节点
对象时，还需要删除任何泛型：

比如说,

node<Item> 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;
    }

}

public类Deque实现了Iterable{
私有整数大小；
私有节点firstItem=新节点（）；
私有节点lastItem=新节点（）；
公共部门（）{
firstItem.previousNode=null；
firstItem.nextNode=lastItem；
lastItem.previousNode=firstItem；
lastItem.nextNode=null；
尺寸=0；
}//构造一个空的deque
公共布尔值为空（）{
return firstItem.nextNode==lastItem；
}//是空的吗？
公共整数大小（）{
返回大小；
}//返回数据块上的项目数
公共无效添加第一个（项目）{
如果（项==null）{
抛出新的NullPointerException（“不能将null添加到deque”）；
}
if（firstItem.nextNode==lastItem）{
node nextItem=新节点（）；
nextItem.value=项目；
firstItem.nextNode=nextItem；
nextItem.previousNode=firstItem；
lastItem.previousNode=nextItem；
nextItem.nextNode=lastItem；
}否则{
节点ne
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;
    }

}