手写LinkedList

简单的实现了增加和删除方法，以及返回节点个数和返回所有元素值
直接上代码吧
首先创建了一个Node类，前指向，后指向以及数据

package Node;

public class Node {
    private Node pre;
    private Node next;
    private Object value;

    public Node() {
    }

    public Node(Node pre, Node next, Object value) {
        this.pre = pre;
        this.next = next;
        this.value = value;
    }

    public Node getPre() {
        return pre;
    }

    public void setPre(Node pre) {
        this.pre = pre;
    }

    public Node getNext() {
        return next;
    }

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

    public Object getValue() {
        return value;
    }

    public void setValue(Object value) {
        this.value = value;
    }
}

然后是具体实现

import Node.Node;

public class MyArrayLinkedList {
    //首节点
    private Node firstNode;
    //末节点
    private Node lastNode;
    //节点个数
    private int size;

   public void add(Object object){
       //创建新节点，将object放入节点中
       Node newNode = new Node();
       newNode.setValue(object);

       //判断首节点是否为空
       if(firstNode == null){//如果首节点为null，新节点就是首节点，首节点也是末节点
           firstNode = newNode;
           lastNode = firstNode;
       }else{//首节点不为null，将新节点放入到最后一个节点的后面,新节点的前指向又指向lastNode
           lastNode.setNext(newNode);
           newNode.setPre(lastNode);
           lastNode = newNode;
       }
       size++;
   }

   //移除节点
   public void remove(Object object){
       if(object.equals(firstNode.getValue())){//如果删除的是第一个节点
           firstNode = firstNode.getNext();//将下一个节点变成第一个节点
           firstNode.setPre(null);
       }else {//如果不是第一个节点
           Node currentNode = firstNode.getNext();//第二个节点指向当前节点
           //根据传入的值循环判断要删除的值是哪一个节点
           while(!object.equals(currentNode.getValue())){
               currentNode = currentNode.getNext();
           }
           if(currentNode.getNext() == null){//如果当前节点是最后一个节点
               //重新指向，最后的节点的上一个节点的next指向null
               currentNode.getPre().setNext(null);
           }else {//不是最后一个节点
               //重新指向，即要删除的节点的上一个节点的next指向要删除的下一个节点
               currentNode.getPre().setNext(currentNode.getNext());
               //重新指向，即要删除的节点的下一个节点的pre指向要删除的上一个节点
               currentNode.getNext().setPre(currentNode.getPre());
           }
       }
       size--;
   }

   //返回链表的节点个数
   public int size(){
       return size;
   }

   //返回节点的所有元素值
   public Object[] getAll(){
       Object[] temp = new Object[size];
       Node node = firstNode;
       for(int i = 0;i < size;i++){
           temp[i] = node.getValue();
           node = node.getNext();
       }
       return temp;
   }
}

测试类

import java.util.Arrays;

public class TestMyArrayLinkedList {
    public static void main(String[] args) {
        MyArrayLinkedList myArrayLinkedList=new MyArrayLinkedList();
       //测试add方法
        for(int i=0;i<6;i++){
            myArrayLinkedList.add(i+1+"小明");
        }
        myArrayLinkedList.add("7小明");
        //测试getAll方法
        Object[] all = myArrayLinkedList.getAll();
        System.out.println(Arrays.toString(all));

        int size = myArrayLinkedList.size();
        System.out.println(size);
        //测试remove方法
        myArrayLinkedList.remove("6小明");

        Object[] list = myArrayLinkedList.getAll();
        System.out.println(Arrays.toString(list));
        size = myArrayLinkedList.size();
        System.out.println(size);
    }

}

测试结果