could you help my java programming homework, Add the following methods to the DoublyLinkedList class and test them by adding appropriate statements into DLLDriver. In other words, make a linkedlist, add to and remove from that list using the methods you wrote. Make sure to test all cases. private void addBefore(Node node, E newData) : adds newData immediately before the given node . private void removeBefore(Node node) : removes the node that comes immediately before the given node . private Node getNode(int i) : returns the address of the i-th node. The node immediately after the header sentinel is the 0-th node. public E get(int i): returns the data at the i-th position (in the i-th node). Write this method by making a call to the getNode method you have written above. public void add(int i, E newData): adds newData at the i-th position. Write this method by making calls to the getNode and addBefore methods you have written above. public E remove(int i) : removes the i-th node, and returns the data that is removed. Write this method by making calls to the getNode and removeBefore methods you have written above. public int indexOf(E target) : returns the position (index) of the target if the list contains the target , and returns -1 otherwise. Indices start with 0. (i.e. the index of the node immediately after the header node is 0.) public void removeEveryOther(): strating with the head node remove every other node of the linked list. For example, if the list contains (A, B, C, D, E, F) initially, the list will contain (B, D, F) after the removal operation. Write this method by walking through the list ONLY once. ------------------------------------------------------------------------------------- DublyLinkedList.java

public class DoublyLinkedList {

//---------------- nested Node class ----------------

/**

* Node of a doubly linked list, which stores a reference to its

* element and to both the previous and next node in the list.

*/

private static class Node {

/** The element stored at this node */

private E element; // reference to the element stored at this node

/** A reference to the preceding node in the list */

private Node prev; // reference to the previous node in the list

/** A reference to the subsequent node in the list */

private Node next; // reference to the subsequent node in the list

/**

* Creates a node with the given element and next node.

*

* @param e the element to be stored

* @param p reference to a node that should precede the new node

* @param n reference to a node that should follow the new node

*/

public Node(E e, Node p, Node n) {

element = e;

prev = p;

next = n;

}

// public accessor methods

/**

* Returns the element stored at the node.

* @return the element stored at the node

*/

public E getElement() {

return element;

}

/**

* Returns the node that precedes this one (or null if no such node).

* @return the preceding node

*/

public Node getPrev() { return prev; }

/**

* Returns the node that follows this one (or null if no such node).

* @return the following node

*/

public Node getNext() { return next; }

// Update methods

/**

* Sets the node's previous reference to point to Node n.

* @param p the node that should precede this one

*/

public void setPrev(Node p) { prev = p; }

/**

* Sets the node's next reference to point to Node n.

* @param n the node that should follow this one

*/

public void setNext(Node n) { next = n; }

} //----------- end of nested Node class -----------

// instance variables of the DoublyLinkedList

/** Sentinel node at the beginning of the list */

private Node header; // header sentinel

/** Sentinel node at the end of the list */

private Node trailer; // trailer sentinel

/** Number of elements in the list (not including sentinels) */

private int size = 0; // number of elements in the list

/** Constructs a new empty list. */

public DoublyLinkedList() {

header = new Node<>(null, null, null); // create header

trailer = new Node<>(null, header, null); // trailer is preceded by header

header.setNext(trailer); // header is followed by trailer

}

// public accessor methods

/**

* Returns the number of elements in the linked list.

* @return number of elements in the linked list

*/

public int size() { return size; }

/**

* Tests whether the linked list is empty.

* @return true if the linked list is empty, false otherwise

*/

public boolean isEmpty() { return size == 0; }

/**

* Returns (but does not remove) the first element of the list.

* @return element at the front of the list (or null if empty)

*/

public E first() {

if (isEmpty()) return null;

return header.getNext().getElement(); // first element is beyond header

}

/**

* Returns (but does not remove) the last element of the list.

* @return element at the end of the list (or null if empty)

*/

public E last() {

if (isEmpty()) return null;

return trailer.getPrev().getElement(); // last element is before trailer

}

// public update methods

/**

* Adds an element to the front of the list.

* @param e the new element to add

*/

public void addFirst(E e) {

addBetween(e, header, header.getNext()); // place just after the header

}

/**

* Adds an element to the end of the list.

* @param e the new element to add

*/

public void addLast(E e) {

addBetween(e, trailer.getPrev(), trailer); // place just before the trailer

}

/**

* Removes and returns the first element of the list.

* @return the removed element (or null if empty)

*/

public E removeFirst() {

if (isEmpty()) return null; // nothing to remove

return remove(header.getNext()); // first element is beyond header

}

/**

* Removes and returns the last element of the list.

* @return the removed element (or null if empty)

*/

public E removeLast() {

if (isEmpty()) return null; // nothing to remove

return remove(trailer.getPrev()); // last element is before trailer

}

// private update methods

/**

* Adds an element to the linked list in between the given nodes.

* The given predecessor and successor should be neighboring each

* other prior to the call.

*

* @param predecessor node just before the location where the new element is inserted

* @param successor node just after the location where the new element is inserted

*/

private void addBetween(E e, Node predecessor, Node successor) {

// create and link a new node

Node newest = new Node<>(e, predecessor, successor);

predecessor.setNext(newest);

successor.setPrev(newest);

size++;

}

/**

* Removes the given node from the list and returns its element.

* @param node the node to be removed (must not be a sentinel)

*/

private E remove(Node node) {

Node predecessor = node.getPrev();

Node successor = node.getNext();

predecessor.setNext(successor);

successor.setPrev(predecessor);

size--;

return node.getElement();

}

/**

* Produces a string representation of the contents of the list.

* This exists for debugging purposes only.

*/

public String toString() {

StringBuilder sb = new StringBuilder("(");

Node walk = header.getNext();

while (walk != trailer) {

sb.append(walk.getElement());

walk = walk.getNext();

if (walk != trailer)

sb.append(", ");

}

sb.append(")");

return sb.toString();

}

} //----------- end of DoublyLinkedList class ----------- ---------------------------------------------------------------------------------------- DLLDriver.java

public class DLLDriver {

public static void main(String[] args) {

DoublyLinkedList dll = new DoublyLinkedList<>();

dll.addFirst("A");

dll.addFirst("B");

dll.addLast("C");

dll.addFirst("D");

System.out.println(dll);

dll.removeFirst();

System.out.println("After removal of first: "+dll);

dll.removeLast();

System.out.println("After removal of last: "+dll);

}

}