Question

Write a program that thoroughly tests the class LinkedBag. Write the "LinkedBag" class, and a main program named "Project1.java" testing the methods defined for the LinkedBag object. The interface file: BagInterface.java.

/** An interface that describes the operations of a bag of objects. @author

Frank M. Carrano @author Timothy M. Henry @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();// 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

Answer 1

Please find the source code below. It has three files: LinkedBag.java - an implementation of the given BagInterface based on LinkedList, Util.java - contains some utility methods and Project1.java - Main class to test the files

/** LinkedBag.java **/

public class LinkedBag<T> implements BagInterface<T> {

    private Node head;
    private int length;

    public LinkedBag() {
        this.head = null;
        this.length = 0;
    }

    @Override
    public int getCurrentSize() {
        return this.length;
    }

    @Override
    public boolean isEmpty() {
        return this.length == 0;
    }

    @Override
    public boolean add(T newEntry) {
        Node newNode = new Node(newEntry);
        newNode.next = head;
        head = newNode;
        this.length++;
        return true;
    }

    @Override
    public T remove() {
        T result = null;
        if(this.head != null) {
            result = this.head.data;
            this.head = this.head.next;
            this.length --;
        }
        return result;
    }

    @Override
    public boolean remove(T anEntry) {
        boolean res = false;
        Node node = searchFor(anEntry);
        if (node != null) {
            node.data = this.head.data;
            this.head = this.head.next;
            this.length --;
            res = true;
        }
        return res;
    }

    @Override
    public void clear() {
        while (!isEmpty()) {
            remove();
        }
    }

    @Override
    public int getFrequencyOf(T anEntry) {
        int frequency = 0;
        int count = 0;
        Node cur = this.head;
        while (count < this.length && cur != null) {
            if (anEntry.equals(cur.data)) {
                frequency ++;
            }
            count ++;
            cur = cur.next;
        }
        return frequency;
    }

    @Override
    public boolean contains(T anEntry) {
        Node toSearch = searchFor(anEntry);
        return toSearch != null;
    }

    @Override
    public T[] toArray() {
        T[] array =  (T[]) new Object[this.length];
        Node cur = this.head;
        for (int i=0; i<this.length && cur != null; i++) {
            array[i] = cur.data;
            cur = cur.next;
        }
        return array;
    }

    @Override
    public BagInterface<T> union(BagInterface<T> anotherBag) {
        T[] thisBag = toArray();
        T[] otherBag = anotherBag.toArray();
        T[] latest = Util.union(thisBag, otherBag);
        return LinkedBag.fromArray(latest);
    }

    @Override
    public BagInterface<T> intersection(BagInterface<T> anotherBag) {
        return LinkedBag.fromArray(Util.intesection(this.toArray(), anotherBag.toArray()));
    }

    @Override
    public BagInterface<T> difference(BagInterface<T> anotherBag) {
        return LinkedBag.fromArray(Util.difference(this.toArray(), anotherBag.toArray()));
    }

    public static <T> LinkedBag<T> fromArray(T[] array) {
        LinkedBag<T> linkedBag = new LinkedBag<>();
        for(int i=0; i<array.length; i++) {
            linkedBag.add(array[i]);
        }
        return linkedBag;
    }

    public void print() {
        Node cur = this.head;
        while (cur != null) {
            System.out.print(cur.data + "->");
            cur = cur.next;
        }
        System.out.print("null");
        System.out.println();
    }


    private Node searchFor(T toSearch) {
        boolean found = false;
        Node cur = this.head;
        while (!found && (cur != null)) {
            if (toSearch.equals(cur.data)) {
                found = true;
            } else {
                cur = cur.next;
            }
        }
        return cur;
    }

    private class Node {
        private T data;
        private Node next;

        public Node(T data) {
            this(data, null);
        }

        public Node(T data, Node next) {
            this.data = data;
            this.next = next;
        }
    }
}

/** Util.java **/

import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Util {

    public static <T> T[] union(T[] a, T[] b) {
        ArrayList<T> l1 = new ArrayList<>(Arrays.asList(a));
        ArrayList<T> l2 = new ArrayList<>(Arrays.asList(b));
        l1.addAll(l2);
        return l1.toArray((T[]) new Object[l1.size()]);
    }

    public static <T>  T[] intesection(T[] a, T[] b) {
        Set<T> res = new HashSet<>();
        ArrayList<T> f = new ArrayList<>(Arrays.asList(a));
        ArrayList<T> s = new ArrayList<>(Arrays.asList(b));
        res = Stream.concat(f.stream(), s.stream())
                .filter(f::contains)
                .filter(s::contains)
                .collect(Collectors.toSet());
        return res.toArray((T[]) new Object[res.size()]);
    }

    public static <T> T[] difference(T[] a, T[] b) {
        ArrayList<T> l1 = new ArrayList<>(Arrays.asList(a));
        ArrayList<T> l2 = new ArrayList<>(Arrays.asList(b));
        l1.removeAll(l2);
        return l1.toArray((T[]) new Object[l1.size()]);
    }
}

/** Project1.java **/

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Project1 {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>(Arrays.asList(1,2,3,4,5,6,6,7,8,9,9,10));
        LinkedBag<Integer> linkedBag = LinkedBag.fromArray(list.toArray(new Integer[0]));
        linkedBag.print();

        System.out.println("Current Size is: " + linkedBag.getCurrentSize());

        System.out.println("Frequency of element 9 is " + linkedBag.getFrequencyOf(9));

        System.out.println("Removing an unspecified element; remove()");
        linkedBag.remove();
        linkedBag.print();

        System.out.println("Removing an element; remove(9)");
        linkedBag.remove(9);
        linkedBag.print();

        LinkedBag<Integer> bag2 = LinkedBag.fromArray(new ArrayList<>(Arrays.asList(4,5,6,99,10)).toArray(new Integer[5]));
        LinkedBag<Integer> bag3 = LinkedBag.fromArray(new ArrayList<>(Arrays.asList(6,8,9,10)).toArray(new Integer[4]));

        System.out.println("Union of bag 2 and original bag: ");
        ((LinkedBag<Integer>)linkedBag.union(bag2)).print();

        System.out.println("Difference of bag 3 and original bag: ");
        ((LinkedBag<Integer>)linkedBag.difference(bag3)).print();

        System.out.println("Intersection of bag 2 and original bag: ");
        ((LinkedBag<Integer>)linkedBag.intersection(bag2)).print();
    }
}