Beginner Help please... class LList implements ListInterface { private Node firstNode; // reference to first node private int numberOfEntries; public LList() { clear(); } // end default constructor public final void clear() // note the final method { firstNode = null; numberOfEntries = 0; } // end clear public void add(T newEntry) { Node newNode = new Node(newEntry); if (isEmpty()) { firstNode = newNode; } else // add to end of nonempty list { Node lastNode = getNodeAt(numberOfEntries); lastNode.next = newNode; // make last node reference new node } // end if numberOfEntries++; } // end add public boolean add(int newPosition, T newEntry) { boolean isSuccessful = true; if ((newPosition >= 1) && (newPosition <= numberOfEntries + 1)) { Node newNode = new Node(newEntry); if (newPosition == 1) // case 1 { newNode.setNextNode(firstNode); firstNode = newNode; } else // case 2: list is not empty { // and newPosition > 1 Node nodeBefore = getNodeAt(newPosition - 1); Node nodeAfter = nodeBefore.getNextNode(); newNode.setNextNode(nodeAfter); nodeBefore.setNextNode(newNode); } // end if numberOfEntries++; } else { isSuccessful = false; } return isSuccessful; } // end add public T remove(int givenPosition) { T result = null; // return value if ((givenPosition >= 1) && (givenPosition <= numberOfEntries)) { assert !isEmpty(); if (givenPosition == 1) // case 1: remove first entry { result = firstNode.getData(); // save entry to be removed firstNode = firstNode.getNextNode(); } else // case 2: not first entry { Node nodeBefore = getNodeAt(givenPosition - 1); Node nodeToRemove = nodeBefore.getNextNode(); Node nodeAfter = nodeToRemove.getNextNode(); nodeBefore.setNextNode(nodeAfter); result = nodeToRemove.getData(); // save entry to be removed } // end if numberOfEntries--; } // end if return result; // return removed entry, or // null if operation fails } // end remove public boolean contains(T anEntry) { boolean found = false; Node currentNode = firstNode; while (!found && (currentNode != null)) { if (anEntry.equals(currentNode.getData())) { found = true; } else { currentNode = currentNode.getNextNode(); } } // end while return found; } // end contains public T getEntry(int givenPosition) { T result = null; // result to return if ((givenPosition >= 1) && (givenPosition <= numberOfEntries)) { assert !isEmpty(); result = getNodeAt(givenPosition).getData(); } // end if return result; } // end getEntry public boolean replace(int givenPosition, T newEntry) { boolean isSuccessful = true; if ((givenPosition >= 1) && (givenPosition <= numberOfEntries)) { assert !isEmpty(); Node desiredNode = getNodeAt(givenPosition); desiredNode.setData(newEntry); } else { isSuccessful = false; } return isSuccessful; } // end replace public int getLength() { return numberOfEntries; } public boolean isEmpty() { boolean result; if (numberOfEntries == 0) // or getLength() == 0 { assert firstNode == null; result = true; } else { assert firstNode != null; result = false; } // end if return result; } // end isEmpty public T[] toArray() { // the cast is safe because the new array contains null entries @SuppressWarnings("unchecked") T[] result = (T[]) new Object[numberOfEntries]; int index = 0; Node currentNode = firstNode; while ((index < numberOfEntries) && (currentNode != null)) { result[index] = currentNode.getData(); currentNode = currentNode.getNextNode(); index++; } // end while return result; } // end toArray private Node getNodeAt(int givenPosition) { assert (firstNode != null) && (1 <= givenPosition) && (givenPosition <= numberOfEntries); Node currentNode = firstNode; // traverse the chain to locate the desired node for (int counter = 1; counter < givenPosition; counter++) { currentNode = currentNode.getNextNode(); } assert currentNode != null; return currentNode; } // end getNodeAt private class Node { private T data; // entry in bag private Node next; // link to next node private Node(T dataPortion) { this(dataPortion, null); } // end constructor private Node(T dataPortion, Node nextNode) { data = dataPortion; next = nextNode; } // end constructor private T getData() { return data; } // end getData private void setData(T newData) { data = newData; } // end setData private Node getNextNode() { return next; } // end getNextNode private void setNextNode(Node nextNode) { next = nextNode; } // end setNextNode } // end Node /** Build a string representation of the list * * @return a string showing the state of the list */ public String toString() { String result = "{ "; Node currentNode = firstNode; while (currentNode != null) { result = result + "<" + currentNode.data + "> "; currentNode = currentNode.next; } result = result + "}"; return result; } /** Display the list with indices one to a line * This will correctly display an infinite list, * whereas the toString() method will never return * */ public void display() { int index = 1; Node currentNode = firstNode; while (currentNode != null) { System.out.println(index + ":" + currentNode.getData()); currentNode = currentNode.getNextNode(); index++; } } // end display /** Check to see if two lists are the same. * @param aList another linked list to check this list against * @return true if all the items in this list and the other list are equals */ public boolean equals(LList aList) { boolean isEqual = false; // result of comparison of lists Node currOne = firstNode; Node currTwo = aList.firstNode; int counter; if (numberOfEntries == aList.numberOfEntries) { // lists have equal lengths, so traverse both and compare items as you go: // (NOTE: loop is skipped if lists are empty) while ((currOne != null) && (currOne.getData()).equals(currTwo.getData())) { currOne = currOne.getNextNode(); currTwo = currTwo.getNextNode(); } // end while isEqual = currOne == null; } else // lists have unequal lengths { isEqual = false; } return isEqual; } // end equals /********************************************************************* * * METHODS TO BE COMPLETED * ***********************************************************************/ public int countEntry(T anEntry) { int count = 0; // CODE TO BE COMPLETED return count; } public boolean removeSecond(T anEntry) { boolean found = false; // CODE TO BE COMPLETED return found; } }