ArrayList.java

/**
 * Write a description of class Quack here.
 *
 * @author
 * @version
 */
public class ArrayList <T>{
    public class Node {
        public T data; // the data stored in this node
        public Node next; // a reference to the next node in the list

        /**
         * Default no-arg constructor
         * pre: none
         * post: data and next are null.
         */
        public Node() {}

        /**
         * Full-arg constructor
         * pre: none
         * post: data and next are as per the param
         */
        public Node(T data, Node next) {
            this.data = data;
            this.next = next;
        }

        /**
         * Only data constructor
         * pre: none
         * post: data is as per param and next is null.
         */
        public Node(T data) {
            this.data = data;
            this.next = null;
        }
    } // end of inner class

    public Node head = null;

    /**
     * This method adds the param element to the end of the list
     * pre: none, but makes no sense to add null data
     * post: adds another node to the linked list at the end. the definition of end is simply
     * the last node in a chain of nodes.
     */
    protected void append(T newData) {
        Node newNode = new Node(newData);
        if (isEmpty()) { // if list is empty, head is the newdata.
            head = newNode;
        } else {
            Node current = head;
            while (current.next != null) {
                current = current.next;
            }
            current.next = newNode;
        }
    }
    
    /**
     * This method adds the param element to the end of the list
     * pre: none, but makes no sense to add null data
     * post: adds another node to the linked list at the end. the definition of end is simply
     * the last node in a chain of nodes.
     */
    protected void add(T newData) {
        Node newNode = new Node(newData);
        if (isEmpty()) { // if list is empty, head is the newdata.
            head = newNode;
        } else {
            Node current = head;
            while (current.next != null) {
                current = current.next;
            }
            current.next = newNode;
        }
    }
    
    /**
     * this method removes an element at a spesificied index.
     * pre: none
     * post: returns type objecty with the object removed from the param index.
     */
    protected T remove(int index) {
        // out of bounds case
        if (index < 0 || index >= this.size()) {
            System.out.println("Index out of bounds. You get a null return now :(.");
            return null;
        }
        // null array case
        if (this.isEmpty()) return null;
        
        // finding and linking the previous and next node together (of the target node)
        Node current = head;
        T toRemove;

        
        if (index == 0) { // if removing the head
            toRemove = current.data;
            head = current.next;
        } else { // all other cases.
            // chat gpt has helped with a promt along the lines of write some code that iterates
            //through a list of nodes.
            Node previous = null;
            for (int i = 0; i < index; i++) {
                previous = current;
                current = current.next;
            }
            toRemove = current.data;
            previous.next = current.next;
        }

        return toRemove;
    }

    /**
     * This method adds another element at the specified index and everything is moved accordingly
     * pre: Object and int param respectively.
     * post: adds a new node at the specified index linking the following nodes to the new one.
     */
    protected void insert(T newData, int index) {
        if (index < 0 || index > size()) {
            System.out.println("The index is out of bounds.");
            return;
        }
        Node newNode = new Node(newData);
        if (index == 0) {
            newNode.next = head;
            head = newNode;
        } else {
            Node current = head;
            Node previous = null;
            int currentIndex = 0;
            while (currentIndex < index) {
                previous = current;
                current = current.next;
                currentIndex++;
            }
            previous.next = newNode;
            newNode.next = current;
        }
    }

    /**
     * This method deletes the element at the specified index.
     * pre: type int param
     * post: deletes the element at the param.
     */
    protected void delete(int index) {
        if (index < 0 || index >= size()) {
            System.out.println("Invalid index for deletion.");
            return;
        }
        if (index == 0) { // Deleting the first element
            head = head.next;
        } else {
            Node current = head;
            Node previous = null;
            int currentIndex = 0;
            while (currentIndex < index) {
                previous = current;
                current = current.next;
                currentIndex++;
            }
            previous.next = current.next;
        }
    }
    
    /**
     * this method clears the array.
     * pre: none
     * post: the array is now empty, it is null.
     */
    public void clear() {
        this.remove(0);
        this.head = null;
    }

    /**
     * This method returns the element at the specified index
     * pre: type int param
     * post: returns type Object with the element at the index
     */
    protected T get(int index) {
        if (index < 0 || index >= size()) {
            System.out.println("Invalid index.");
            return null;
        }
        return getHelper(head, index).data;
    }

    /**
     * Helper method that gets the node at the index value and returns that node.
     */
    private Node getHelper(Node front, int index) {
        if (index == 0) {
            return front;
        }
        return getHelper(front.next, index - 1);
    }

    /**
     * This method returns the size of the linked list recursively using a helper method
     * pre: none
     * post: returns type int with the number of nodes.
     */
    public int size() {
        return sizeHelper(head);
    }

    /**
     * Private helper method to recursively find the length / size of the linked list
     */
    private int sizeHelper(Node front) {
        if (front == null) {
            return 0;
        }
        return 1 + sizeHelper(front.next);
    }

    /**
     * This method returns a string with all of the data values of the nodes
     * pre: none
     * post: returns type String with the data values of the nodes.
     */
    public String toString() {
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append("Data: [");
        Node current = head;
        while (current != null) {
            stringBuilder.append(current.data);
            if (current.next != null) {
                stringBuilder.append(", ");
            }
            current = current.next;
        }
        stringBuilder.append("]");
        return stringBuilder.toString();
    }

    /**
     * This method checks if the first node is null or not which means if it is empty or not
     * pre: none
     * post: returns type boolean indicating if it is empty
     */
    public boolean isEmpty() {
        return head == null;
    }

    /**
     * Returns the index of an object in the linked list, and returns -1 if it does not exist
     * pre: object type param indicating the element you want the index of
     * post: returns with int of either the index number or -1 (not found)
     */
    protected int indexOf(T target) {
        Node current = head;
        int index = 0;
        while (current != null) {
            if (current.data.equals(target)) {
                return index;
            }
            current = current.next;
            index++;
        }
        return -1;
    }

    /**
     * Override this method
     * - I am pretty sure that wh
     * This method should determine whether two of the same class type objects are the same.
     */
    public boolean equals(Object other) {
        if (this == other) {
            return true;
        }
        if (!(other instanceof ArrayList)) {
            return false;
        }
        ArrayList that = (ArrayList) other;
        if (this.size() != that.size()) {
            return false;
        }

        Node thisNode = this.head;
        Node thatNode = that.head;
        while (thisNode != null) {
            if (!thisNode.data.equals(thatNode.data)) {
                return false;
            }
            thisNode = thisNode.next;
            thatNode = thatNode.next;
        }
        return true;
    }
    
}