datalab2
This commit is contained in:
parent
c18ba394ae
commit
ec083c6254
BIN
DataLabs/lab2/ArrayBag.class
Normal file
BIN
DataLabs/lab2/ArrayBag.class
Normal file
Binary file not shown.
102
DataLabs/lab2/ArrayBag.java
Normal file
102
DataLabs/lab2/ArrayBag.java
Normal file
@ -0,0 +1,102 @@
|
||||
public class ArrayBag<T> implements BagInterface<T> {
|
||||
|
||||
private T[] t;
|
||||
private int size;
|
||||
private int capacity;
|
||||
private static final int DEFAULT_CAPACITY = 25;
|
||||
|
||||
|
||||
public ArrayBag(int capacity) {
|
||||
this.size = 0;
|
||||
this.capacity = capacity;
|
||||
this.t = (T[]) new Object[capacity];
|
||||
|
||||
}
|
||||
public ArrayBag() {
|
||||
this(DEFAULT_CAPACITY);
|
||||
}
|
||||
|
||||
public int getCurrentSize() {
|
||||
return size;
|
||||
}
|
||||
|
||||
public boolean isEmpty() {
|
||||
return size == 0;
|
||||
}
|
||||
|
||||
public boolean add(T newEntry) {
|
||||
if (isFull()) {
|
||||
return false;
|
||||
}
|
||||
t[size] = newEntry;
|
||||
size++;
|
||||
return true;
|
||||
}
|
||||
|
||||
public T remove() {
|
||||
if (isEmpty()) {
|
||||
return null;
|
||||
}
|
||||
T temp = t[size - 1];
|
||||
t[size - 1] = null;
|
||||
size--;
|
||||
return temp;
|
||||
}
|
||||
|
||||
public boolean remove(T anEntry) {
|
||||
int index = getIndexOf(anEntry);
|
||||
if (index >= 0) {
|
||||
t[index] = t[size - 1];
|
||||
t[size - 1] = null;
|
||||
size--;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
public void clear() {
|
||||
while(!isEmpty()) {
|
||||
t[size - 1] = null;
|
||||
size--;
|
||||
}
|
||||
}
|
||||
|
||||
public int getFrequencyOf(T anEntry) {
|
||||
int temp = 0;
|
||||
for(int i = 0; i < size; i++) {
|
||||
if(t[i] == anEntry) {
|
||||
temp++;
|
||||
}
|
||||
}
|
||||
return temp;
|
||||
}
|
||||
|
||||
public boolean contains(T anEntry) {
|
||||
if(getFrequencyOf(anEntry) > 0) {
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
public T[] toArray() {
|
||||
T[] newArray = (T[]) new Object[size];
|
||||
for(int i = 0; i < size; i++) {
|
||||
newArray[i] = t[i];
|
||||
}
|
||||
return newArray;
|
||||
}
|
||||
|
||||
private int getIndexOf(T anEntry) {
|
||||
for(int i = 0; i < size; i++) {
|
||||
if(t[i] == anEntry) {
|
||||
return i;
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
public boolean isFull() {
|
||||
return capacity == size;
|
||||
}
|
||||
}
|
||||
241
DataLabs/lab2/ArrayBagDemo.java
Normal file
241
DataLabs/lab2/ArrayBagDemo.java
Normal file
@ -0,0 +1,241 @@
|
||||
/** A demonstration of the class ArrayBag
|
||||
@author Frank M. Carrano
|
||||
@version 4.0
|
||||
*/
|
||||
public class ArrayBagDemo
|
||||
{
|
||||
public static void main(String[] args)
|
||||
{
|
||||
String[] contentsOfBag = {"A", "A", "B", "A", "C", "A"};
|
||||
// Tests on an empty bag
|
||||
BagInterface<String> aBag = new ArrayBag<>(contentsOfBag.length);
|
||||
System.out.println("Testing an initially empty bag:");
|
||||
testIsEmpty(aBag, true);
|
||||
String[] testStrings1 = {"", "B"};
|
||||
testFrequency(aBag, testStrings1);
|
||||
testContains(aBag, testStrings1);
|
||||
testRemove(aBag, testStrings1);
|
||||
// Adding strings
|
||||
System.out.println("Adding " + contentsOfBag.length +
|
||||
" strings to an initially empty bag with" +
|
||||
" the capacity to hold more than " +
|
||||
contentsOfBag.length + " strings:");
|
||||
testAdd(aBag, contentsOfBag);
|
||||
|
||||
// Tests on a bag that is not empty
|
||||
testIsEmpty(aBag, false);
|
||||
String[] testStrings2 = {"A", "B", "C", "D", "Z"};
|
||||
testFrequency(aBag, testStrings2);
|
||||
testContains(aBag, testStrings2);
|
||||
|
||||
// Removing strings
|
||||
String[] testStrings3 = {"", "B", "A", "C", "Z"};
|
||||
testRemove(aBag, testStrings3);
|
||||
System.out.println("\nClearing the bag:");
|
||||
aBag.clear();
|
||||
testIsEmpty(aBag, true);
|
||||
displayBag(aBag);
|
||||
|
||||
// Filling an initially empty bag to capacity
|
||||
System.out.println("\nTesting an initially empty bag that " +
|
||||
" will be filled to capacity:");
|
||||
aBag = new ArrayBag<String>(7);
|
||||
String[] contentsOfBag2 = {"A", "B", "A", "C", "B", "C", "D"};
|
||||
testAdd(aBag, contentsOfBag2);
|
||||
|
||||
System.out.println("Try to add another string to the full bag:");
|
||||
if (aBag.add("another string"))
|
||||
System.out.println("Added a string beyond the bag's capacity: ERROR!");
|
||||
else
|
||||
System.out.println("The method add cannot add another string: OK");
|
||||
} // end main
|
||||
|
||||
// Tests the method add.
|
||||
private static void testAdd(BagInterface<String> aBag, String[] content)
|
||||
{
|
||||
System.out.print("Adding ");
|
||||
for (int index = 0; index < content.length; index++)
|
||||
{
|
||||
aBag.add(content[index]);
|
||||
System.out.print(content[index] + " ");
|
||||
} // end for
|
||||
System.out.println();
|
||||
|
||||
displayBag(aBag);
|
||||
} // end testAdd
|
||||
// Tests the two remove methods.
|
||||
private static void testRemove(BagInterface<String> aBag, String[] tests)
|
||||
{
|
||||
for (int index = 0; index < tests.length; index++)
|
||||
{
|
||||
String aString = tests[index];
|
||||
if (aString.equals("") || (aString == null))
|
||||
{
|
||||
// test remove()
|
||||
System.out.println("\nRemoving a string from the bag:");
|
||||
String removedString = aBag.remove();
|
||||
System.out.println("remove() returns " + removedString);
|
||||
}
|
||||
else
|
||||
{
|
||||
// test remove(aString)
|
||||
System.out.println("\nRemoving \"" + aString + "\" from the bag:");
|
||||
boolean result = aBag.remove(aString);
|
||||
System.out.println("remove(\"" + aString + "\") returns " + result);
|
||||
} // end if
|
||||
|
||||
displayBag(aBag);
|
||||
} // end for
|
||||
} // end testRemove
|
||||
// Tests the method isEmpty.
|
||||
// correctResult indicates what isEmpty should return.
|
||||
private static void testIsEmpty(BagInterface<String> aBag, boolean correctResult)
|
||||
{
|
||||
System.out.print("Testing isEmpty with ");
|
||||
if (correctResult)
|
||||
System.out.println("an empty bag:");
|
||||
else
|
||||
System.out.println("a bag that is not empty:");
|
||||
|
||||
System.out.print("isEmpty finds the bag ");
|
||||
if (correctResult && aBag.isEmpty())
|
||||
System.out.println("empty: OK.");
|
||||
else if (correctResult)
|
||||
System.out.println("not empty, but it is empty: ERROR.");
|
||||
else if (!correctResult && aBag.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(BagInterface<String> aBag, String[] tests)
|
||||
{
|
||||
System.out.println("\nTesting the method getFrequencyOf:");
|
||||
for (int index = 0; index < tests.length; index++)
|
||||
{
|
||||
String aString = tests[index];
|
||||
if (!aString.equals("") && (aString != null))
|
||||
{
|
||||
System.out.println("In this bag, the count of " + tests[index] +
|
||||
" is " + aBag.getFrequencyOf(tests[index]));
|
||||
} // end if
|
||||
} // end for
|
||||
} // end testFrequency
|
||||
|
||||
// Tests the method contains.
|
||||
private static void testContains(BagInterface<String> aBag, String[] tests)
|
||||
{
|
||||
System.out.println("\nTesting the method contains:");
|
||||
for (int index = 0; index < tests.length; index++)
|
||||
{
|
||||
String aString = tests[index];
|
||||
if (!aString.equals("") && (aString != null))
|
||||
{
|
||||
System.out.println("Does this bag contain " + tests[index] +
|
||||
"? " + aBag.contains(tests[index]));
|
||||
} // end if
|
||||
} // end for
|
||||
} // end testContains
|
||||
// Tests the method toArray while displaying the bag.
|
||||
private static void displayBag(BagInterface<String> aBag)
|
||||
{
|
||||
System.out.println("The bag contains " + aBag.getCurrentSize() +
|
||||
" string(s), as follows:");
|
||||
Object[] bagArray = aBag.toArray();
|
||||
for (int index = 0; index < bagArray.length; index++)
|
||||
{
|
||||
System.out.print(bagArray[index] + " ");
|
||||
} // end for
|
||||
|
||||
System.out.println();
|
||||
} // end displayBag
|
||||
} // end ArrayBagDemo
|
||||
/*
|
||||
Testing an initially empty bag:
|
||||
Testing isEmpty with an empty bag:
|
||||
isEmpty finds the bag empty: OK.
|
||||
|
||||
|
||||
Testing the method getFrequencyOf:
|
||||
In this bag, the count of B is 0
|
||||
|
||||
Testing the method contains:
|
||||
Does this bag contain B? false
|
||||
|
||||
Removing a string from the bag:
|
||||
remove() returns null
|
||||
The bag contains 0 string(s), as follows:
|
||||
|
||||
|
||||
Removing "B" from the bag:
|
||||
remove("B") returns false
|
||||
The bag contains 0 string(s), as follows:
|
||||
|
||||
Adding 6 strings to an initially empty bag with the capacity to hold more than 6 strings:
|
||||
Adding A A B A C A
|
||||
The bag contains 6 string(s), as follows:
|
||||
A A B A C A
|
||||
Testing isEmpty with a bag that is not empty:
|
||||
isEmpty finds the bag not empty: OK.
|
||||
|
||||
|
||||
Testing the method getFrequencyOf:
|
||||
In this bag, the count of A is 4
|
||||
In this bag, the count of B is 1
|
||||
In this bag, the count of C is 1
|
||||
In this bag, the count of D is 0
|
||||
In this bag, the count of Z is 0
|
||||
|
||||
Testing the method contains:
|
||||
Does this bag contain A? true
|
||||
Does this bag contain B? true
|
||||
Does this bag contain C? true
|
||||
Does this bag contain D? false
|
||||
Does this bag contain Z? false
|
||||
|
||||
Removing a string from the bag:
|
||||
remove() returns A
|
||||
The bag contains 5 string(s), as follows:
|
||||
A A B A C
|
||||
|
||||
Removing "B" from the bag:
|
||||
remove("B") returns true
|
||||
The bag contains 4 string(s), as follows:
|
||||
A A C A
|
||||
|
||||
Removing "A" from the bag:
|
||||
remove("A") returns true
|
||||
The bag contains 3 string(s), as follows:
|
||||
A A C
|
||||
|
||||
Removing "C" from the bag:
|
||||
remove("C") returns true
|
||||
The bag contains 2 string(s), as follows:
|
||||
A A
|
||||
|
||||
Removing "Z" from the bag:
|
||||
remove("Z") returns false
|
||||
The bag contains 2 string(s), as follows:
|
||||
A A
|
||||
|
||||
Clearing the bag:
|
||||
Testing isEmpty with an empty bag:
|
||||
isEmpty finds the bag empty: OK.
|
||||
|
||||
The bag contains 0 string(s), as follows:
|
||||
|
||||
|
||||
Testing an initially empty bag that will be filled to capacity:
|
||||
Adding A B A C B C D
|
||||
The bag contains 7 string(s), as follows:
|
||||
A B A C B C D
|
||||
Try to add another string to the full bag:
|
||||
The method add cannot add another string: OK
|
||||
*/
|
||||
/*
|
||||
Exception in thread "main" java.lang.SecurityException: Attempt to create a bag whose capacity exceeds 3
|
||||
at ArrayBag.<init>(ArrayBag.java:38)
|
||||
at ArrayBagDemo.main(ArrayBagDemo.java:12)
|
||||
|
||||
*/
|
||||
BIN
DataLabs/lab2/BagInterface.class
Normal file
BIN
DataLabs/lab2/BagInterface.class
Normal file
Binary file not shown.
48
DataLabs/lab2/BagInterface.java
Normal file
48
DataLabs/lab2/BagInterface.java
Normal file
@ -0,0 +1,48 @@
|
||||
/**
|
||||
An interface that describes the operations of a bag of objects.
|
||||
@author Frank M. Carrano
|
||||
@version 4.0
|
||||
*/
|
||||
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();
|
||||
} // end BagInterface
|
||||
BIN
DataLabs/lab2/Lab3.docx
Normal file
BIN
DataLabs/lab2/Lab3.docx
Normal file
Binary file not shown.
Loading…
x
Reference in New Issue
Block a user