Java函数编写实现双向链表

双向链表是一种常见的数据结构，它与单向链表相比，除了具有后继指针Next指向下一个节点外，还具有前驱指针Prev指向前一个节点。

为了实现双向链表，我们需要定义一个节点类Node，其中包含节点的值value和指向下一个节点的指针next，以及指向前一个节点的指针prev。然后我们需要定义一个双向链表类DoubleLinkedList，其中包含链表的头节点head和尾节点tail，以及链表的长度size。

下面是对应的Java代码实现：

class Node {
    int value;
    Node prev;
    Node next;

    public Node(int value) {
        this.value = value;
        this.prev = null;
        this.next = null;
    }
}

class DoubleLinkedList {
    Node head;
    Node tail;
    int size;

    public DoubleLinkedList() {
        this.head = null;
        this.tail = null;
        this.size = 0;
    }

    // 在链表末尾添加一个节点
    public void addNode(int value) {
        Node newNode = new Node(value);
        if (size == 0) {
            head = newNode;
            tail = newNode;
        } else {
            tail.next = newNode;
            newNode.prev = tail;
            tail = newNode;
        }
        size++;
    }

    // 在链表指定位置插入一个节点
    public void insertNode(int value, int index) {
        if (index < 0 || index > size) {
            throw new IndexOutOfBoundsException();
        }
        Node newNode = new Node(value);
        if (index == 0) {
            newNode.next = head;
            head.prev = newNode;
            head = newNode;
        } else if (index == size) {
            tail.next = newNode;
            newNode.prev = tail;
            tail = newNode;
        } else {
            Node currNode = head;
            for (int i = 0; i < index - 1; i++) {
                currNode = currNode.next;
            }
            newNode.prev = currNode;
            newNode.next = currNode.next;
            currNode.next.prev = newNode;
            currNode.next = newNode;
        }
        size++;
    }

    // 删除链表指定位置的节点
    public void deleteNode(int index) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException();
        }
        if (index == 0) {
            head = head.next;
            head.prev = null;
        } else if (index == size - 1) {
            tail = tail.prev;
            tail.next = null;
        } else {
            Node currNode = head;
            for (int i = 0; i < index; i++) {
                currNode = currNode.next;
            }
            currNode.prev.next = currNode.next;
            currNode.next.prev = currNode.prev;
        }
        size--;
    }

    // 获取链表指定位置的节点值
    public int get(int index) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException();
        }
        Node currNode = head;
        for (int i = 0; i < index; i++) {
            currNode = currNode.next;
        }
        return currNode.value;
    }

    // 修改链表指定位置的节点值
    public void set(int index, int value) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException();
        }
        Node currNode = head;
        for (int i = 0; i < index; i++) {
            currNode = currNode.next;
        }
        currNode.value = value;
    }

    // 返回链表的长度
    public int size() {
        return size;
    }
}

public class Main {
    public static void main(String[] args) {
        DoubleLinkedList dll = new DoubleLinkedList();
        dll.addNode(1);
        dll.addNode(2);
        dll.addNode(3);
        dll.insertNode(4, 1);
        dll.deleteNode(2);
        System.out.println(dll.get(1));
        dll.set(1, 5);
        System.out.println(dll.size());
    }
}

在主函数中，我们创建了一个双向链表对象dll，并进行了一些基本操作的测试，比如添加节点、插入节点、删除节点、获取节点值、修改节点值以及获取链表的长度。

这是一个简单的双向链表的实现，基本满足了在链表末尾添加节点、在指定位置插入节点、删除指定位置节点、获取指定位置节点值、修改指定位置节点值以及获取链表长度的需求。可以根据实际需求进行扩展和优化。