I really need help in writing the code for this class. I DO NOT need the whole c
ID: 3746145 • Letter: I
Question
I really need help in writing the code for this class. I DO NOT need the whole class. I ONLY need the equals and toString methods in the DoublyLinkedBag class.Thank you!
The code for LinkedBag is as follows:
public class LinkedBag implements BagInterface{
private Node firstNode; // Reference to first node
private int numberOfEntries;
public LinkedBag(){
firstNode = null;
numberOfEntries = 0;
} // end default constructor
/** Sees whether this bag is empty.
* @return True if this bag is empty, or false if not.
* */
public boolean isEmpty(){
return numberOfEntries == 0;
} // end isEmpty
/** Gets the number of entries currently in this bag.
* @return The integer number of entries currently in this bag.
* */
public int getCurrentSize(){
return numberOfEntries;
} // end getCurrentSize
/** Adds a new entry to this bag.
* @param newEntry The object to be added as a new entry
* @return True if the addition is successful, or false if not.
**/
public boolean add(T newEntry) // OutOfMemoryError possible
{
// Add to beginning of chain:
Node newNode = new Node(newEntry);
newNode.next = firstNode; // Make new node reference rest of chain
// (firstNode is null if chain is empty)
firstNode = newNode; // New node is at beginning of chain
numberOfEntries++;
return true;
} // end add
/** Retrieves all entries that are in this bag.
* @return A newly allocated array of all the entries in this bag.
* */
public Object[] toArray() {
// The cast is safe because the new array contains null entries
@SuppressWarnings("unchecked")
T[] result = (T[])
new Object[numberOfEntries]; // Unchecked cast
int index = 0;
Node currentNode = firstNode;
while ((index < numberOfEntries) && (currentNode != null)){
result[index] = currentNode.data;
index++;
currentNode = currentNode.next;
} // end while
return result;
} // end toArray
/** Counts the number of times a given entry appears in this bag.
* @param anEntry The entry to be counted.
* @return The number of times anEntry appears in this bag.
* */
public int getFrequencyOf(T anEntry){
int frequency = 0;
int counter = 0;
Node currentNode = firstNode;
while ((counter < numberOfEntries) && (currentNode != null)){
if (anEntry.equals(currentNode.data)){
frequency++;
} // end if
counter++;
currentNode = currentNode.next;
} // end while
return frequency;
} // end getFrequencyOf
/** Tests whether this bag contains a given entry.
* @param anEntry The entry to locate.
* @return True if the bag contains anEntry, or false otherwise.
* */
public boolean contains(T anEntry){
boolean found = false;
Node currentNode = firstNode;
while (!found && (currentNode != null)){
if (anEntry.equals(currentNode.data))
found = true;
else
currentNode = currentNode.next;
} // end while
return found;
} // end contains
// Locates a given entry within this bag.
// Returns a reference to the node containing the entry, if located,
// or null otherwise.
private Node getReferenceTo(T anEntry){
boolean found = false;
Node currentNode = firstNode;
while (!found && (currentNode != null)){
if (anEntry.equals(currentNode.data))
found = true;
else
currentNode = currentNode.next;
} // end while
return currentNode;
} // end getReferenceTo
/** Removes all entries from this bag. */
public void clear(){
while (!isEmpty())remove();
} // end clear
/** Removes one unspecified entry from this bag, if possible.
* @return Either the removed entry, if the removal
* was successful, or null.
* */
public T remove(){
T result = null;
if (firstNode != null){
result = firstNode.data;
firstNode = firstNode.next; // Remove first node from chain
numberOfEntries--;
} // end if
return result;
} // end remove
/** Removes one occurrence of a given entry from this bag, if possible.
* @param anEntry The entry to be removed.
* @return True if the removal was successful, or false otherwise.
* */
public boolean remove(T anEntry) {
boolean result = false;
Node nodeN = getReferenceTo(anEntry);
if (nodeN != null){
nodeN.data = firstNode.data; // Replace located entry with entry in first node
firstNode = firstNode.next; // Remove first node
numberOfEntries--;
result = true;
} // end if
return result;
} // end remove
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
} // end Node
public T replace(T replacement) {
T t = null;
if (!isEmpty()) {
t = firstNode.data;
firstNode.data = replacement;
}
return t;
}
public void removeEvery(T anEntry) {
Node newNode = firstNode;
while(newNode != null) {
if(newNode.data.equals(anEntry)) {
remove(anEntry);
}
newNode = newNode.next;
}
}
@Override
public boolean equals(Object obj) {
}
} // end LinkedBag
I ONLY need the equals method and the toString in the DoublyLinkedBag class. Both the methods, equals and toString are marked with //TODO
The DoublyLinkedClass is as follows:
public class DoublyLinkedBag implements BagInterface
{
private DoublyLinkedNode firstNode; // Reference to first node
private int numberOfEntries;
public DoublyLinkedBag()
{
} // end default constructor
public boolean add(T newEntry)
{
} // end add
public T[] toArray()
{
} // end toArray
public boolean isEmpty()
{
} // end isEmpty
public int getCurrentSize()
{
} // end getCurrentSize
public int getFrequencyOf(T anEntry)
{
} // end getFrequencyOf
public boolean contains(T anEntry)
{
} // end contains
public void clear()
{
} // end clear
public T remove()
{
} // end remove
public boolean remove(T anEntry)
{;
} // end remove
public T replace(T replacement)
{
}
public void removeEvery(T anEntry)
{
}
/**
Override the equals method of Object class so that it returns true when the contents of two DoublyLinkedBags are same. Note that two equal DoublyLinkedBags contain the same number of entries, and each entry occurs in each DoublyLinkedBag the same number of times. I.e., the elements in two do not need to be in exact same location.
Before checking the contents inside this method make sure that the passed in object is not null, is of the same runtime class, and the lengths are same. If any of these fail you can return false. Otherwise, you base your return results on contents. (At the start you can also do the quick check if both refer to the same object in memory.)
*/
@Override
public boolean equals(Object obj)
{
//TODO
}
/**
Returns String representation of the items in this bag.
For example, it would return [A, B, C] if bag had three Strings "A", "B", and "C".
@return String representation of items in this bag enclosed in square brackets, separated by comma and a single space (see example above). You can rely on the fact that items' proper toString method was implemented. In this method ONLY if you need to you can use String class's methods. Also, ONLY in this method you can use fully qualified name for StringBuffer class, and use all of its methods.
*/
@Override
public String toString()
{
//TODO
}
return "[ ]"; // this is returned in case bag is empty.
}
// A class of nodes for a chain of doubly linked nodes.
private class DoublyLinkedNode
{
private T data; // Entry in bag
private DoublyLinkedNode next; // Link to next node
private DoublyLinkedNode prev; // Link to previous node
private DoublyLinkedNode(T dataPortion)
{
this(dataPortion, null, null);
} // end constructor
private DoublyLinkedNode(T dataPortion, DoublyLinkedNode nextNode,
DoublyLinkedNode previousNode)
{
data = dataPortion;
next = nextNode;
prev = previousNode;
} // end constructor
} // end DoublyLinkedNode
} // end DoublyLinkedBag
1. Part 1: Doubly Linked Chairn In a doubly linked chain, each node can reference the previous node as well as the next node. Below Figure I shows a doubly linked chain and its head referenceExplanation / Answer
Completed the implementations of toString() and equals() methods only, and left all other methods unchanged. Didn’t use toArray() method.
// DoublyLinkedBag.java
public class DoublyLinkedBag<T> implements BagInterface<T>
{
private DoublyLinkedNode firstNode; // Reference to first node
private int numberOfEntries;
public DoublyLinkedBag()
{
} // end default constructor
public boolean add(T newEntry)
{
return false;
} // end add
public T[] toArray()
{
return null;
} // end toArray
public boolean isEmpty()
{
return false;
} // end isEmpty
public int getCurrentSize()
{
return numberOfEntries;
} // end getCurrentSize
public int getFrequencyOf(T anEntry)
{
return numberOfEntries;
} // end getFrequencyOf
public boolean contains(T anEntry)
{
return false;
} // end contains
public void clear()
{
} // end clear
public T remove()
{
return null;
} // end remove
public boolean remove(T anEntry)
{
return false;
} // end remove
public T replace(T replacement)
{
return replacement;
}
public void removeEvery(T anEntry)
{
}
/**
* Override the equals method of Object class so that it returns true when
* the contents of two DoublyLinkedBags are same. Note that two equal
* DoublyLinkedBags contain the same number of entries, and each entry
* occurs in each DoublyLinkedBag the same number of times. I.e., the
* elements in two do not need to be in exact same location.
*
* Before checking the contents inside this method make sure that the passed
* in object is not null, is of the same runtime class, and the lengths are
* same. If any of these fail you can return false. Otherwise, you base your
* return results on contents. (At the start you can also do the quick check
* if both refer to the same object in memory.)
*/
@Override
public boolean equals(Object obj)
{
// ensuring that the object is not null and is an instance of
// DoubleLinkedBag
if (obj != null && obj instanceof DoublyLinkedBag) {
// type casting
DoublyLinkedBag<T> bag = (DoublyLinkedBag<T>) obj;
// checking if both bags contain same number of elements
if (numberOfEntries == bag.numberOfEntries) {
// getting a reference to first node in this bag
DoublyLinkedNode<T> node = firstNode;
// looping through all nodes in this bag, checking if all
// elements exist in other bag
for (int i = 0; i < numberOfEntries; i++) {
if (!bag.contains(node.data)) {
//current element does not exist in second bag
return false;
}
node = node.next;
}
//getting a reference to first node in other bag
node = bag.firstNode;
// looping through all nodes in other bag, checking if all
// elements exist in this bag
for (int i = 0; i < bag.numberOfEntries; i++) {
if (!this.contains(node.data)) {
//current element does not exist in first bag
return false;
}
node = node.next;
}
//all checks are passed, both bags are equal
return true;
}
}
return false;
}
/**
* Returns String representation of the items in this bag.
*
* For example, it would return [A, B, C] if bag had three Strings "A", "B",
* and "C".
*
* @return String representation of items in this bag enclosed in square
* brackets, separated by comma and a single space (see example
* above). You can rely on the fact that items' proper toString
* method was implemented. In this method ONLY if you need to you
* can use String class's methods. Also, ONLY in this method you can
* use fully qualified name for StringBuffer class, and use all of
* its methods.
*/
@Override
public String toString()
{
String data = "[";
// getting a reference to the first node
DoublyLinkedNode<T> node = firstNode;
// looping through all elements, appending to the String variable
for (int i = 0; i < numberOfEntries; i++) {
data += node.data;
if (i != numberOfEntries - 1) {
// appending a comma and space
data += ", ";
}
// moving to next node
node = node.next;
}
data += "]";
// returning the String in required format
return data;
}
// A class of nodes for a chain of doubly linked nodes.
class DoublyLinkedNode<T>
{
private T data; // Entry in bag
private DoublyLinkedNode next; // Link to next node
private DoublyLinkedNode prev; // Link to previous node
private DoublyLinkedNode(T dataPortion)
{
this(dataPortion, null, null);
} // end constructor
private DoublyLinkedNode(T dataPortion, DoublyLinkedNode nextNode,
DoublyLinkedNode previousNode)
{
data = dataPortion;
next = nextNode;
prev = previousNode;
} // end constructor
} // end DoublyLinkedNode
} // end DoublyLinkedBag