Java LinkedList getFirstElement和getLastElement方法

我需要编写一个Java程序（类LinkedList），该程序可以在不使用导入列表的情况下完成所有工作，我已经尝试过了，但我不确定它们是否工作正常

有人能帮我吗？尤其是getFirstElement和getLastElement方法

以下是我的课程：

package main.java.a3;

public interface List<E> {
    public void add(E e); 
    public void add(int index, E e);
    public int size();
    public E get(int index);
    public boolean isEmpty();
}




package main.java.a3;

    import java.util.NoSuchElementException;

    public class LinkedList<E> implements List<E>{

        private ListNode head;

        @Override
        public void add(E e) {
            if(e == null){
                throw new NullPointerException("Element was null");
            }   
            if(head == null){
                head = new ListNode(e,null);
            }else{  
                    ListNode temp = head;
                    while(temp.next!=null){
                        temp=temp.next;
                    }
                    temp.setNext(new ListNode(e,null));
                }
        }

        @Override
        public void add(int index, E e) {
            if(e == null) {
                throw new NullPointerException("Element was null!");
            }
            else if(index<0){
                throw new IndexOutOfBoundsException("Index was negative");
            }
            else if(index>=size() + 1){
                throw new IndexOutOfBoundsException("Index was bigger than size");  
            } else {
                ListNode temp = head;
                while(temp.next != null) {
                    temp = temp.next;
                }
                temp.setNext(new ListNode(e, null));
            }

        }

        @Override
        public int size() {
            int size = 0;
            ListNode temp = head;
            while(temp != null) {
                size++;
                temp = temp.getNext();
            }  
               return size;
        }

        @Override
        public E get(int index) {
            if(index<0){
                throw new IndexOutOfBoundsException("Index was negative");
            }
            if(index>=size()){
                throw new IndexOutOfBoundsException("Index was bigger than size");  
            }
            ListNode temp = head;
            for (int i = 0; i<index;i++){
                temp = temp.next;
            }
            return temp.data;
        }

        @Override
        public boolean isEmpty() {
            if(head == null) {
                return true;
            } else {
                return false;
            }
        }

                // innere Klasse        
                        private class ListNode{
                            E data;
                            ListNode next;

                            public ListNode(E data, ListNode next){
                                setData(data);
                                setNext(next);
                            }

                            public void setData(E data){
                                this.data = data;
                            }

                            public void setNext(ListNode next){
                                this.next = next;
                            }

                            public E getData() {
                                return data;
                            }

                            public ListNode getNext() {
                                return next;
                            }

                        }
                // innere Klasse    

        public String toString() {
                return head.toString(); 
        }

        public void addFirst(E elem) {
            if(elem == null) {
                throw new NullPointerException("Element was null!");
            } else {
                ListNode temp = new ListNode(elem, head);
                if(head != null) {
                    temp.setNext(head);
                }
                head = temp;
            }
        }

        public void addLast(E elem) {
            if(elem == null) {
                throw new NullPointerException("Element was null!");
            } else {
                ListNode tail = new ListNode(elem, null);
                while(head != null) {
                    tail.getNext();
                    if(tail.getNext() == null) {
                        tail.setNext(head);
                    }
                } 
            }
        }

        public E getFirst() {
            if(head == null) {
                throw new NoSuchElementException("Element was null!");
            }else {
                return (E) head;
            }

        }

        public E getLast(){
            E elem = null;
            ListNode tail = new ListNode(elem, null);
            if(tail == null) {
                throw new NoSuchElementException("Element was null!");
            }
            return (E) tail;
        }


    }

