LinkedList.java

package linkedlist;

public class LinkedList<T> {
    private Node<T> head;
    private int count;

    public LinkedList() {
        head = null;
        count = 0;
    }

    public int getCount() {
        return count;
    }

    public Node<T> getFirst() {
        return head;
    }

    public Node<T> getLast() {
        if(head == null) {
            return null;
        }
        Node<T> current = head;
        while(current.getNext() != null) {
            current = current.getNext();
        }
        return current;
    }

    public Node<T> getAt(int index) {
        if(index < 0 || index >= count) {
            throw new IndexOutOfBoundsException();
        }
        Node<T> current = head;
        for(int i = 0; i < index; i++) {
            current = current.getNext();
        }
        return current;
    }

    public boolean search(T data) {
        Node<T> current = head;
        while(current != null) {
            if(current.getData().equals(data)) {
                return true;
            }
            current = current.getNext();
        }
        return false;
    }

    public void clear() {
        head = null;
        count = 0;
    }

    public void insertFirst(T data) {
        var newNode = new Node<T>(data);
        newNode.setNext(head);
        head = newNode;
        count++;
    }

    public void insertLast(T data) {
        var lastNode = getLast();
        var newNode = new Node<T>(data);
        if(lastNode == null) {
            head = newNode;
        } else {
            lastNode.setNext(newNode);
        }
        count++;
    }

    public void insertAt(T data, int index) {
        if(index < 0 || index > count) {
            throw new IndexOutOfBoundsException();
        }
        if(index == 0) {
            insertFirst(data);
            return;
        }
        if(index == count) {
            insertLast(data);
            return;
        }

        var current = head;
        for(int i = 0; i < index - 1; i++) {
            current = current.getNext();
        }
        var newNode = new Node<T>(data);
        newNode.setNext(current.getNext());
        current.setNext(newNode);
        count++;
    }

    public void removeFirst() {
        if(head == null) {
            return;
        }
        head = head.getNext();
        count--;
    }

    public void removeLast() {
        if(head == null) {
            return;
        }
        if(head.getNext() == null) {
            head = null;
            count--;
            return;
        }
        var current = head;
        while(current.getNext().getNext() != null) {
            current = current.getNext();
        }
        current.setNext(null);
        count--;
    }

    public void removeAt(int index) {
        if(index < 0 || index >= count) {
            throw new IndexOutOfBoundsException();
        }

        if(index == 0) {
            removeFirst();
            return;
        }

        var current = head;
        for(int i = 0; i < index - 1; i++) {
            current = current.getNext();
        }
        current.setNext(current.getNext().getNext());
        count--;
    }
}