双链表实现增删改查

定义一个接口：

public interface MyList<T> extends Iterator<T>{
    /*新增一个元素*/
    void add(T element);
    
    /*删除相同元素*/
    void delete(T element);
    
    /*根据索引删除元素*/
    void delete(int index);
    
    /*
     * 将指定索引位置的元素替换成新元素
     */
    void update(int index,T newElment);
    
    /*
     * 当前列表中是否含有target这个元素
     */
    boolean contains(T target);
    
    /*
     * 返回指定索引处的元素
     */
    Object at(int index); 
    
    /*
     * 根据元素查找对应索引
     */
    int indexof(T element);
}

定义双链表元素属性：

public class ListNode {
    private Object data;//真实元素数据
    private ListNode next;//元素后继
    private ListNode pre;//元素前继
    
    public ListNode(Object data) {
        super();
        this.data = data;
    }

    public Object getData() {
        return data;
    }

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

    public ListNode getNext() {
        return next;
    }

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

    public ListNode getPre() {
        return pre;
    }

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

双链表实现类：

public class DoubleLinkList<T> implements MyList<T>{
    private ListNode first = new ListNode(null);
    private ListNode last = new ListNode(null);
    private int size;
    
    public DoubleLinkList() {
        first.setNext(last);
        last.setPre(first);
    }
    
    @Override
    public void add(T element) {
        ListNode newnode = new ListNode(element);
        last.getPre().setNext(newnode);
        newnode.setNext(last); 
        newnode.setPre(last.getPre());
        last.setPre(newnode);
        size++;
    }

    @Override
    public void delete(T element) {
         ListNode p = first.getNext();
         while(p != last) {
             if(p.getData().equals(element)) {
                    p.getPre().setNext(p.getNext());
                    p.getNext().setPre(p.getPre());
                    
                    p.setNext(null);
                    p.setPre(null);
                    size--;
                     break;//注意
                 }
             p=p.getNext();
         }
        
    }

    /*
     * 根据索引删除元素
     */
    @Override
    public void delete(int index) {
        if (index<0||index>=size) {
            return;
        }
        int i=0;//指针指向的节点的索引
        ListNode p = first.getNext();
        
        while (p != last) {
            if (i==index) {
                
                p.getPre().setNext(p.getNext());
                p.getNext().setPre(p.getPre());
                
                p.setNext(null);
                p.setPre(null);
                size--;
                break;//注意这里
            }
            p = p.getNext();
            i++;
        }
    }

    @Override
    public void update(int index, T newElment) {
        int i=0;
        ListNode p = first.getNext();

        
        while (p != last) {
            if (i==index) {
                p.setData(newElment);
            }
            p = p.getNext();
            i++;
        }
        
    }

    @Override
    public boolean contains(T target) {
        int i = 0;
        ListNode p = first.getNext();
        
        while (p != last) {
            if (p.getData().equals(target)) {
                return true;
            }
            p = p.getNext();
            i++;
        }
        return false;
    }

    @Override
    public T at(int index) { 
        if (index<0||index>=size) {
            return null;
        }
        int i=0;
        ListNode p = first.getNext();
        
        while (p != last) {
            if (i==index) {
                return (T) p.getData();
            }
            p = p.getNext();
            i++;
        }
        return null;
    }

    @Override
    public int indexof(T element) {
        int i=0;
        ListNode p = first.getNext();
        
        while (p != last) {
            if (p.getData().equals(element)) {
                return i;
            }
            p = p.getNext();
            i++;
        }
        return -1;
    }

    public String toString() {
        StringBuilder sBuilder = new StringBuilder("[");
        ListNode p = first.getNext(); 
        while(p != last) {
            sBuilder.append(p.getData());
            if (p.getNext() != last) 
                sBuilder.append(",");
                p = p.getNext();
        }
        sBuilder.append("]");
        return sBuilder.toString();
        
    }

    private ListNode now = first;
    
    @Override
    public boolean hasNext() {
        
        return now.getNext()!=last;
    }

    @Override
    public T next() {
        ListNode next = now.getNext();
        now = now.getNext();
        return (T)next.getData();
    }
}

单元测试类：

class DoubleLinkListTest {

    DoubleLinkList list = new DoubleLinkList();
    
    @BeforeEach
    void setUp() throws Exception {

        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");
        list.add("f");
    }

//    @Test
//    void testDoubleLinkList() {
//        
//    }

    @Test
    void testAdd() {
        System.out.println("add");
        System.out.println(list);
    }

    @Test
    void testDeleteObject() {
        list.delete("b");
        System.out.println("deleteobject");
        System.out.println(list);
    
    }

    @Test
    void testDeleteInt() {
        System.out.println("deleteindex");
        list.delete(0);
        System.out.println(list);
    }

    @Test
    void testUpdate() {
        System.out.println("update");
        list.update(1, "a");
        System.out.println(list);
    }

    @Test
    void testContains() {
        System.out.println("Contains");
        Boolean i=list.contains("b");
        System.out.println(i);
    }

    @Test
    void testAt() {
        System.out.println("at");
        Object i=list.at(4);
        System.out.println(i);
    }

    @Test
    void testIndexof() {
        System.out.println("indexof");
        int i=list.indexof("f");
        System.out.println(i);
    }
    
    @Test
    void iter() {
        System.out.println("Iterator");
        while (list.hasNext()) {
            System.out.println(list.next());
            
        }
    }

}