Java Part 1: Write a replace method for the ArrayBag class. This method: -replac
ID: 3886058 • Letter: J
Question
Java
Part 1:
Write a replace method for the ArrayBag class. This method:
-replaces any object currently in the bag with an object sent in as a parameter
-returns the object that is replaced (removed)
Part 2:
Write a removeEvery method for the ArrayBag class. The method:
-removes all occurrences of a specific entry (send as a parameter) from a bag
-------------------------------------------------
import java.util.Arrays;
import java.util.Random;
public final class ArrayBag<T extends Comparable<? super T>> implements BagInterface<T> {
private final T[] bag;
private int numberOfEntries;
private boolean initialized = false;
private static final int DEFAULT_CAPACITY = 25;
private static final int MAX_CAPACITY = 10000;
/** Creates an empty bag whose initial capacity is 25. */
public ArrayBag() {
this(DEFAULT_CAPACITY);
} // end default constructor
/**
* Creates an empty bag having a given capacity.
*
* @param desiredCapacity
* The integer capacity desired.
*/
public ArrayBag(int desiredCapacity) {
if (desiredCapacity <= MAX_CAPACITY) {
// The cast is safe because the new array contains null entries
@SuppressWarnings("unchecked")
T[] tempBag = (T[]) new Comparable[desiredCapacity]; // Unchecked cast
bag = tempBag;
numberOfEntries = 0;
initialized = true;
} else
throw new IllegalStateException("Attempt to create a bag "
+ "whose capacity exceeds " + "allowed maximum.");
} // end constructor
/**
* 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) {
checkInitialization();
boolean result = true;
if (isArrayFull()) {
result = false;
} else { // Assertion: result is true here
bag[numberOfEntries] = newEntry;
numberOfEntries++;
} // end if
if (Arrays.asList(bag).contains(newEntry)) {}
return result;
} // end add
/**
* Retrieves all entries that are in this bag.
*
* @return A newly allocated array of all the entries in this bag.
*/
public T[] toArray() {
checkInitialization();
// The cast is safe because the new array contains null entries.
@SuppressWarnings("unchecked")
T[] result = (T[]) new Comparable[numberOfEntries]; // Unchecked cast
for (int index = 0; index < numberOfEntries; index++) {
result[index] = bag[index];
} // end for
return result;
// Note: The body of this method could consist of one return statement,
// if you call Arrays.copyOf
} // end toArray
/**
* 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 current number of entries in this bag.
*
* @return The integer number of entries currently in this bag.
*/
public int getCurrentSize() {
return numberOfEntries;
} // end getCurrentSize
/**
* 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 ba.
*/
public int getFrequencyOf(T anEntry) {
checkInitialization();
int counter = 0;
for (int index = 0; index < numberOfEntries; index++) {
if (anEntry.equals(bag[index])) {
counter++;
} // end if
} // end for
return counter;
} // end getFrequencyOf
/**
* Tests whether this bag contains a given entry.
*
* @param anEntry
* The entry to locate.
* @return True if this bag contains anEntry, or false otherwise.
*/
public boolean contains(T anEntry) {
checkInitialization();
return getIndexOf(anEntry) > -1; // or >= 0
} // end contains
/** Removes all entries from this bag. */
public void clear() {
while (!this.isEmpty())
this.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() {
checkInitialization();
T result = removeEntry(numberOfEntries - 1);
return result;
} // end 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) {
checkInitialization();
int index = getIndexOf(anEntry);
T result = removeEntry(index);
return anEntry.equals(result);
} // end remove
public boolean removeRandom() {
Random generator = new Random();
int randomPosition = generator.nextInt(numberOfEntries);
T result = removeEntry(randomPosition);
if (result == null) {
return false;
} else {
return true;
}
}
@Override
public boolean equals(Object obj) {
if (obj instanceof ArrayBag<?>) {
ArrayBag<T> otherArrayBag = (ArrayBag<T>) obj;
if (numberOfEntries == otherArrayBag.numberOfEntries) {
// I create new arrays so that I can manipulate them
// and it will not alter this.bag or otherArrayBag.bag
T[] currentBagTempArray = toArray();
T[] otherBagTempArray = otherArrayBag.toArray();
Arrays.sort(currentBagTempArray);
Arrays.sort(otherBagTempArray);
for (int i = 0; i < numberOfEntries; i++) {
if (!currentBagTempArray[i].equals(otherBagTempArray[i])) {
return false;
}
}
return true;
} else {
return false;
}
} else {
return false;
}
}
public ResizableArrayBag<T> createResizableArray() {
T[] currentBagContents = toArray();
ResizableArrayBag<T> newBag = new ResizableArrayBag<T>(currentBagContents);
return newBag;
}
// Returns true if the array bag is full, or false if not.
private boolean isArrayFull() {
return numberOfEntries >= bag.length;
} // end isArrayFull
// Locates a given entry within the array bag.
// 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(bag[index])) {
found = true;
where = index;
} // end if
index++;
} // end while
// 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 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 = bag[givenIndex]; // Entry to remove
int lastIndex = numberOfEntries - 1;
bag[givenIndex] = bag[lastIndex]; // Replace entry to remove with
// last entry
bag[lastIndex] = null; // Remove reference to last entry
numberOfEntries--;
} // end if
return result;
} // end removeEntry
// Throws an exception if this object is not initialized.
private void checkInitialization() {
if (!initialized)
throw new SecurityException(
"ArrayBag object is not initialized properly.");
} // end checkInitialization
} // end ArrayBag
Explanation / Answer
import java.awt.*;
import javax.swing.*;
public class MyTestApp extends JPanel
{
Rectangle rect;
Ellipse oval;
public static void main(String [] args)
{
MyTestApp myTestApp = new MyTestApp ();
myTestApp.test();
}
public MyTestApp ()
{
JFrame frame = new JFrame("MyClass Driver");
setBackground(new Color(200, 250, 200));
setPreferredSize(new Dimension(500, 400));
frame.add(this);
frame.pack();
frame.setVisible(true);
}
public void delay(int msecs)
{
try
{
Thread.sleep(msecs);
} catch (InterruptedException e)
{
}
}
public void paint(Graphics g)
{
super.paint(g);
if (rect != null)
rect.drawRectangle(g);
if (oval != null)
oval.drawEllipse(g);
}
public void test()
{
delay(1000);
rect = new Rectangle(20, 30, 23, 75, Color.GREEN, Color.BLUE);
oval = new Ellipse(10, 10, 10 , 34, Color.RED, Color.MAGENTA);
repaint();
}
public abstract class Shape
{
private int x, y, width, height;
private Color fillColor;
private Color outlineColor;
public Shape(int x, int y, int width, int height, Color fillColor, Color outlineColor)
{
setXY(x, y);
setSize(width, height);
setFillColor(fillColor);
setOutlineColor(outlineColor);
}
public boolean setXY(int x, int y)
{
this.x = x;
this.y = y;
return true;
}
public void setSize(int width, int height)
{
if (width > 0)
this.width = width;
if (height > 0)
this.height = height;
}
public boolean setFillColor(Color fillColor)
{
if (fillColor == null) return false;
this.fillColor = fillColor;
return true;
}
public boolean setOutlineColor(Color outlineColor)
{
if (outlineColor == null) return false;
this.outlineColor = outlineColor;
return true;
}
public Color getFillColor()
{
return fillColor;
}
public Color getOutlineColor()
{
return outlineColor;
}
public abstract void drawRectangle(Graphics g);
public abstract void drawEllipse(Graphics g);
}
class Rectangle extends Shape
{
public Rectangle(int x, int y, int width, int height, Color fillColor, Color outlineColor)
{
super(x, y, width, height, fillColor, outlineColor);
}
public void drawRectangle(Graphics g)
{
g.setColor(fillColor);
g.fillRect(x, y, width, height);
g.setColor(outlineColor);
g.drawRect(x, y, width, height);
}
}
class Ellipse extends Shape
{
public Ellipse(int x, int y, int width, int height, Color fillColor, Color outlineColor)
{
super(x, y, width, height, fillColor, outlineColor);
}
public void drawEllipse(Graphics g)
{
g.setColor(fillColor);
g.fillOval(x, y, width, height);
g.setColor(outlineColor);
g.drawOval(x, y, width, height);
}
}
}
Related Questions
drjack9650@gmail.com
Navigate
Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.