Как найти одинаковые слова в массиве

This should be quite simple (I think), but I just can’t get it right…:|

The task is as follows:

Ask the user for some input. The input must be split in to single words and put into an array. All words should be counted. If equal words exists, they get a «+1» on the output.
Finally I want to print out and hopefully the right amount of counted words in a list. I got the first two columns right, but the word-counter of equal words gave me a headache. If a word is found to be equal, it mustnt appear twice in the generated list! :!

I am a complete JAVA newbie so please be kind on the code-judging.

Here is my code so far:

package MyProjects;

import javax.swing.JOptionPane;

public class MyWordCount {
public static void main(String[] args) {

    //User input dialog
    String inPut = JOptionPane.showInputDialog("Write som text here");

    //Puts it into an array, and split it with " ".
    String[] wordList = inPut.split(" ");

    //Print to screen
    System.out.println("Place:tWord:tCount: ");

    //Check & init wordCount
    int wordCount = 0;

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

        for (int j = 0; j < wordList.length; j++){

            //some code here to compare
            //something.compareTo(wordList) ?

        }

        System.out.println(i + "t" + wordList[i]+ "t" + wordCount[?] );
    }

}
}

You can use Hashmap to do that. A Hashmap stores key-value pairs and each key has to be unique.

So in your case, a key will be a word of the string you have split and value will be it’s count.

Once you have split the input into words and put them into a string array, put the first word,as a key, into the Hashmap and 1 as it’s value. For each subsequent word, you can use the function containsKey() to match that word with any of the existing keys in the Hashmap. If it returns true, increment the value (count) of that key by one, else put the word and 1 as a new key-value pair into the Hashmap.

answered Sep 11, 2012 at 21:12

So in order to compare two strings, you do:

String stringOne = "Hello";
String stringTwo = "World";
stringOne.compareTo(stringTwo);
//Or you can do
stringTwo.compareTo(stringOne); 

You can’t compare a String to a String array like in your comment. You would have to take an element in this string array, and compare that (So stringArray[elementNumber]).

For counting how many words there are, if you are determining the number of repeated words, you would want to have an array of integers (So make a new int[]). Each place in the new int[] should correspond to the word in your array of words. This would allow you to count the number of times a word is repeated.

answered Sep 11, 2012 at 21:07

import java.util.ArrayList;
import java.util.regex.PatternSyntaxException;

import javax.swing.JOptionPane;

public class Main {

/**
 * @param args
 */
public static void main(String[] args) {

    //Print to screen
    System.out.println("Place:tWord:tCount: ");

    //User input dialog
    String inPut = JOptionPane.showInputDialog("Write som text here");

    //Puts it into an array, and split it with " ".
    String[] wordList;
    try{
        wordList = inPut.split(" ");
    }catch(PatternSyntaxException e) {
        // catch the buggy!
        System.out.println("Ooops.. "+e.getMessage());
        return;
    }catch(NullPointerException n) {
        System.out.println("cancelled! exitting..");
        return;
    }

    ArrayList<String> allWords = new ArrayList<String>();
    for(String word : wordList) {
        allWords.add(word);
    }

    // reset unique words counter
    int uniqueWordCount = 0;

    // Remove all of the words
    while(allWords.size() > 0) {
        // reset the word counter
        int count = 0;

        // get the next word
        String activeWord = allWords.get(0);

        // Remove all instances of this word
        while(doesContainThisWord(allWords, activeWord)) {
            allWords.remove(activeWord);
            count++;
        }

        // increase the unique word count;
        uniqueWordCount++;

        // print result.
        System.out.println(uniqueWordCount + "t" + activeWord + "t" + count );

    }

}

/**
 * This function returns true if the parameters are not null and the array contains an equal string to newWord.
 */
public static boolean doesContainThisWord(ArrayList<String> wordList, String newWord) {
    // Just checking...
    if (wordList == null || newWord == null) {
        return false;
    }

    // Loop through the list of words
    for (String oldWord : wordList) {
        if (oldWord.equals(newWord)) {
            // gotcha!
            return true;
        }
    }
    return false;
}

}

answered Sep 11, 2012 at 21:31

Here’s a solution using a map of WordInfo objects that records locations of the words within the text and uses that as a count. The LinkedHashMap preserves the order of keys from when they are first entered so simply iterating through the keys gives you the «cast in order of appearance»

You can make this case insensitive while preserving the case of the first appearance by storing all keys as lower case but storing the original case in the WordInfo object. Or just convert all words to lower case and leave it at that.
You may also want to think about removing all , / . / " etc from the first text before splitting, but you’ll never get that perfect anyway.

import java.util.LinkedHashMap;
import java.util.Map;

import javax.swing.JOptionPane;

public class MyWordCount {
    public static void main(String[] args) {

        //User input dialog
        String inPut = JOptionPane.showInputDialog("Write som text here");

        Map<String,WordInfo> wordMap = new LinkedHashMap<String,WordInfo>();

        //Puts it into an array, and split it with " ".
        String[] wordList = inPut.split(" ");

        for (int i = 0; i < wordList.length; i++) {
            String word = wordList[i];
            WordInfo wi = wordMap.get(word);
            if (wi == null) {
                wi = new WordInfo();            
            }
            wi.addPlace(i+1);
            wordMap.put(word,wi);           
        }

        //Print to screen

        System.out.println("Place:tWord:tCount: ");

        for (String word : wordMap.keySet()) {          

            WordInfo wi = wordMap.get(word);        
            System.out.println(wi.places() + "t" + word + "t" + wi.count());
        }

      }
}

And the WordInfo class:

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

public class WordInfo {

    private List<Integer> places;

    public WordInfo() {
        this.places = new ArrayList<>();
    }

    public void addPlace(int place) {
        this.places.add(place);
    }


    public int count() {
        return this.places.size();
    }

    public String places() {
        if (places.size() == 0)
            return "";

        String result = "";
        for (Integer place : this.places) {
            result += ", " + place;
        }
        result = result.substring(2, result.length());
        return result;
    }
}

answered Sep 11, 2012 at 22:57

Thanks for trying to help me. -This is what I ended up doing:

import java.util.ArrayList;

import javax.swing.JOptionPane;

public class MyWordCount {
public static void main(String[] args) {

    // Text in
    String inText = JOptionPane.showInputDialog("Write some text here");

    // Puts it into an array, and splits
    String[] wordlist = inText.split(" ");

    // Text out (Header)
    System.out.println("Place:tWord:tNo. of Words: ");

    // declare Arraylist for words
    ArrayList<String> wordEncounter = new ArrayList<String>();
    ArrayList<Integer> numberEncounter = new ArrayList<Integer>();

    // Checks number of encounters of words
    for (int i = 0; i < wordlist.length; i++) {
        String word = wordlist[i];

        // Make everything lowercase just for ease...
        word = word.toLowerCase();

        if (wordEncounter.contains(word)) {
            // Checks word encounter - return index of word
            int position = wordEncounter.indexOf(word);
            Integer number = numberEncounter.get(position);
            int number_int = number.intValue();
            number_int++;
            number = new Integer(number_int);
            numberEncounter.set(position, number);

            // Number of encounters - add 1;
        } else {
            wordEncounter.add(word);
            numberEncounter.add(new Integer(1));
        }

    }

    // Text out (the list of words)
    for (int i = 0; i < wordEncounter.size(); i++) {
        System.out.println(i + "t" + wordEncounter.get(i) + "t"
                + numberEncounter.get(i));
    }

  }
}

answered Sep 21, 2012 at 23:11