When compiling the LinkedList and Iterator class, the following error is being p
ID: 3604509 • Letter: W
Question
When compiling the LinkedList and Iterator class, the following error is being produced:
Note: LinkedList.java uses unchecked or unsafe operations.
Note: Recompile with -Xlint:unchecked for details.
Any suggestions?
public class LinkedList<T> {
Node<T> itsFirstNode;
Node<T> itsLastNode;
private int size;
public LinkedList() {
itsFirstNode = null;
itsLastNode = null;
size = 0;
}
public Iterator<T> getIterator() {
return new Iterator(this);
}
// THIS WILL NEED TO BE MODIFIED FOR DOUBLY-LINKED LIST
public void add(T element) {
Node<T> node = new Node(element);
if (itsFirstNode == null) {
itsFirstNode = node;
itsLastNode = node;
}
else {
itsLastNode.setNextNode(node);
node.setPriorNode(itsLastNode);//prior node set from new node to last node
itsLastNode = node;
}
size++;
}
// THIS WILL NEED TO BE MODIFIED FOR DOUBLY-LINKED LIST
public void add(T element, int index) {
int counter = 0;
Node<T> newNode = new Node(element);
Node<T> current = itsFirstNode;
while (current.getNextNode() != null ) {
if (counter == index - 1 )
break;
current = current.getNextNode();
counter++;
}
newNode.setNextNode(current.getNextNode());
Node<T> temp=current.getNextNode();//temp node is next node of current node
temp.setPriorNode(newNode);
current.setNextNode(newNode);
newNode.setPriorNode(current);
size++;
}
public T get(int index) {
int counter = 0;
Node<T> current = itsFirstNode;
while (current.getNextNode() != null ) {
if (counter == index)
break;
current = current.getNextNode();
counter++;
}
return current.getData();
}
// returns true if element is in the list, false if not
public boolean contains(T element) {
Node<T> head = itsFirstNode;
boolean res = false;
if (itsFirstNode == null)
return res;
else {
while (head != null) {
if(head.getData() == element){
res = true;
break;
}
head.setNextNode(head.getNextNode());
}
}
return res;
}
// returns the index of the element if it is in the list, -1 if not found
public int indexOf(T element) {
Node<T> head = itsFirstNode;
int index = 0;
if(itsFirstNode == null)
return -1;
else {
while (head != null) {
if (head.getData() == element) {
break;
}
head.setNextNode(head.getNextNode());
index++;
}
}
return index;
}
// returns an Iterator at the location of the element if it is in the list
// returns the null reference if the element is not found
/* we cannot get java iterator to an user defined object unless implementing iterable interface*/
/* therefore i changed return type to Node<T> and return reference to current node*/
public Node<T> iteratorAt(T element) {
Node<T> head = itsFirstNode;
if (itsFirstNode == null)
return null;
else {
while (head != null) {
if (head.getData() == element) {
break;
}
head.setNextNode(head.getNextNode());
}
}
return head;
}
public String toString() {
String returnVal = "";
Node<T> current = itsFirstNode;
if (size != 0 ) {
while (current.getNextNode() != null ) {
returnVal += current.toString();
returnVal += " ";
current = current.getNextNode();
}
returnVal += current.toString();
}
return returnVal;
} // end toString
class Node<T> {
private T data;
private Node<T> itsNext;
private Node<T> itsPrior;
public Node(T data) {
itsNext = null;
itsPrior = null;
this.data = data;
}
public T getData() {
return this.data;
}
public Node<T> getNextNode() {
return itsNext;
}
public Node<T> getPriorNode() {
return itsPrior;
}
public void setNextNode(Node<T> next) {
itsNext = next;
}
public void setPriorNode(Node<T> prior) {
itsPrior=prior;
}
public String toString() {
return data.toString();
}
} // end of Node<T>
} // end LinkedList<T> class
-------------------------------------------------------------------------------------------------------------------------------
public class Iterator<T> {
private LinkedList<T> myList;
private LinkedList<T>.Node<T> myCurrentNode;
public Iterator(LinkedList<T> list) {
myList = list;
myCurrentNode = myList.itsFirstNode;
}
// return true if there is a "next" element, otherwise returns false
public boolean hasNext() {
if (myCurrentNode != null)
return true;
return false;
}
// return true if there is a "prior" element, otherwise returns false
public boolean hasPrior() {
if (myCurrentNode.getNextNode() != null)
return true;
return false;
}
// returns the "next" node (really the current one) and
// moves the Iterator forward by one node
public T next() {
T data = myCurrentNode.getData();
myCurrentNode = myCurrentNode.getNextNode();
return data;
}
// returns the "prior" node (really the current one) and
// moves the Iterator backward by one node
public T prior() {
T data = myCurrentNode.getData();
myCurrentNode = myCurrentNode.getPriorNode();
return data;
}
// Sets this iterator to point to the last Node in the list
public void setToEnd() {
while (myCurrentNode.getNextNode() != null)
myCurrentNode = myCurrentNode.getNextNode();
}
} //end Iterator<T> ckass
Explanation / Answer
The problem is solved. I have modified LinkedList class and highlighed changes made
public class LinkedList<T> {
Node<T> itsFirstNode;
Node<T> itsLastNode;
private int size;
public LinkedList() {
itsFirstNode = null;
itsLastNode = null;
size = 0;
}
public Iterator<T> getIterator() {
return new Iterator<T>(this);
}
// THIS WILL NEED TO BE MODIFIED FOR DOUBLY-LINKED LIST
public void add(T element) {
Node<T> node = new Node<T>(element);
if (itsFirstNode == null) {
itsFirstNode = node;
itsLastNode = node;
}
else {
itsLastNode.setNextNode(node);
node.setPriorNode(itsLastNode);//prior node set from new node to last node
itsLastNode = node;
}
size++;
}
// THIS WILL NEED TO BE MODIFIED FOR DOUBLY-LINKED LIST
public void add(T element, int index) {
int counter = 0;
Node<T> newNode = new Node<T>(element);
Node<T> current = itsFirstNode;
while (current.getNextNode() != null ) {
if (counter == index - 1 )
break;
current = current.getNextNode();
counter++;
}
newNode.setNextNode(current.getNextNode());
Node<T> temp=current.getNextNode();//temp node is next node of current node
temp.setPriorNode(newNode);
current.setNextNode(newNode);
newNode.setPriorNode(current);
size++;
}
public T get(int index) {
int counter = 0;
Node<T> current = itsFirstNode;
while (current.getNextNode() != null ) {
if (counter == index)
break;
current = current.getNextNode();
counter++;
}
return current.getData();
}
// returns true if element is in the list, false if not
public boolean contains(T element) {
Node<T> head = itsFirstNode;
boolean res = false;
if (itsFirstNode == null)
return res;
else {
while (head != null) {
if(head.getData() == element){
res = true;
break;
}
head.setNextNode(head.getNextNode());
}
}
return res;
}
// returns the index of the element if it is in the list, -1 if not found
public int indexOf(T element) {
Node<T> head = itsFirstNode;
int index = 0;
if(itsFirstNode == null)
return -1;
else {
while (head != null) {
if (head.getData() == element) {
break;
}
head.setNextNode(head.getNextNode());
index++;
}
}
return index;
}
// returns an Iterator at the location of the element if it is in the list
// returns the null reference if the element is not found
/* we cannot get java iterator to an user defined object unless implementing iterable interface*/
/* therefore i changed return type to Node<T> and return reference to current node*/
public Node<T> iteratorAt(T element) {
Node<T> head = itsFirstNode;
if (itsFirstNode == null)
return null;
else {
while (head != null) {
if (head.getData() == element) {
break;
}
head.setNextNode(head.getNextNode());
}
}
return head;
}
public String toString() {
String returnVal = "";
Node<T> current = itsFirstNode;
if (size != 0 ) {
while (current.getNextNode() != null ) {
returnVal += current.toString();
returnVal += " ";
current = current.getNextNode();
}
returnVal += current.toString();
}
return returnVal;
} // end toString
class Node<T> {
private T data;
private Node<T> itsNext;
private Node<T> itsPrior;
public Node(T data) {
itsNext = null;
itsPrior = null;
this.data = data;
}
public T getData() {
return this.data;
}
public Node<T> getNextNode() {
return itsNext;
}
public Node<T> getPriorNode() {
return itsPrior;
}
public void setNextNode(Node<T> next) {
itsNext = next;
}
public void setPriorNode(Node<T> prior) {
itsPrior=prior;
}
public String toString() {
return data.toString();
}
} // end of Node<T>
} // end LinkedList<T> class
Related Questions
drjack9650@gmail.com
Navigate
Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.