Don't know how to start..

Can anyone help me?

For this program you are to create a two class application - a driver and a principal class - that reads in text interactively from the keyboard, and then reports on two aspects of the entered text. First it should print a table of word sizes in the entered text, for sizes from 1 up to 12 and larger; and second, it should report the number of sentences in the text. To be clear on how this should work, here is the text from a sample run:

> run WordProfileDriver
Enter lines of text, type two returns in a row to end

[DrJava Input Box] The time has come, the walrus said - to speak of many things
[DrJava Input Box] At least that's how the ultra-ultra-famous first line goes, from the
[DrJava Input Box]the Lewis Carroll poem! If you don't know it, give it a try.

words of size 1---2
words of size 2---6
words of size 3---9
words of size 4---10
words of size 5---5
words of size 6---3
words of size 7---1
words of size 8---0
words of size 9---0
words of size 10---0
words of size 11---0
words of size >= 12---1
sentences: 2

As you can see, the driver class is called WordProfileDriver (you must use this name). The second class, where all the action happens, must be called WordProfile. Some further thoughts:

Read input using the style of program Backwards from section 7.2 of the iJava textbook.

You must make essential use of arrays in your word size accounting. Notice that words that are of size 12 or larger are lumped together.

You will need to use a StringTokenizer for this problem. In addition to "space", these characters should be considered delimiters: ,.?!:; This means that dash - the symbol "-", and single quote - the symbol " ' ", should be considered characters in a word (and thus "can't" is a single word of length 5, a lone dash is actually a word of size 1, and "head-long" is a single word of length 9).

To count sentences, just count the number of ? (question mark), !(exclamation mark), .(period). Just counting these three sentence terminators is fairly easy, although strictly speaking it's not completely correct, since a sentence might end in ??, for example.

Lines should be read in in the driver, but should be processed using StringTokenizer in WordProfile. Also, the essential array, where where you keep track of word size counts, MUST be in the WordProfile class, and not in the driver.

When you paste in your code, do NOT paste in any import statements. We will import java.util for you, for both classes.

Put your WordProfile class here:

From what I see in the specifications, it is likely that it is not your first Java course. If you really don't know where to start, you need a good revision before you even start.

Having said that, here are some hints.

1. main
Since you "run WordProfileDriver", you will have your "main" method in the file WordProfileDriver.java which instantiates the WordProfile class, and does the screen IO to store the user input data into a String of the WordProfile object.

2. WordProfile class

It will have a String as an instance variable, constructor and get/set methods.
You will likely to have an append method since input is read in in separate lines. Alternatively you can join the different lines in the main, but that's messy.
You will need also an "analyse" method to do the calculations. This can be done only when the whole text has been entered, since sentences could be cut between lines.

The StringTokenizer is an older class that helps in separating a text into "tokens" according to your definition of separators. You could use one set of separators for the words, and another for the sentences, basically run through the text twice. However, this is not a good practice for huge texts of several gigabytes. The approach depends on your level of techniques, namely simplicity versus performance.

Work on the skeleton, and report back if you need further help.

Note: do not start a new thread for the same problem in order to provide other teachers and other readers continuity.

To solve this problem, we need to create two classes: WordProfileDriver and WordProfile.

Here is the WordProfile class that will do the word size accounting and count the sentences:

```java
import java.util.StringTokenizer;

public class WordProfile {
private int[] wordSizes;

public WordProfile() {
wordSizes = new int[13]; // Index 0 is not used
}

public void processLine(String line) {
StringTokenizer tokenizer = new StringTokenizer(line, " ,.?!:;");
while (tokenizer.hasMoreTokens()) {
String word = tokenizer.nextToken();
int wordSize = word.length();
if (wordSize >= 12) {
wordSizes[12]++;
} else {
wordSizes[wordSize]++;
}
}
}

public int[] getWordSizes() {
return wordSizes;
}

public int countSentences(String line) {
int sentenceCount = 0;
for (int i = 0; i < line.length(); i++) {
char c = line.charAt(i);
if (c == '?' || c == '!' || c == '.') {
sentenceCount++;
}
}
return sentenceCount;
}
}
```

And here is the WordProfileDriver class that will read lines of text from the keyboard and interact with the WordProfile class:

```java
import java.util.Scanner;

public class WordProfileDriver {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
WordProfile wordProfile = new WordProfile();

System.out.println("Enter lines of text, type two returns in a row to end");

String line = scanner.nextLine();
int sentenceCount = 0;

while (!line.isEmpty()) {
wordProfile.processLine(line);
sentenceCount += wordProfile.countSentences(line);
line = scanner.nextLine();
}

int[] wordSizes = wordProfile.getWordSizes();

for (int i = 1; i <= 12; i++) {
System.out.println("words of size " + i + "---" + wordSizes[i]);
}

System.out.println("words of size >= 12---" + wordSizes[12]);
System.out.println("sentences: " + sentenceCount);

scanner.close();
}
}
```

To test this program, you can copy and paste both classes into separate Java files in your IDE or a text editor, and then compile and run the WordProfileDriver class.

When you run the program, it will prompt you to enter lines of text. Type in your text and press Enter. To end, simply press Enter twice in a row. The program will then display the table of word sizes and the count of sentences.

Note that in the WordProfileDriver class, we use the Scanner class to read input from the keyboard, and in the WordProfile class, we use the StringTokenizer class to split the input into words and count their sizes.

I hope this explanation helps you understand how to solve the problem. Let me know if you have any further questions!