使用java实现链表的代码封装，要求包括提取元素，插入元素，删除元素，寻找元素，写到一个文件里面，使用静态类

以下是使用Java实现链表的代码封装，包括提取元素、插入元素、删除元素、寻找元素：

public class LinkedList<E> {
    
    private Node<E> head;
    private int size;
    
    public LinkedList() {
        head = null;
        size = 0;
    }
    
    public int size() {
        return size;
    }
    
    public boolean isEmpty() {
        return size == 0;
    }
    
    public void addFirst(E element) {
        head = new Node<>(element, head);
        size++;
    }
    
    public void addLast(E element) {
        if (isEmpty()) {
            addFirst(element);
        } else {
            Node<E> current = head;
            while (current.getNext() != null) {
                current = current.getNext();
            }
            current.setNext(new Node<>(element, null));
            size++;
        }
    }
    
    public E getFirst() {
        if (isEmpty()) {
            throw new NoSuchElementException("List is empty");
        }
        return head.getElement();
    }
    
    public E getLast() {
        if (isEmpty()) {
            throw new NoSuchElementException("List is empty");
        }
        Node<E> current = head;
        while (current.getNext() != null) {
            current = current.getNext();
        }
        return current.getElement();
    }
    
    public E removeFirst() {
        if (isEmpty()) {
            throw new NoSuchElementException("List is empty");
        }
        E element = head.getElement();
        head = head.getNext();
        size--;
        return element;
    }
    
    public E removeLast() {
        if (isEmpty()) {
            throw new NoSuchElementException("List is empty");
        }
        if (size() == 1) {
            return removeFirst();
        }
        Node<E> current = head;
        while (current.getNext().getNext() != null) {
            current = current.getNext();
        }
        E element = current.getNext().getElement();
        current.setNext(null);
        size--;
        return element;
    }
    
    public boolean contains(E element) {
        Node<E> current = head;
        while (current != null) {
            if (element.equals(current.getElement())) {
                return true;
            }
            current = current.getNext();
        }
        return false;
    }
    
    public void add(int index, E element) {
        if (index < 0 || index > size) {
            throw new IndexOutOfBoundsException("Invalid index");
        }
        if (index == 0) {
            addFirst(element);
        } else {
            Node<E> current = head;
            for (int i = 0; i < index - 1; i++) {
                current = current.getNext();
            }
            current.setNext(new Node<>(element, current.getNext()));
            size++;
        }
    }
    
    public E get(int index) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException("Invalid index");
        }
        Node<E> current = head;
        for (int i = 0; i < index; i++) {
            current = current.getNext();
        }
        return current.getElement();
    }
    
    public E remove(int index) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException("Invalid index");
        }
        if (index == 0) {
            return removeFirst();
        } else {
            Node<E> current = head;
            for (int i = 0; i < index - 1; i++) {
                current = current.getNext();
            }
            E element = current.getNext().getElement();
            current.setNext(current.getNext().getNext());
            size--;
            return element;
        }
    }
    
    public int indexOf(E element) {
        Node<E> current = head;
        int index = 0;
        while (current != null) {
            if (element.equals(current.getElement())) {
                return index;
            }
            current = current.getNext();
            index++;
        }
        return -1;
    }
    
    private static class Node<E> {
        
        private E element;
        private Node<E> next;
        
        public Node(E element, Node<E> next) {
            this.element = element;
            this.next = next;
        }
        
        public E getElement() {
            return element;
        }
        
        public Node<E> getNext() {
            return next;
        }
        
        public void setNext(Node<E> next) {
            this.next = next;
        }
    }
}

在这个实现中，我们使用了一个内部静态类`Node`来表示链表中的每个节点。这个类包含一个元素属性和一个指向下一个节点的指针属性。链表本身包含一个头节点属性和一个大小属性，用来记录链表中节点的数量。我们实现了以下方法：

- `size()`：返回链表中节点的数量。
- `isEmpty()`：检查链表是否为空。
- `addFirst(element)`：在链表的开头插入一个新节点。
- `addLast(element)`：在链表的末尾插入一个新节点。
- `getFirst()`：返回链表的第一个节点的元素。
- `getLast()`：返回链表的最后一个节点的元素。
- `removeFirst()`：删除链表中的第一个节点，并返回该节点的元素。
- `removeLast()`：删除链表中的最后一个节点，并返回该节点的元素。
- `contains(element)`：检查链表中是否包含给定的元素。
- `add(index, element)`：在链表的指定位置插入一个新节点。
- `get(index)`：返回链表中指定位置的节点的元素。
- `remove(index)`：删除链表中指定位置的节点，并返回该节点的元素。
- `indexOf(element)`：返回链表中给定元素的第一个出现位置的索引。

以上实现可以被封装到一个名为`LinkedList`的类中，该类使用泛型来允许存储任何类型的元素。