datalab2

DataLabs/lab2/ArrayBag.java

@@ -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;
+ }
+}

DataLabs/lab2/ArrayBagDemo.java

@@ -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)
+   
+*/

DataLabs/lab2/BagInterface.java

@@ -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