Question

**********Using Java***************

Create 5 CLASSES: Driver(main), Word, AnagramFamily, and 2 Comparators classes

words.txt is a very large file containing thousands of words. I will post some words down below.

DETAILS To better prepare you for assignments in more advanced courses, specific step-by-step, method headings class names, and the like have been omitted. What remains is a general description (you may need to read this several times to fully understand the requirements): form. The canonical form stores a word with its letters in alphabetical order, e.g. bob would be bbo, cat would be act, program would be agmoprr, and so on. The class Word constructor has the responsibility of storing which is stored in the canonical form field (you should call a separate method for this conversion purpose) Once all the words from the input file have been properly stored in a LinkedList of Word, you should use Collections to sort this list ascending alphabetically based on the canonical words by making the Word class Using an Iterator on the LinkedList of Word, create a 2ng list (new LinkedList) consisting of objects of a new class named AnagramFamily. AnagramFamily should contain at least 2 fields; 1 to hold a list of "Word" words that are all anagrams of each other (these should all be grouped together in the original canonical sorted list) and the 2nd field to store an integer value of how many items are in the current list. (Keep in mind, because the original list contains both the normal and canonical forms, as the AnagramFamily List will also have, a family of anagrams will all have the same canonical form with different normal forms stored in the normalForm field of the Word class). Each AnagramFamily List of Word should be sorted Descending by normal form using a Comparator of Word (if you insert Word(s) into a family one at a time, this presents an issue on how to get this ist sorted as each Word insertion will require a new sort to be performed to guarantee the list is always sorted. For this reason it is best to form a list, sort it, and then create an AnagramFamily by passing the sorted list to it). Sort the AnagramFamily LinkedList in descending order based on family size by use of a Comparator to be passed to the Collections sort method. Next, output the top five largest families then, all families of length 8, and lastly, the very last family stored in the list to a file named "out6.txt." Be sure to format the output to be very clear and meaningful

some of word.txt

aa
aah
aahed
aahing
aahs
aal
aalii
aaliis
aals
aardvark
aardvarks
aardwolf
aardwolves
aargh
aarrgh
aarrghh
aas
aasvogel
aasvogels
ab
aba
abaca
abacas
abaci
aback
abacterial
abacus
abacuses
abaft
abaka
abakas
abalone
abalones
abamp
abampere
abamperes
abamps
abandon
abandoned
abandoner
abandoners
abandoning
abandonment
abandonments
abandons
abapical
abas
abase
abased
abasedly
abasement
abasements
abaser
abasers
abases
abash
abashed
abashes
abashing
abashment
abashments
abasia
abasias
abasing
abatable
abate
abated
abatement
abatements
abater
abaters
abates
abating
abatis
abatises
abator
abators
abattis
abattises
abattoir
abattoirs
abaxial
abaxile
abba
abbacies
abbacy
abbas
abbatial
abbe
abbes
abbess
abbesses
abbey
abbeys
abbot
abbotcies
abbotcy
abbots
abbreviate
abbreviated
abbreviates

Answer 1

Hi,

Please find the classes that you have mentioned me to create.

AnagramFamily.java:

import java.util.Collections;

import java.util.LinkedList;

import java.util.List;

import java.util.ListIterator;

public class AnagramFamily {

private LinkedList<Word> myWords;

private int myCount;

/**

* this constructor accepts a list containing a sorted anagram family, adds the

* elements of that list to the myWords feild, sorts myWords, and calculates the

* number of words in the list

*

* @param theFamily

* (list of words)

*

**/

public AnagramFamily(List<Word> theFamily) {

myCount = 0;

myWords = new LinkedList<Word>();

// theFamily iterator

ListIterator<Word> iterator = theFamily.listIterator();

while (iterator.hasNext()) {

myWords.add(iterator.next());

myCount++;

}

// sort words by original form

// descending alphabetically

Collections.sort(myWords, new CompareByOriginal());

}

/**

* getMyCount() returns this objects # of words.

*

* @return myCount (# of words)

**/

public int getMyCount() {

return myCount;

}

/**

* toString returns the string representation of a list with all of myWords

* original word forms to identify its containing word objects.

*

* @return myWords.toString()

*

**/

public String toString() {

return myWords.toString();

}

}

CompareAnagramSize.java:

import java.util.Comparator;

public class CompareAnagramSize implements Comparator<AnagramFamily> {

/**

* this comparator compares two anagram families, families with more objects

* considered ahead.

*

* @param theThis

* (original family)

* @param theOther

* (family being considered)

* @return theOther.getMyCount() - theThis.getMyCount()

*

**/

public int compare(AnagramFamily theThis, AnagramFamily theOther) {

return theOther.getMyCount() - theThis.getMyCount();

}

}

CompareByOriginal.java:

import java.util.Comparator;

public class CompareByOriginal implements Comparator<Word> {

/**

* compare is a comparator which compares word objects alphabetically descending

*

* @param theFirst

* (word being compared to)

* @param theSecond

* (word being compared)

* @return theSecond.getMyWord().compareTo( theFirst.getMyWord())

*

*/

public int compare(Word theFirst, Word theSecond) {

return theSecond.getMyWord().compareTo(theFirst.getMyWord());

}

}

ProgramNineDriver.java:

import java.io.File;

import java.io.FileNotFoundException;

import java.io.PrintStream;

import java.util.Collections;

import java.util.LinkedList;

import java.util.ListIterator;

import java.util.Scanner;

