program to determine number of duplicates in a sentence

Code:public class duplicate

{

public static void main(String[] args)throws IOException

  {

  System.out.println("Enter words separated by spaces ('.' to quit):");

  Set<开发者_JS百科String> s = new HashSet<String>();

  Scanner input = new Scanner(System.in);

  while (true)

  {

  String token = input.next();

  if (".".equals(token))

  break;

  if (!s.add(token))

  System.out.println("Duplicate detected: " + token);

  }

  System.out.println(s.size() + " distinct words:\n" + s);
 Set<String> duplicatesnum = new HashSet<String>();

String token = input.next(); if (!s.add(token)) { duplicatesnum.add(token); System.out.println("Duplicate detected: " + token); }

System.out.println(duplicatesnum.size());

} } the output is: Enter words separated by spaces ('.' to quit): one two one two . Duplicate detected: one Duplicate detected: two 2 distinct words: [two, one]

---

I assume you want to know the number of different duplicate words. You can use another HashSet<String> for the duplicates.

//Outside the loop
Set<String> duplicates = new HashSet<String>();

//Inside the loop
if (!s.add(token))
{
    duplicates.add(token);
    System.out.println("Duplicate detected: " + token);
}

//Outside the loop
System.out.println(duplicates.size());

Also if you care for the occurences of each word declare a HashMap<String, Integer> as in others posts is mentioned.

But if you want the number of all duplicate words(not different) just declare a counter:

//Outside the loop
int duplicates = 0;    

//Inside the loop
if (!s.add(token))
{
    duplicates++;
    System.out.println("Duplicate detected: " + token);
}

//Outside the loop
System.out.println(duplicates);

---

Instead of a HashSet, use a HashMap. A HashSet only stores the values. A HashMap maps a value to another value (see http://www.geekinterview.com/question_details/47545 for an explanation)

In your case, the key of the HashMap is your string (just as the key of the HashSet is the string). The value in the HashMap is the number of times you encountered this string.

When you find a new string, add it to the HashMap, and set the value of the entry to zero. When you encounter the same string later, increment the value in the HashMap.

---

Because you are using a HashSet, you will not know how many duplicates you have. If you went with a HashMap<String, Integer>, you could increment whenever you found that your key was != null.

---

In the if (!s.add(token)), you can increment a counter and then display it's value at the end.

---

Your question is a bit misleading. Some people understand that you want:

Input: hello man, hello woman, say good by to your man.

Output:

Found duplicate: Hello

Found duplicate: Man

Duplicate count: 2

Others understood you wanted:

Input: hello man, hello woman, say hello to your man.

Output:

Found duplicate: Hello - 3 appearances

Found duplicate: Man - 2 appearances

Assuming you want the 1st option - go with Petar Minchev's solution

Assuming you want the 2nd option - go with Patrick's solution. Don't forget that when you use an Integer in a Map, you can get/put int as well, and Java will Automatically Box/Unbox it for you, but if you rely on this - you can get NPEs when asking the map for a key that does not exist:

Map<String,Integer> myMap = new HashMap<String,Integer>();    
myMap.get("key that does not exist"); // NPE here <---

The NPE is caused since the return value from 'get' is null, and that value is being cast into an Integer after which the intValue() method will be invoked - thus triggering an NPE.

---

You can use Google collections library:

Multiset<String> words = HashMultiset.create();

while (true) {
    String token = input.next();

    if (".".equals(token))
        break;
    if (!words.add(token))
        System.out.println("Duplicate detected: " + token);
}
System.out.println(words.elementSet().size() + " distinct words:\n" + words.elementSet());

Collection<Entry<String>> duplicateWords = Collections2.filter(words.entrySet(), new Predicate<Entry<String>>() {
   public boolean apply(Entry<String> entry) {
      return entry.getCount() > 1;
   }
});
System.out.println("There are " + duplicateWords.size() + " duplicate words.");
System.out.println("The duplicate words are: " + Joiner.on(", ").join(duplicateWords));

Example of output:

Enter words separated by spaces ('.' to quit):
aaa bbb aaa ccc aaa bbb .
3 distinct words:
[aaa, ccc, bbb]
There are 2 duplicate words.
The duplicate words are: aaa x 3, bbb x 2