package main.java.a3；
公共接口列表{
公共空间添加（E）；
公共无效添加（整数索引，E）；
公共整数大小（）；
公共E-get（int-index）；
公共布尔值为空（）；
}
包main.java.a3；
导入java.util.NoSuchElementException；
公共类LinkedList实现列表{
私有节点头；
@凌驾
公共空间添加（E）{
如果（e==null）{
抛出新的NullPointerException（“元素为null”）；
}   
if（head==null）{
head=新的ListNode（e，null）；
}否则{
ListNode温度=头；
while（临时下一步！=null）{
温度=下一个温度；
}
temp.setNext（新的ListNode（e，null））；
}
}
@凌驾
公共无效添加（整数索引，E）{
如果（e==null）{
抛出新的NullPointerException（“元素为null！”）；
}
否则如果（索引=大小（）+1）{
抛出新索引AutofBoundsException（“索引大于大小”）；
}否则{
ListNode温度=头；
while（temp.next！=null）{
温度=下一个温度；
}
temp.setNext（新的ListNode（e，null））；
}
}
@凌驾
公共整数大小（）{
int size=0；
ListNode温度=头；
while（temp！=null）{
大小++；
temp=temp.getNext（）；
}  
返回大小；
}
@凌驾
公共E-get（int索引）{
如果（索引=大小（））{
抛出新索引AutofBoundsException（“索引大于大小”）；
}
ListNode温度=头；
对于（inti=0；i在
getFirst
中，您正在将
head
元素转换为
E
，
head
类型为
ListNode
。您需要返回
head.data
，而不是
head
本身。也就是说，如果您确实想要值，而不是元素，那么只需返回
head
，然后返回
head
将返回类型更改为
ListNode

我不理解你的
getLast
tho，你正在创建一个新元素，然后检查它是否为null（？），然后在
ListNode
时再次将它强制转换为
E
。你需要迭代整个列表以获得最后一个元素，然后返回它，类似于：

ListNode temp=head；
while（temp.next！=null）
温度=下一个温度；
返回温度数据；

然后就像我之前写的那样，您可以返回元素或值。当然，您需要注意可能的空指针，例如
head
为空等等，但是您知道。
有两个选项，迭代选项和恒定时间选项

在迭代过程中，头指向第一个节点，因此获取第一个元素只需调用头.data（），但对于最后一个元素，必须使用while/for循环进行迭代，直到currentNode.next（）！=null

在常量时间选项中，您有两个指针，一个用于head，另一个用于最后一个元素。对于获取第一个元素，它与迭代方式相同，但对于获取最后一个元素，您必须使用最后一个指针返回值。这里的复杂问题是控制添加/删除元素以更新de最后一个节点

一个非常基本的例子可以是：

public class LinkedList<E> implements List<E>{
    private ListNode<E> head;
    private ListNode<E> last;
    private int size;

    public E getFirst(){
        if(head!=null)
            return head.data();
        else
            return null;
    }

    public E getIterativeLast(){
        if(head!=null){
            ListNode<E> last =  head;
            for(;last.next()!=null; last=last.next());
            return last.data(());

        }else{
            return null;
        }
    }


    public E getConstantLast(){
        if(last != null){
            return last.data();
        }else{
            return null;
        }

    }

    public void add(E elem){
        LastNode<E> newElem = new LastNode(elem);
        if(head == null){
            head = last = newElem;
        }else{
            last.setNext(newElem);
            last = newElem:
        }
        size++;
    }

}

getFirstElement（）和getLastElement（）

/*假设链接列表中的元素存储在节点类的变量数据中*/

public E getFirst() {
            if(head == null) {
                throw new NoSuchElementException("Element was null!");
            }else {
                return (E) head.data;
            }

        }

        public E getLast(){
            if(head == null) {
                throw new NoSuchElementException("Element was null!");
            }
            else{
                for(Node iterate=head; iterate!=null; iterate=iterate.next){
                    return (E) iterate.data;
                }

            }
        }

getFirstElement应该只是
return head.getData（）
getLastElement是
if（head.getNext（）==null）{return data；}否则{return getNext（）.getLastElement（）；}
Where next（）.getLastElement是一个递归调用。getFirst方法正在工作，但getLast不工作。但无论如何，谢谢。正在编写编辑，但发生了错误；getLastElement是
if（head.getNext（）==null）{return data；}else{return getNext（）.getLastElement（）；}
Where next（）.getLastElement是一个递归调用。getLast应该与addLast函数具有相同的逻辑，只是不添加新节点，但返回的最后一个节点不为null
public E getFirst() {
            if(head == null) {
                throw new NoSuchElementException("Element was null!");
            }else {
                return (E) head.data;
            }

        }

        public E getLast(){
            if(head == null) {
                throw new NoSuchElementException("Element was null!");
            }
            else{
                for(Node iterate=head; iterate!=null; iterate=iterate.next){
                    return (E) iterate.data;
                }

            }
        }