I have this class I am able to use to test my code: import java.util.Iterator; /
ID: 3769804 • Letter: I
Question
I have this class I am able to use to test my code:
import java.util.Iterator;
// This Class can be used to test the OrderedLinkedList class
public class LinkedListTest {
private class Courses implements Comparable<Courses>{
String rubric;
int number;
public Courses(String rub, int num) {
rubric = rub;
number = num;
}
public int compareTo(Courses other) {
if (rubric.compareTo(other.rubric) < 0)
return -1;
else if (rubric.compareTo(other.rubric) > 0)
return 1;
else
return number - other.number;
}
public String toString() {
return rubric + " " + number;
}
}
public static void main(String[] args) {
LinkedListTest ll = new LinkedListTest();
Courses listOfCourses[] = { ll.new Courses("COSC", 2436),
ll.new Courses("ITSE", 2409),
ll.new Courses("COSC", 1436),
ll.new Courses("ITSY", 1300),
ll.new Courses("ITSY", 1300),
ll.new Courses("COSC", 2436),
ll.new Courses("ITSE", 2417) };
OrderedLinkedList<Courses> orderedList = new OrderedLinkedList<Courses>();
for (int i = 0; i < listOfCourses.length; i++)
orderedList.findOrAdd(listOfCourses[i]);
Iterator<Courses> classIter = orderedList.iterator();
while(classIter.hasNext()) {
System.out.println(classIter.next());
} // There should be 5 courses listed in order
}
}
Here are the requirements: Implement a generic ordered linked list abstract data type. A unique feature of this generic linked list data structure is the findOrAdd method. This method searches the list for a previously added object with the same name, if one is found, the previous object is returned, if not the new object is added, in alphabetical order, to the list. Using ADTs from standard Java classes is not permitted. This is the code I have so far for the OrderedLinkedList:
import java.util.Iterator;
public class OrderedLinkedList< E extends Comparable< E>> implements Iterable <E>
{
private E first;
private E next;
private E last;
private E current;
private E temp;
private int size;
public OrderedLinkedList()
{
this.first = null;
this.next = null;
this.last = null;
this.current = null;
this.temp = null;
this.size = 0;
}
public E findOrAdd (E element)
{
E value = null;
Iterator <E> iter = this.iterator ();
if (this.first == null)
{
this.first = element;
this.current = element;
this.size++;
}
else
for (int i = 0; i < this.size; i++)
{
if (current.compareTo(element) > 0 && iter.hasNext() == false)
{
temp = this.first;
this.current = element;
this.next = temp;
this.size++;
}
else if (current.compareTo(element) < 0 && iter.hasNext() == true)
continue;
else if (current.compareTo(element) == 0)
value = element;
else if (current.compareTo(element) > 0)
{
temp = this.next;
this.current = element;
}
}
return value;
}
public Iterator <E> iterator ()
{
return new OrdListIterator <E> ();
}
private class OrdListIterator <E> implements Iterator <E>
{
private E nextNode;
public OrdListIterator ()
{
}
public boolean hasNext ()
{
return (next != null);
}
public E next ()
{
return (E) next;
}
public void remove ()
{
}
}
}
At this point, I am at a complete loss. It just keeps printing COSC 2436 infinitely.
OrderedLinkedList implements Iterable private OrdListlterator implements iterator +OrdListlteratorO +hasNextO: boolearn +nextO:E + remove0:void einte rface Iterable interface Iterator hasNext):boolean + iterator:Iterator + remove): voidExplanation / Answer
import java.util.*;
public class OrderedLinkedList< E extends Comparable< E>> implements Iterable <E>
{
private Node<E> start;
private Node<E> end;
private Node<E> current;
private int numberContents;
public OrderedLinkedList()
{
numberContents = 0;
}
public OrderedLinkedList(E element)
{
start = new Node<E>(element);
end = start;
numberContents = 1;
}
public boolean add(E element)
{
Node<E> newEnd = new Node<E>(element);
if (numberContents == 0 ) {
start = newEnd;
}
else {
end.setNext(newEnd);
newEnd.setPrevious(end);
current = newEnd;
end = newEnd;
}
numberContents++;
return true;
}
public int size() {
return numberContents;
}
public boolean isEmpty() {
return start == null;
}
public E first() {
if (isEmpty()) {
throw new NoSuchElementException();
}
current = start;
return start.getContents();
}
public E last() {
if (isEmpty()) {
throw new NoSuchElementException();
}
current = end;
return end.getContents();
}
public SortedSet<E> tailSet(E fromElement)
{
if (isEmpty())
{
throw new NullPointerException();
}
OrderedLinkedList oll = new OrderedLinkedList();
SortedSet<E> tail = oll.tailSet(fromElement+"");
return tail;
}
public SortedSet<E> headSet(E toElement)
{
if (isEmpty())
{
throw new NullPointerException();
}
OrderedLinkedList oll = new OrderedLinkedList();
SortedSet<E> head = oll.headSet(toElement+"");
return head;
}
public SortedSet<E> subSet(E fromElement, E toElement)
{
if (isEmpty())
{
throw new NullPointerException();
}
OrderedLinkedList oll = new OrderedLinkedList();
SortedSet<E> sub = oll.subSet(fromElement, toElement+"");
return sub;
}
public Iterator<E> iterator() {
return new Iterator<E>() {
E valueReturned;
private int counter = 0;
public boolean hasNext() {
if (counter >= numberContents){
return false;
}
else {
counter++;
return true;
}
}
public E next() {
valueReturned = current.getContents();
current = current.getNext();
return valueReturned;
}
public void remove() {
throw new UnsupportedOperationException();
}
};
}
public Comparator<E> comparator(){
return new Comparator<E>() {
public int compare(E obj1, E obj2) {
Node<E> node1 = (Node) obj1;
Node<E> node2 = (Node) obj2;
return node1.compareTo(node2.getContents());
}
public boolean equals(E obj) {
if (!(obj instanceof OrderedLinkedList)) {
return false;
}
Node<E> newNode = (Node) obj;
return current.getContents().equals(newNode.getContents());
}
};
}
}
import java.util.*;
public class Node<E> implements Comparable<E>
{
Node<E> next;
Node<E> previous;
E element;
public Node(E element)
{
this.element = element;
next = null;
previous = null;
}
public void setNext(Node<E> next)
{
this.next = next;
}
public void setPrevious(Node previous)
{
this.previous = previous;
}
public Node<E> getNext()
{
return next;
}
public Node<E> getPrevious()
{
return previous;
}
public E getContents()
{
return element;
}
public String toString()
{
return ""+ element;
}
public int compareTo(E obj)
{
Node<E> newNode = (Node<E>) obj;
int nodeComp = ((Comparable<E>)element).compareTo(newNode.getContents());
return nodeComp;
}
}