Java双向链表简单实现

Java链表的实现可以分为ILink接口、LinkImpl类、以及内部类Node类

ILink接口用于定义链表增删查改等一些面向外部的方法

LinkImpl类用于实现ILink中的方法类，连接整个l链表，并在内部定义内部类Node

Node类用于存放实际数据，data，以及前后结点

定义内部类的最大好处：就是可以直接访问内部类的私有属性

下面直接上传代码:

ILink接口

interface ILink{
    /**
     * 返回索引位置的值
     * @param index
     * @return
     */
    Object get(int index);
    /**
     * 添加元素
     * @param data
     * @return
     */
    boolean add(Object data);

    /**
     * 查找是否存在
     * @param data
     * @return
     */
    int contains(Object data);

    /**
     * 删除元素
     * @param data
     * @return
     */
    void remove(Object data);

    /**
     * 修改元素
     * @param index
     * @param newData
     * @return
     */
    Object set(int index, Object newData);

    /**
     * 链表清空
     */
    void clear();

    /**
     * 将链表转为数组
     * @return
     */
    Object[] toArray();

    /**
     * 链表长度
     * @return
     */
    int size();
    /**
     * 遍历链表
     */
    void printLink();
}

LinkImpl类

class LinkImpl implements ILink{
    private Node head;
    private Node last;
    private int size;
    /**
     * 真正的火车车厢，负责数据存储
     */
    private class Node{
        private Node prev;
        private Object data;
        private Node next;

        public Node(Node prev, Object data, Node next) {
            this.prev = prev;
            this.data = data;
            this.next = next;
        }
    }

    @Override
    public Object get(int index){
        if(!isIndex(index)){
            return null;
        }
        return node(index).data;
    }

    @Override
    public boolean add(Object data) {
        Node temp = this.last;
        Node newnode = new Node(temp,data,null);
        this.last = newnode;
        if(this.head == null){
            this.head = newnode;
        } else {
            temp.next = newnode;
        }
        this.size++;
        return true;
    }

    @Override
    public int contains(Object data) {
        if (data == null) {
            for (Node temp = this.head; temp != null; temp = temp.next) {
                int i = 0;
                if (temp.data == null) {
                    return i;
                }
                i++;
            }
        } else {
            for (Node temp = this.head; temp != null; temp = temp.next) {
                int i = 0;
                if (temp.data.equals(data)) {
                    return i;
                }
                i++;
            }
        }
        return -1;
    }

    @Override
    public void remove(Object data) {
        if (data == null){
            for (Node temp = this.head; temp!=null; temp=temp.next){
                if (temp.data == null){
                    unLink(temp);
                }
            }
        } else{
            for (Node temp = this.head; temp!=null; temp=temp.next) {
                if (temp.data.equals(data)) {
                    unLink(temp);
                }
            }
        }
    }

    @Override
    public Object set(int index, Object newData) {
        if (!isIndex(index)){
            return null;
        }
        Node node = node(index);
        Object num = node.data;
        node.data = newData;
        return num;
    }

    @Override
    public void clear() {
        for (Node temp = head; temp != null; ){
            Node node = temp.next;
            temp.data = null;
            temp = temp.prev = temp.next = null;
            temp = node;
            this.size--;
        }
    }

    @Override
    public Object[] toArray() {
        Object[] result = new Object[size];
        int i = 0;
        for (Node temp = head; temp!=null; temp=temp.next){
            result[i++] = temp.data;
        }
        return result;
    }

    @Override
    public int size() {
        return this.size;
    }

    @Override
    public void printLink() {
        Object[] data = this.toArray();
        for(Object o: data){
            System.out.println(o);
        }
    }

    /**
     * 仅供本方法使用,根据指定索引取得具体结点
     * @param index
     * @return
     */
    private Node node(int index){
        if(index < (size>>1)){
            Node temp = this.head;
            for (int i = 0; i<index; i++){
                temp = temp.next;
            }
            return temp;
        }
        Node temp = this.last;
        for (int i = size-1; i<index; i--){
            temp = temp.prev;
        }
        return temp;
    }

    private boolean isIndex(int index){
        return index>=0 && index < size;
    }

    private Object unLink(Node x){
        Object elementData = x.data;
        Node prev = x.prev;
        Node next = x.next;
        if(prev == null){
            this.head = next;
        } else {
            prev.next = next;
            x.prev = null;
        }
        if(next == null){
            this.last = prev;
        } else {
            next.prev = prev;
            x.next = null;
        }
        x.data = null;
        this.size--;
        return elementData;
    }
}

测试代码就不写了吧，应该都会的吧。

如有不足之处还请见谅