Question

Assume that you have the following Bag object, myBag, with n String data: Baginterface <String> myBag new ArrayBag< >( Write Java statements that create a newBag object which contains non-duplicate data in myBag and marks the duplicate data. Example: if myBag contains data Hn newBag object should contain: "aa", "Аа", "СС", "Bb", "DUP. 1.Bb", "DUP.2.Aa", "D', Hint: You can use the Bag's methods: int getCurrentSize (0; boolean isFull (0; boolean isEmpty (0: boolean add (T newEntry); T remove (0; boolean remove (T anEntry): void clear (0; int getFrequencyOf (T anEntry); boolean contains (T anEntry); T [] toArray (0:

I don't understand the question. Could someone solve and explain it please?

Answer 1

ANSWER:

THE QUESTION IS ABOUT TO REMOVE THE DUPLICATE DATA IN THE BAG

CODE:

import java.util.*;

/* class BagTest */

public class BagTest

{

/* main module */

public static void main(String[] args)

{

/* object creation */

ArrayList<String> mybag = new ArrayList<String>();

/* adding String to Bag Array */

mybag.add("hello");

mybag.add("hello");

mybag.add("world");

mybag.add("hello");

mybag.add("james");

mybag.add("james");

/* before removal */

System.out.println("Initial Array:"+mybag);

/* removing duplicates */

for(int inc1=0;inc1<mybag.size();inc1++)

{

for(int inc2=inc1+1;inc2<mybag.size();inc2++)

{

if(mybag.get(inc1).equals(mybag.get(inc2)))

{

mybag.remove(inc2);

inc2--;

}

}

}

/* after removal */

System.out.println("Output Array:"+mybag);

}

}

(OR)

CODE:

public class ArrayBag<T> implements BagInterface<T>
{
   private final T[] bag;
   private static final int DEFAULT_CAPACITY = 25;
   private int numberOfEntries;
   public ArrayBag()
   {
       this(DEFAULT_CAPACITY);
   }    public ArrayBag(int capacity)
   {
       numberOfEntries = 0;
@SuppressWarnings("unchecked")
T[] tempBag = (T[])new Object[capacity]; // unchecked cast
bag = tempBag;
// for (int index = 0; index < initialCapacity; index++)
// System.out.print(bag[index] + " ");
// System.out.println();
   } // end constructor

   public boolean add(T newEntry)
   {
       boolean result = true;
       if (isFull())
       {
           result = false;
       }
       else
       { // assertion: result is true here
           bag[numberOfEntries] = newEntry;
           numberOfEntries++;
       } // end if
      
       return result;
   } // end add

   public boolean isFull()
   {
       return numberOfEntries == bag.length;
   } // end isFull
  
   public T[] toArray() //OK
   {
@SuppressWarnings("unchecked")
T[] result = (T[])new Object[numberOfEntries]; // unchecked cast

       for (int index = 0; index < numberOfEntries; index++)
       {
           result[index] = bag[index];
       } // end for
          
       return result;
   } // end toArray

   public boolean isEmpty()
   {
       return numberOfEntries == 0;
   } // end isEmpty

   public int getCurrentSize()
   {
       return numberOfEntries;
   } // end getCurrentSize

   public int getFrequencyOf(T anEntry)
   {
       int counter = 0;

       for (int index = 0; index < numberOfEntries; index++)
       {
           if (anEntry.equals(bag[index]))
           {
               counter++;
           } // end if
       } // end for

       return counter;
   } // end getFrequencyOf

   public boolean contains(T anEntry)
   {
       return getIndexOf(anEntry) > -1; // or >= 0
   } // end contains

    private int getIndexOf(T anEntry)
   {
       int where = -1;
       boolean found = false;
  
       for (int index = 0; !found && (index < numberOfEntries); index++)
       {
           if (anEntry.equals(bag[index]))
           {
               found = true;
               where = index;
           } // end if
       } // end for
  
// Assertion: If where > -1, anEntry is in the array bag, and it
// equals bag[where]; otherwise, anEntry is not in the array

       return where;
   } // end getIndexOf

   /** Removes all entries from this bag. */
   public void clear()
   {
       while (!isEmpty())
remove();
   } // end clear
  
   public T remove()
   {
       T result = removeEntry(numberOfEntries - 1);
      
       return result;
   } // end remove
  
   public boolean remove(T anEntry)
   {
       int index = getIndexOf(anEntry);
T result = removeEntry(index);
      
       return anEntry.equals(result);
   } // end remove

private T removeEntry(int givenIndex)
   {
       T result = null;
  
       if (!isEmpty() && (givenIndex >= 0))
       {
result = bag[givenIndex]; // entry to remove
numberOfEntries--;
bag[givenIndex] = bag[numberOfEntries]; // replace entry to remove with last entry
bag[numberOfEntries] = null; // remove reference to last entry
       } // end if
  
return result;
   } // end removeEntry   
} // end ArrayBag

TestBag:

import junit.framework.TestCase;

/**
* A JUnit test case class.
* Every method starting with the word "test" will be called when running
* the test with JUnit.
*/
public class TestBag extends TestCase {
  
/**
* A test method.
* (Replace "X" with a name describing the test. You may write as
* many "testSomething" methods in this class as you wish, and each
* one will be called when running JUnit over this class.)
*/
public void testIsFull() {
BagInterface<String> bag = new ArrayBag<String>(3);
  
assertFalse(bag.isFull());
  
bag.add("app");
  
assertFalse(bag.isFull());
  
bag.add("ban");
bag.add("cherry");
  
assertTrue(bag.isFull());
}
  
public void testAdd() {
BagInterface<String> bag = new ArrayBag<String>(3);
  
assertTrue(bag.add("app"));
assertTrue(bag.add("ban"));
assertTrue(bag.add("che"));
assertFalse(bag.add("don"));
}
  
public void testGetCurrentSize() {
BagInterface<String> bag = new ArrayBag<String>();
  
assertEquals(0,bag.getCurrentSize());
  
assertTrue(bag.add("app"));
assertEquals(1,bag.getCurrentSize());
}
  
public void testIsEmpty() {
BagInterface<String> bag = new ArrayBag<String>();
  
assertTrue(bag.isEmpty());
  
assertTrue(bag.add("app"));
  
assertFalse(bag.isEmpty());
}
  
public void testClear() {
BagInterface<String> bag = new ArrayBag<String>();
  
assertTrue(bag.add("app"));
assertTrue(bag.add("ban"));
assertTrue(bag.add("che"));
assertTrue(bag.add("don"));
  
assertFalse(bag.isEmpty());
  
// nothing to assert as clear() returns void
bag.clear();
  
assertTrue(bag.isEmpty());
  
}
  
public void testContains() {
BagInterface<String> bag = new ArrayBag<String>();
  
assertTrue(bag.add("app"));
assertTrue(bag.add("app"));
assertFalse(bag.contains("ban"));
}
  
// remove(T)
public void testRemoveParam() {
BagInterface<String> bag = new ArrayBag<String>();

assertFalse(bag.remove("app"));
  
assertTrue(bag.add("app"));
assertTrue(bag.remove("app"));
}

// remove()
public void testRemove() {
BagInterface<String> bag = new ArrayBag<String>();

assertNull(bag.remove());
  
/**
* If we only have app in the bag
* that should be the item that is removed.
*/
assertTrue(bag.add("app"));
assertEquals("app",bag.remove());
}

public void getFrequencyOf() {
BagInterface<String> bag = new ArrayBag<String>();

assertEquals(0,bag.getFrequencyOf("app"));

assertTrue(bag.add("app"));
assertEquals(1,bag.getFrequencyOf("app"));

for (int i = 0; i < 5; i++)
assertTrue(bag.add("ban"));

assertEquals(5,bag.getFrequencyOf("ban"));   
}
  
}

PLZZZZZZZZZZZZZZZZZZ RATE THUMBSUP PLZZZZZZZ