java单向链表基本实现

单向链表基本格式

package linked_list;

import java.util.Comparator;
import java.util.Iterator;
import java.util.Objects;
import java.util.function.Consumer;

public class SingleLinkedList<E> implements Iterable<E> {
    private int size = 0;
    private Node<E> head = new Node<>();

    /**
     * 插入数据
     *
     * @param data
     */
    public void add(E data) {
        addLast(data);
    }

    /**
     * 在指定位置插入指定数据
     *
     * @param index
     * @param data
     */
    public void add(int index, E data) {
        if (index > size) {
            throw new IndexOutOfBoundsException(size);
        } else if (index == size) {
            addLast(data);
        } else if (index == 0) {
            addFirst(data);
        } else {
            Node<E> node = new Node<>(data);
            Node<E> temp = head;
            int i = 1;
            while (i < index) {
                temp = temp.next;
                i++;
            }
            node.next = temp.next;
            temp.next = node;
        }
        size++;
    }

    /**
     * 头插
     */
    public void addFirst(E data) {
        Node<E> node = new Node<>(data);
        if (size != 0) {
            node.next = head;
        }
        head = node;
        size++;
    }

    /**
     * 尾插
     *
     * @param data
     */
    public void addLast(E data) {
        if (size == 0) {
            head = new Node<>(data);
        } else {
            Node<E> temp = head;
            while (temp.next != null) {
                temp = temp.next;
            }
            temp.next = new Node<>(data);
        }
        size++;
    }

    /**
     * 删除指定索引位置
     *
     * @param index
     */
    public void remove(int index) {
        if (index >= size) {
            throw new IndexOutOfBoundsException(size);
        }
        if (index == 0) {
            head = head.next;
            return;
        }
        Node<E> node = head;
        // 因为0是head，所以从1开始，等于index是获取当前节点，
        // 删除中间节点需要将当前节点的上一个节点的next指向当前节点的下一个节点
        int i = 1;
        while (i < index) {
            node = node.next;
            i++;
        }
        node.next = node.next.next;
        size--;
    }

    /**
     * 根据元素删除遇到的第一个元素
     *
     * @param data
     */
    public void remove(E data) {
        if (head.data.equals(data)) {
            head = head.next;
            return;
        }
        Node<E> node = head.next;
        Node<E> pre = head;
        while (node.next != null) {
            boolean equals = node.data.equals(data);
            if (equals) {
                pre.next = node.next;
                break;
            } else {
                pre = pre.next;
                node = node.next;
            }
        }
        size--;
    }

    /**
     * 根据下标获取数据
     *
     * @param index
     * @return
     */
    public E get(int index) {
        if (index >= size) {
            throw new IndexOutOfBoundsException(size);
        }
        if (index == 0) {
            return head.data;
        }
        Node<E> temp = head.next;
        int i = 1;
        while (i != index) {
            temp = temp.next;
            i++;
        }
        return temp.data;
    }

    /**
     * 获取链表长度
     * @return
     */
    public int size(){
        return size;
    }
    @Override
    public Iterator<E> iterator() {
        return new Iterator<E>() {
            Node<E> pre = head;

            // 是否有下一个节点
            @Override
            public boolean hasNext() {
                return pre != null;
            }

            // 返回当前节点并且指向下一个节点
            @Override
            public E next() {
                E value = pre.data;
                pre = pre.next;
                return value;
            }
        };
    }

    public void loop(Consumer<E> consumer) {
        Node<E> temp = head;
        while (temp != null) {
            consumer.accept(temp.data);
            temp = temp.next;
        }
    }

    private static class Node<E> {
        private E data;
        private Node<E> next;

        public Node() {
        }

        public Node(E data) {
            this.data = data;
        }

        @Override
        public String toString() {
            return data.toString();
        }
    }
}

    }

    public Node(E data) {
        this.data = data;
    }

    @Override
    public String toString() {
        return data.toString();
    }
}

}