Read everything carefully! To Be Done: - Open Resizable ArrayBag and rename as A
ID: 3885299 • Letter: R
Question
Read everything carefully!
To Be Done:
- Open Resizable ArrayBag and rename as ArraySet.java
- Global replace of ‘Bag’ with ‘Set’
- Re-write ‘add’ methods to prevent the addition of duplicate entries, using either the ‘contains’ method or ‘getIndexOf’
- We can remove ‘getFrequencyOf’ method.
- Update the test class
– replace the ‘testGetFrequencyOf’ method and add a method to verify that duplicates can’t be added.
Here's a pic of the full assignment:
Here I have attached the source code needed to adjust edit for this assignment. USE THE FOLLOWING SOURCE:
---------------------------------------------------------------------------------------------
ResizableArrayBag.java
---------------------------------------------------------------------------------------------
---------------------------------------------------------------------------------------------------------------------
BagInterface.java
---------------------------------------------------------------------------------------------------------------------
---------------------------------------------------------------------------------------------------------------------
SetInterface.java (You may not need this class, however if you do it's here)
---------------------------------------------------------------------------------------------------------------------
---------------------------------------------------------------------------------------------------------------------
ResizableArrayBagDemo.java
---------------------------------------------------------------------------------------------------------------------
Problem: Complete Programming Project 2, page 92. This will require that you use the 'SetInterface' of Chapter 1 instead of the 'Baglnterface' of Chapter 2. You will add the methods of the interface to the existing class. Then, develop a test application that will verify the functionality of the solution. You may wish to look at the example test applications. As always, be sure to test ALL methods of the class and interface. Requirements: You will submit the lab following the normal lab procedures. Make sure to label your lab folder as fille 2YourLastName To Be Done: Open Resizable ArrayBag and rename as ArraySet.java Global replace of 'Bag' with 'Set' Re-write ‘add, methods to prevent the addition of duplicate entries, using either the 'contains' method or 'getIndexOf - We can remove 'getFrequencyOf" method. Update the test class - replace the 'testGetFrequencyOf method and add a method to verify that duplicates can't be added.Explanation / Answer
// Below is the complete code
import java.util.Arrays;
public final class ArraySet<T> implements SetInterface<T>
{
private T[] Set; // Cannot be final due to doubling
private int numberOfEntries;
private boolean initialized = false;
private static final int DEFAULT_CAPACITY = 25; // Initial capacity of Set
private static final int MAX_CAPACITY = 10000;
/** Creates an empty Set whose initial capacity is 25. */
public ArraySet()
{
this(DEFAULT_CAPACITY);
} // end default constructor
/** Creates an empty Set having a given initial capacity.
@param initialCapacity The integer capacity desired. */
public ArraySet(int initialCapacity)
{
checkCapacity(initialCapacity);
// The cast is safe because the new array contains null entries
@SuppressWarnings("unchecked")
T[] tempSet = (T[])new Object[initialCapacity]; // Unchecked cast
Set = tempSet;
numberOfEntries = 0;
initialized = true;
} // end constructor
/** Creates a Set containing given entries.
@param contents An array of objects. */
public ArraySet(T[] contents)
{
checkCapacity(contents.length);
Set = Arrays.copyOf(contents, contents.length);
numberOfEntries = contents.length;
initialized = true;
} // end constructor
/** Adds a new entry to this Set.
@param newEntry The object to be added as a new entry.
@return True. */
public boolean add(T newEntry)
{
checkInitialization();
if (isArrayFull())
{
doubleCapacity();
} // end if
if(!contains(newEntry)){
Set[numberOfEntries] = newEntry;
numberOfEntries++;
}
return true;
} // end add
/** Retrieves all entries that are in this Set.
@return A newly allocated array of all the entries in this Set. */
public T[] toArray()
{
checkInitialization();
// The cast is safe because the new array contains null entries.
@SuppressWarnings("unchecked")
T[] result = (T[])new Object[numberOfEntries]; // Unchecked cast
for (int index = 0; index < numberOfEntries; index++)
{
result[index] = Set[index];
} // end for
return result;
} // end toArray
/** Sees whether this Set is empty.
@return True if this Set is empty, or false if not. */
public boolean isEmpty()
{
return numberOfEntries == 0;
} // end isEmpty
/** Gets the current number of entries in this Set.
@return The integer number of entries currently in this Set. */
public int getCurrentSize()
{
return numberOfEntries;
} // end getCurrentSize
/** Counts the number of times a given entry appears in this Set.
@param anEntry The entry to be counted.
@return The number of times anEntry appears in this ba. */
/*
public int getFrequencyOf(T anEntry)
{
checkInitialization();
int counter = 0;
for (int index = 0; index < numberOfEntries; index++)
{
if (anEntry.equals(Set[index]))
{
counter++;
} // end if
} // end for
return counter;
} // end getFrequencyOf
*/
/** Tests whether this Set contains a given entry.
@param anEntry The entry to locate.
@return True if this Set contains anEntry, or false otherwise. */
public boolean contains(T anEntry)
{
checkInitialization();
return getIndexOf(anEntry) > -1; // or >= 0
} // end contains
/** Removes all entries from this Set. */
public void clear()
{
while (!isEmpty())
remove();
} // end clear
/** Removes one unspecified entry from this Set, if possible.
@return Either the removed entry, if the removal
was successful, or null. */
public T remove()
{
checkInitialization();
T result = removeEntry(numberOfEntries - 1);
return result;
} // end remove
/** Removes one occurrence of a given entry from this Set.
@param anEntry The entry to be removed.
@return True if the removal was successful, or false if not. */
public boolean remove(T anEntry)
{
checkInitialization();
int index = getIndexOf(anEntry);
T result = removeEntry(index);
return anEntry.equals(result);
} // end remove
// Locates a given entry within the array Set.
// Returns the index of the entry, if located,
// or -1 otherwise.
// Precondition: checkInitialization has been called.
private int getIndexOf(T anEntry)
{
int where = -1;
boolean found = false;
int index = 0;
while (!found && (index < numberOfEntries))
{
if (anEntry.equals(Set[index]))
{
found = true;
where = index;
} // end if
index++;
} // end while
// Assertion: If where > -1, anEntry is in the array Set, and it
// equals Set[where]; otherwise, anEntry is not in the array.
return where;
} // end getIndexOf
// Removes and returns the entry at a given index within the array.
// If no such entry exists, returns null.
// Precondition: 0 <= givenIndex < numberOfEntries.
// Precondition: checkInitialization has been called.
private T removeEntry(int givenIndex)
{
T result = null;
if (!isEmpty() && (givenIndex >= 0))
{
result = Set[givenIndex]; // Entry to remove
int lastIndex = numberOfEntries - 1;
Set[givenIndex] = Set[lastIndex]; // Replace entry to remove with last entry
Set[lastIndex] = null; // Remove reference to last entry
numberOfEntries--;
} // end if
return result;
} // end removeEntry
// Returns true if the array Set is full, or false if not.
private boolean isArrayFull()
{
return numberOfEntries >= Set.length;
} // end isArrayFull
// Doubles the size of the array Set.
// Precondition: checkInitialization has been called.
private void doubleCapacity()
{
int newLength = 2 * Set.length;
checkCapacity(newLength);
Set = Arrays.copyOf(Set, newLength);
} // end doubleCapacity
// Throws an exception if the client requests a capacity that is too large.
private void checkCapacity(int capacity)
{
if (capacity > MAX_CAPACITY)
throw new IllegalStateException("Attempt to create a Set whose capacity exceeds " +
"allowed maximum of " + MAX_CAPACITY);
} // end checkCapacity
// Throws an exception if receiving object is not initialized.
private void checkInitialization()
{
if (!initialized)
throw new SecurityException ("Uninitialized object used " +
"to call an ArraySet method.");
} // end checkInitialization
} // end ResizableArraySet
/* BagInterface.java*/
public interface BagInterface<T>
{
/** Gets the current number of entries in this bag.
@return The integer number of entries currently in the bag. */
public int getCurrentSize();
/** Sees whether this bag is empty.
@return True if the bag is empty, or false if not. */
public boolean isEmpty();
/** 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);
/** Removes one unspecified entry from this bag, if possible.
@return Either the removed entry, if the removal.
was successful, or null. */
public T remove();
/** Removes one occurrence of a given entry from this bag.
@param anEntry The entry to be removed.
@return True if the removal was successful, or false if not. */
public boolean remove(T anEntry);
/** Removes all entries from this bag. */
public void clear();
/** 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 the bag. */
public int getFrequencyOf(T anEntry);
/** Tests whether this bag contains a given entry.
@param anEntry The entry to locate.
@return True if the bag contains anEntry, or false if not. */
public boolean contains(T anEntry);
/** Retrieves all entries that are in this bag.
@return A newly allocated array of all the entries in the bag.
Note: If the bag is empty, the returned array is empty. */
public T[] toArray();
// public <T> T[] toArray(); // Alternate
// public Object[] toArray(); // Alternate
/** Creates a new bag that combines the contents of this bag
and anotherBag.
@param anotherBag The bag that is to be added.
@return A combined bag. */
// public BagInterface<T> union(BagInterface<T> anotherBag);
/** Creates a new bag that contains those objects that occur
in both this bag and anotherBag.
@param anotherBag The bag that is to be compared.
@return A combined bag. */
// public BagInterface<T> intersection(BagInterface<T> anotherBag);
/** Creates a new bag of objects that would be left in this bag
after removing those that also occur in anotherBag.
@param anotherBag The bag that is to be removed.
@return A combined bag. */
// public BagInterface<T> difference(BagInterface<T> anotherBag);
} // end BagInterface
/* SetInterface.java */
public interface SetInterface<T>
{
public int getCurrentSize();
public boolean isEmpty();
/** Adds a new entry to this set, avoiding duplicates.
@param newEntry The object to be added as a new entry.
@return True if the addition is successful, or
false if the item is already in the set. */
public boolean add(T newEntry);
/** Removes a specific entry from this set, if possible.
@param anEntry The entry to be removed.
@return True if the removal was successful, or false if not. */
public boolean remove(T anEntry);
public T remove();
public void clear();
public boolean contains(T anEntry);
public T[] toArray();
} // end SetInterface
/*ResizableArraySetDemo.java*/
public class ResizableArraySetDemo
{
public static void main(String[] args)
{
// A Set whose initial capacity is small
SetInterface<String> aSet = new ArraySet<>(3);
testIsEmpty(aSet, true);
System.out.println("Adding to the Set more strings than its initial capacity.");
String[] contentsOfSet = {"A", "D", "B", "A", "C", "A", "D"};
testAdd(aSet, contentsOfSet);
testIsEmpty(aSet, false);
String[] testStrings2 = {"A", "B", "C", "D", "Z"};
//testFrequency(aSet, testStrings2);
testContains(aSet, testStrings2);
// Removing strings
String[] testStrings3 = {"", "B", "A", "C", "Z"};
testRemove(aSet, testStrings3);
System.out.println(" Clearing the Set:");
aSet.clear();
testIsEmpty(aSet, true);
displaySet(aSet);
} // end main
// Tests the method add.
private static void testAdd(SetInterface<String> aSet, String[] content)
{
System.out.print("Adding to the Set: ");
for (int index = 0; index < content.length; index++)
{
aSet.add(content[index]);
System.out.print(content[index] + " ");
} // end for
System.out.println();
displaySet(aSet);
} // end testAdd
// Tests the two remove methods.
private static void testRemove(SetInterface<String> aSet, String[] tests)
{
for (int index = 0; index < tests.length; index++)
{
String aString = tests[index];
if (aString.equals("") || (aString == null))
{
// Test remove()
System.out.println(" Removing a string from the Set:");
String removedString = aSet.remove();
System.out.println("remove() returns " + removedString);
}
else
{
// Test remove(aString)
System.out.println(" Removing "" + aString + "" from the Set:");
boolean result = aSet.remove(aString);
System.out.println("remove("" + aString + "") returns " + result);
} // end if
displaySet(aSet);
} // end for
} // end testRemove
// Tests the method isEmpty.
// correctResult indicates what isEmpty should return.
private static void testIsEmpty(SetInterface<String> aSet, boolean correctResult)
{
System.out.print("Testing isEmpty with ");
if (correctResult)
System.out.println("an empty Set:");
else
System.out.println("a Set that is not empty:");
System.out.print("isEmpty finds the Set ");
if (correctResult && aSet.isEmpty())
System.out.println("empty: OK.");
else if (correctResult)
System.out.println("not empty, but it is empty: ERROR.");
else if (!correctResult && aSet.isEmpty())
System.out.println("empty, but it is not empty: ERROR.");
else
System.out.println("not empty: OK.");
System.out.println();
} // end testIsEmpty
// Tests the method getFrequencyOf.
/*
private static void testFrequency(SetInterface<String> aSet, String[] tests)
{
System.out.println(" Testing the method getFrequencyOf:");
for (int index = 0; index < tests.length; index++)
System.out.println("In this Set, the count of " + tests[index] +
" is " + aSet.getFrequencyOf(tests[index]));
} // end testFrequency
*/
// Tests the method contains.
private static void testContains(SetInterface<String> aSet, String[] tests)
{
System.out.println(" Testing the method contains:");
for (int index = 0; index < tests.length; index++)
System.out.println("Does this Set contain " + tests[index] +
"? " + aSet.contains(tests[index]));
} // end testContains
// Tests the method toArray while displaying the Set.
private static void displaySet(SetInterface<String> aSet)
{
System.out.println("The Set contains " + aSet.getCurrentSize() +
" string(s), as follows:");
Object[] SetArray = aSet.toArray();
for (int index = 0; index < SetArray.length; index++)
{
System.out.print(SetArray[index] + " ");
} // end for
System.out.println();
} // end displaySet
} // end ResizableArraySetDemo
Related Questions
drjack9650@gmail.com
Navigate
Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.