Java Question: I need to add an iterator to LinkedDropOtuStackQueue class. The e
ID: 3840569 • Letter: J
Question
Java Question:
I need to add an iterator to LinkedDropOtuStackQueue class.
The example is for the LinkedList.java is as follows:
package jsjf;
import jsjf.exceptions.*;
import java.util.*;
/**
* LinkedList represents a linked implementation of a list.
*
* @author Java Foundations
* @version 4.0
*/
public class LinkedList implements ListADT, Iterable
{
protected int count;
protected LinearNode head, tail;
protected int modCount;
/**
* Creates an empty list.
*/
public LinkedList()
{
count = 0;
head = tail = null;
modCount = 0;
}
public void addElement(T element)
{
LinearNode node = new LinearNode(element);
if (isEmpty())
head = node;
else
tail.setNext(node);
tail = node;
count++;
}
/**
* Removes the first element in this list and returns a reference
* to it. Throws an EmptyCollectionException if the list is empty.
*
* @return a reference to the first element of this list
* @throws EmptyCollectionException if the list is empty
*/
public T removeFirst() throws EmptyCollectionException
{
if (isEmpty())
throw new EmptyCollectionException("LinkedList");
T result = head.getElement();
head = head.getNext();
count--;
if (isEmpty())
tail = null;
return result;
}
/**
* Removes the last element in this list and returns a reference
* to it. Throws an EmptyCollectionException if the list is empty.
*
* @return the last element in this list
* @throws EmptyCollectionException if the list is empty
*/
public T removeLast() throws EmptyCollectionException
{
if (isEmpty())
throw new EmptyCollectionException("LinkedList");
LinearNode current = head;
LinearNode current1=null;
while (current != tail){
current1=current;
current = current.getNext();
// make current points to next element
}
T a=tail.getElement();
tail=current1;
if(tail==null)
head=null;
else
tail.setNext(null);
if(tail==null)
head=null;
else
tail.setNext(null);
count--;
return a;
}
/**
* Removes the first instance of the specified element from this
* list and returns a reference to it. Throws an EmptyCollectionException
* if the list is empty. Throws a ElementNotFoundException if the
* specified element is not found in the list.
*
* @param targetElement the element to be removed from the list
* @return a reference to the removed element
* @throws EmptyCollectionException if the list is empty
* @throws ElementNotFoundException if the target element is not found
*/
public T remove(T targetElement) throws EmptyCollectionException,
ElementNotFoundException
{
if (isEmpty())
throw new EmptyCollectionException("LinkedList");
boolean found = false;
LinearNode previous = null;
LinearNode current = head;
while (current != null && !found)
if (targetElement.equals(current.getElement()))
found = true;
else
{
previous = current;
current = current.getNext();
}
if (!found)
throw new ElementNotFoundException("LinkedList");
if (size() == 1) // only one element in the list
head = tail = null;
else if (current.equals(head)) // target is at the head
head = current.getNext();
else if (current.equals(tail)) // target is at the tail
{
tail = previous;
tail.setNext(null);
}
else // target is in the middle
previous.setNext(current.getNext());
count--;
modCount++;
return current.getElement();
}
/**
* Returns the first element in this list without removing it.
*
* @return the first element in this list
* @throws EmptyCollectionException if the list is empty
*/
public T first() throws EmptyCollectionException
{
if(isEmpty())
{
throw new EmptyCollectionException("LinkedList");
}
return head.getElement();
}
/**
* Returns the last element in this list without removing it.
*
* @return the last element in this list
* @throws EmptyCollectionException if the list is empty
*/
public T last() throws EmptyCollectionException
{
if(isEmpty())
{
throw new EmptyCollectionException("LinkedList");
}
return tail.getElement();
}
/**
* Returns true if the specified element is found in this list and
* false otherwise. Throws an EmptyCollectionException if the list
* is empty.
*
* @param targetElement the element that is sought in the list
* @return true if the element is found in this list
* @throws EmptyCollectionException if the list is empty
*/
public boolean contains(T targetElement) throws EmptyCollectionException
{
if(isEmpty())
{
throw new EmptyCollectionException("LinkedList");
}
return (count==0);
}
/**
* Returns true if this list is empty and false otherwise.
*
* @return true if the list is empty, false otherwise
*/
public boolean isEmpty()
{
return (count==0);
}
/**
* Returns the number of elements in this list.
*
* @return the number of elements in the list
*/
public int size()
{
return count;
}
/**
* Returns a string representation of this list.
*
* @return a string representation of the list
*/
public String toString()
{
String result = ""; // initialize it to empty string
LinearNode t = head; // start from top
while (t != null) // iterate until it reaches the end of the list (end of list is when current == null)
{
result = result + (t.getElement()).toString() + " "; // append it's value to result string
t = t.getNext(); // make current points to next element
}
return result; // return result string
}
/**
* Returns an iterator for the elements in this list.
*
* @return an iterator over the elements of the list
*/
public Iterator iterator()
{
return new LinkedListIterator();
}
/**
* LinkedIterator represents an iterator for a linked list of linear nodes.
*/
private class LinkedListIterator implements Iterator
{
private int iteratorModCount; // the number of elements in the collection
private LinearNode current; // the current position
/**
* Sets up this iterator using the specified items.
*
* @param collection the collection the iterator will move over
* @param size the integer size of the collection
*/
public LinkedListIterator()
{
current = head;
iteratorModCount = modCount;
}
/**
* Returns true if this iterator has at least one more element
* to deliver in the iteration.
*
* @return true if this iterator has at least one more element to deliver
* in the iteration
* @throws ConcurrentModificationException if the collection has changed
* while the iterator is in use
*/
public boolean hasNext() throws ConcurrentModificationException
{
if (iteratorModCount != modCount)
throw new ConcurrentModificationException();
return (current != null);
}
/**
* Returns the next element in the iteration. If there are no
* more elements in this iteration, a NoSuchElementException is
* thrown.
*
* @return the next element in the iteration
* @throws NoSuchElementException if the iterator is empty
*/
public T next() throws ConcurrentModificationException
{
if (!hasNext())
throw new NoSuchElementException();
T result = current.getElement();
current = current.getNext();
return result;
}
/**
* The remove operation is not supported.
*
* @throws UnsupportedOperationException if the remove operation is called
*/
public void remove() throws UnsupportedOperationException
{
throw new UnsupportedOperationException();
}
}
}
Can you please Add an iterator to the LinkedDropOutStack.java as there is an iterator in the LinkedList.java class:
package jsjf;
import jsjf.exceptions.*;
import java.util.EmptyStackException;
/**
* Represents a linked implementation of a stack.
*
* @author Java Foundations
* @version 4.0
*/
public class LinkedDropOutStack implements StackADT
{
private int count;
private LinearNode top;
private int limit = 5;
/**
* Creates an empty stack.
*/
public LinkedDropOutStack()
{
count = 0;
top = null;
}
/**
* Adds the specified element to the top of this stack.
* @param element element to be pushed on stack
*/
public void push(T element)
{
if (count < limit) {
LinearNode temp = new LinearNode(element);
temp.setNext(top);
top = temp;
}
else if (count == limit){
LinearNode temp = new LinearNode(element);
if (isEmpty())
throw new EmptyCollectionException("stack");
T result = top.getElement();
top = top.getNext();
temp.setNext(top);
top = temp;
}
count++;
}
/**
* Removes the element at the top of this stack and returns a
* reference to it.
* @return element from top of stack
* @throws EmptyCollectionException if the stack is empty
*/
public T pop() throws EmptyCollectionException
{
if (isEmpty())
throw new EmptyCollectionException("stack");
T result = top.getElement();
top = top.getNext();
count--;
return result;
}
/**
* Returns a reference to the element at the top of this stack.
* The element is not removed from the stack.
* @return element on top of stack
* @throws EmptyCollectionException if the stack is empty
*/
public T peek() throws EmptyCollectionException
{
if (isEmpty())
throw new EmptyCollectionException("Stack");
else
return top.getElement(); // temp
}
/**
* Returns true if this stack is empty and false otherwise.
* @return true if stack is empty
*/
public boolean isEmpty()
{
if (count == 0) {
return true; // temp
}
else
return false;
}
/**
* Returns the number of elements in this stack.
* @return number of elements in the stack
*/
public int size()
{
// To be completed as a Programming Project
return count - 1; // temp
}
/**
* Returns a string representation of this stack.
* @return string representation of the stack
*/
public String toString()
{
String result = "";
LinearNode values = top;
while (values != null){
result += values.getElement().toString() + " ";
values = values.getNext();
}
return result; // temp
}
}
Thanks
Explanation / Answer
package jsjf;
import jsjf.LinkedList.LinkedListIterator;
import jsjf.exceptions.*;
import java.util.ConcurrentModificationException;
import java.util.EmptyStackException;
import java.util.Iterator;
import java.util.NoSuchElementException;
/**
* Represents a linked implementation of a stack.
*
* @author Java Foundations
* @version 4.0
*/
public class LinkedDropOutStack implements StackADT
{
private int count;
private LinearNode top;
private int limit = 5;
/**
* Creates an empty stack.
*/
public LinkedDropOutStack()
{
count = 0;
top = null;
}
/**
* Adds the specified element to the top of this stack.
* @param element element to be pushed on stack
*/
public void push(T element)
{
if (count < limit) {
LinearNode temp = new LinearNode(element);
temp.setNext(top);
top = temp;
}
else if (count == limit){
LinearNode temp = new LinearNode(element);
if (isEmpty())
throw new EmptyCollectionException("stack");
T result = top.getElement();
top = top.getNext();
temp.setNext(top);
top = temp;
}
count++;
}
/**
* Removes the element at the top of this stack and returns a
* reference to it.
* @return element from top of stack
* @throws EmptyCollectionException if the stack is empty
*/
public T pop() throws EmptyCollectionException
{
if (isEmpty())
throw new EmptyCollectionException("stack");
T result = top.getElement();
top = top.getNext();
count--;
return result;
}
/**
* Returns a reference to the element at the top of this stack.
* The element is not removed from the stack.
* @return element on top of stack
* @throws EmptyCollectionException if the stack is empty
*/
public T peek() throws EmptyCollectionException
{
if (isEmpty())
throw new EmptyCollectionException("Stack");
else
return top.getElement(); // temp
}
/**
* Returns true if this stack is empty and false otherwise.
* @return true if stack is empty
*/
public boolean isEmpty()
{
if (count == 0) {
return true; // temp
}
else
return false;
}
/**
* Returns the number of elements in this stack.
* @return number of elements in the stack
*/
public int size()
{
// To be completed as a Programming Project
return count - 1; // temp
}
/**
* Returns a string representation of this stack.
* @return string representation of the stack
*/
public String toString()
{
String result = "";
LinearNode values = top;
while (values != null){
result += values.getElement().toString() + " ";
values = values.getNext();
}
return result; // temp
}
public Iterator iterator()
{
return new StackIterator();
}
/**
* LinkedIterator represents an iterator for a linked list of linear nodes.
*/
private class StackIterator implements Iterator
{
private int iteratorModCount; // the number of elements in the collection
private LinearNode current; // the current position
/**
* Sets up this iterator using the specified items.
*
* @param collection the collection the iterator will move over
* @param size the integer size of the collection
*/
public StackIterator()
{
current = top;
iteratorModCount = count;
}
/**
* Returns true if this iterator has at least one more element
* to deliver in the iteration.
*
* @return true if this iterator has at least one more element to deliver
* in the iteration
* @throws ConcurrentModificationException if the collection has changed
* while the iterator is in use
*/
public boolean hasNext() throws ConcurrentModificationException
{
if (iteratorModCount != count)
throw new ConcurrentModificationException();
return (current != null);
}
/**
* Returns the next element in the iteration. If there are no
* more elements in this iteration, a NoSuchElementException is
* thrown.
*
* @return the next element in the iteration
* @throws NoSuchElementException if the iterator is empty
*/
public T next() throws ConcurrentModificationException
{
if (!hasNext())
throw new NoSuchElementException();
T result = current.getElement();
current = current.getNext();
return result;
}
/**
* The remove operation is not supported.
*
* @throws UnsupportedOperationException if the remove operation is called
*/
public void remove() throws UnsupportedOperationException
{
throw new UnsupportedOperationException();
}
}
}
Related Questions
drjack9650@gmail.com
Navigate
Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.