public class ProgramNineDriver {

/**

* main is the driver program to test word and AnagramFamily objects from

* words.txt.

*

* @param theArgs[]

* (command line input)

*

**/

public static void main(String theArgs[]) {

Scanner input = null;

PrintStream output = null;

boolean fileOk = false;

try {

input = new Scanner(new File("C:\\Users\\baba\\HomeworkLib\\eclipse-workspace\\Chegg\\images\\words.txt"));

output = new PrintStream(new File("C:\\Users\\baba\\HomeworkLib\\eclipse-workspace\\Chegg\\images\\out9.txt"));

fileOk = true;

} catch (FileNotFoundException e) {

System.out.println("Cannot open file " + e);

}

// body of program if file is read

if (fileOk) {

LinkedList<Word> words = new LinkedList<Word>();

// iterator creates and adds word objects to words

while (input.hasNext()) {

words.add(new Word(input.next()));

}

// sorts words alphabetically canotically

Collections.sort(words);

// this LinkedList stores the content of

// unique AnagramFamilies for construction

LinkedList<Word> aFamily = new LinkedList<Word>();

// this LinkedList stores anagram families

LinkedList<AnagramFamily> families = new LinkedList<AnagramFamily>();

// iterator for traversing words

ListIterator<Word> iterator = words.listIterator();

// uses recursive calls to getFamily to get families

while (iterator.hasNext()) {

Word test = iterator.next();

aFamily.add(test);

// recursive end runs until end of family

if (iterator.hasNext()) {

getFamily(aFamily, iterator, test);

}

// sort this family on original word

// ascending alphabetically

Collections.sort(aFamily, new CompareByOriginal());

// adds current AnagramFamily to our list

families.add(new AnagramFamily(aFamily));

// primes aFamily for next family

aFamily.clear();

}

// sorts our AnagramFamilys

// based on family size descending

Collections.sort(families, new CompareAnagramSize());

// the rest of main handles program output

output.println("5 LARGEST FAMILIES");

for (int i = 0; i < 5; i++) {

output.println(families.get(i));

}

output.println();

output.println("FAMILIES OF LENGTH 8");

for (AnagramFamily f : families) {

if (f.getMyCount() == 8) {

output.println(f);

}

}

input.close();

output.close();

}

}

/**

* getFamily is a recursive method which continues down a list of Word objects

* untill the next word object is not the same as the current object based on

* its canotical form and adds all similar objects to a result LinkedList.

*

* @param theFamily

* (list of similar words)

* @param theIterator

* (word list iterator)

* @param thePrevious

* (last word in the list)

*

**/

public static void getFamily(LinkedList<Word> theFamily, ListIterator<Word> theIterator, Word thePrevious) {

// sets the test to the next word

Word test = theIterator.next();

// if test == previous, recall method with

// test passed to thePrevious

if (thePrevious.compareTo(test) == 0) {

theFamily.add(test);

if (theIterator.hasNext()) {

getFamily(theFamily, theIterator, test);

}

}

// BASE CASE: if the next item != previous

else {

// step back in iterator so next item

// is the first new canotical form

theIterator.previous();

}

}

}

Word.java:

import java.util.Arrays;

public class Word implements Comparable<Word> {

// Original word field

private String myWord;

// field for myWord's canonical form

private String myCat;

/**

* this constructor assigns myWord and calls makeCat to create myCat

*

* @param theWord

* (original word)

*

**/

public Word(String theWord) {

myWord = theWord;

// charlist of word for sorting

char[] wordChars = theWord.toCharArray();

makeCat(wordChars);

// assign myCat to new sorted char string

myCat = new String(wordChars);

}

/**

* this method will find the canotical form of the passed arraylist of char. It

* operates using the mergesort algorithm by recursively splitting the array in

* half then sorting those halfs into a resulting array.

*

* @param chars

* (char list of word characters)

*

**/

private final void makeCat(char[] chars) {

// BASE CASE: if length =< 1

if (chars.length > 1) {

char[] left = Arrays.copyOfRange(chars, 0, chars.length / 2);

char[] right = Arrays.copyOfRange(chars, chars.length / 2, chars.length);

// recursively call makeCat

makeCat(left);

makeCat(right);

// merge the two halves together

merge(chars, left, right);

}

}

/**

* this method handles merging the two halves of the char array from makeCat

* into sorted order.

*

* @param result

* (final char array)

* @param theLeft

* (first half of array)

* @param theRight

* (second half of array)

*

**/

private final void merge(char[] result, char[] theLeft, char[] theRight) {

int i1 = 0; // left array index

int i2 = 0; // right array index

for (int i = 0; i < result.length; i++) {

if (i2 >= theRight.length || (i1 < theLeft.length && theLeft[i1] <= theRight[i2])) {

result[i] = theLeft[i1]; // take from left

i1++;

} else {

result[i] = theRight[i2];

i2++;

}

}

}

/**

* this accessor method retrieves myWord.

*

* @return myWord (word objects word feild)

*

**/

public String getMyWord() {

return myWord;

}

/**

* getMyCat retrieves canatical form.

*

* @return myCat (canotical form feild)

*

**/

public String getMyCat() {

return myCat;

}

/**

* compareTo method compares this objects canotical form to the others canotical

* form ascending alphabetically

*

* @param theOther

* (word to compare to

* @return myCat.compareTo(theOther.getMyCat())

*

**/

public int compareTo(Word theOther) {

return myCat.compareTo(theOther.getMyCat());

}

/**

* toString simply returns the word objects original word feild.

*

* @return myWord (the word feild)

*

**/

public String toString() {

return myWord;

}

}

As per the words list provided by you the output for them is as follows:

Output:

5 LARGEST FAMILIES
[aa]
[abatable]
[abbatial]
[abaca]
[abacterial]

FAMILIES OF LENGTH 8