web-dev-qa-db-ja.com

文字列で繰り返される単語を見つけて、繰り返しを数える

文字列で繰り返される単語を見つけて、それらが繰り返された回数をカウントする必要があります。したがって、基本的に、入力文字列が次の場合:

String s = "House, House, House, Dog, Dog, Dog, Dog";

繰り返しのない新しい文字列リストを作成し、次のように各Wordの繰り返しの量を別の場所に保存する必要があります。

新しい文字列:「家、犬」

新しいInt配列:[3、4]

Javaでこれを簡単に行う方法はありますか?私はs.split()を使用して文字列を分離することができましたが、新しい文字列で繰り返しをカウントして排除するにはどうすればよいですか?ありがとう!

10
Hans

あなたは大変な仕事をしました。これで、Mapを使用して発生をカウントできます。

_Map<String, Integer> occurrences = new HashMap<String, Integer>();

for ( String Word : splitWords ) {
   Integer oldCount = occurrences.get(Word);
   if ( oldCount == null ) {
      oldCount = 0;
   }
   occurrences.put(Word, oldCount + 1);
}
_

map.get(Word)を使用すると、Wordが何度も発生したことがわかります。 map.keySet()を繰り返し処理して、新しいリストを作成できます。

_for ( String Word : occurrences.keySet() ) {
  //do something with Word
}
_

keySetから取得する順序は任意です。入力文字列に最初に現れるときに単語を並べ替える必要がある場合は、代わりにLinkedHashMapを使用する必要があります。

22
Mark Peters

他の人が述べたように、String :: split()を使用し、その後にマップ(ハッシュマップまたはリンクされたハッシュマップ)を続けて、結果をマージします。完全を期すために、コードを配置します。

import Java.util.*;

public class Genric<E>
{
    public static void main(String[] args) 
    {
        Map<String, Integer> unique = new LinkedHashMap<String, Integer>();
        for (String string : "House, House, House, Dog, Dog, Dog, Dog".split(", ")) {
            if(unique.get(string) == null)
                unique.put(string, 1);
            else
                unique.put(string, unique.get(string) + 1);
        }
        String uniqueString = join(unique.keySet(), ", ");
        List<Integer> value = new ArrayList<Integer>(unique.values());

        System.out.println("Output = " + uniqueString);
        System.out.println("Values = " + value);

    }

    public static String join(Collection<String> s, String delimiter) {
        StringBuffer buffer = new StringBuffer();
        Iterator<String> iter = s.iterator();
        while (iter.hasNext()) {
            buffer.append(iter.next());
            if (iter.hasNext()) {
                buffer.append(delimiter);
            }
        }
        return buffer.toString();
    }
}

新しい文字列はOutput = House, Dog

Int配列(またはリスト)Values = [3, 4](List :: toArrayを使用できます)配列を取得します。

3
Favonius

これを試して、

public class DuplicateWordSearcher {
@SuppressWarnings("unchecked")
public static void main(String[] args) {

    String text = "a r b k c d se f g a d f s s f d s ft gh f ws w f v x s g h d h j j k f sd j e wed a d f";

    List<String> list = Arrays.asList(text.split(" "));

    Set<String> uniqueWords = new HashSet<String>(list);
    for (String Word : uniqueWords) {
        System.out.println(Word + ": " + Collections.frequency(list, Word));
    }
}

}

3
Puja Mishra
public class StringsCount{

    public static void main(String args[]) {

        String value = "This is testing Program testing Program";

        String item[] = value.split(" ");

        HashMap<String, Integer> map = new HashMap<>();

        for (String t : item) {
            if (map.containsKey(t)) {
                map.put(t, map.get(t) + 1);

            } else {
                map.put(t, 1);
            }
        }
        Set<String> keys = map.keySet();
        for (String key : keys) {
            System.out.println(key);
            System.out.println(map.get(key));
        }

    }
}
2
javaCode555

Java8を使用する

private static void findWords(String s, List<String> output, List<Integer> count){
    String[] words = s.split(", ");
    Map<String, Integer> map = new LinkedHashMap<>();
    Arrays.stream(words).forEach(e->map.put(e, map.getOrDefault(e, 0) + 1));
    map.forEach((k,v)->{
        output.add(k);
        count.add(v);
    });
}

また、挿入の順序を保持する場合は、LinkedHashMapを使用します

private static void findWords(){
    String s = "House, House, House, Dog, Dog, Dog, Dog";
    List<String> output = new ArrayList<>();
    List<Integer> count = new ArrayList<>();
    findWords(s, output, count);
    System.out.println(output);
    System.out.println(count);
}

出力

[House, Dog]
[3, 4]
2
Ankit Sharma

それはどういうわけかあなたを助けるかもしれません。

String st="I am am not the one who is thinking I one thing at time";
String []ar = st.split("\\s");
Map<String, Integer> mp= new HashMap<String, Integer>();
int count=0;

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

    for(int j=0;j<ar.length;j++){
        if(ar[i].equals(ar[j])){
        count++;                
        }
    }

    mp.put(ar[i], count);
}

System.out.println(mp);
1
RKP
public static void main(String[] args) {
    String s="sdf sdfsdfsd sdfsdfsd sdfsdfsd sdf sdf sdf ";
    String st[]=s.split(" ");
    System.out.println(st.length);
    Map<String, Integer> mp= new TreeMap<String, Integer>();
    for(int i=0;i<st.length;i++){

        Integer count=mp.get(st[i]);
        if(count == null){
            count=0;
        }           
        mp.put(st[i],++count);
    }
   System.out.println(mp.size());
   System.out.println(mp.get("sdfsdfsd"));


}

プレフィックスツリー(トライ)データ構造を使用して、単語を格納し、プレフィックスツリーノード内の単語の数を追跡できます。

  #define  ALPHABET_SIZE 26
  // Structure of each node of prefix tree
  struct prefix_tree_node {
    prefix_tree_node() : count(0) {}
    int count;
    prefix_tree_node *child[ALPHABET_SIZE];
  };
  void insert_string_in_prefix_tree(string Word)
  {
    prefix_tree_node *current = root;
    for(unsigned int i=0;i<Word.size();++i){
      // Assuming it has only alphabetic lowercase characters
            // Note ::::: Change this check or convert into lower case
    const unsigned int letter = static_cast<int>(Word[i] - 'a');

      // Invalid alphabetic character, then continue
      // Note :::: Change this condition depending on the scenario
      if(letter > 26)
        throw runtime_error("Invalid alphabetic character");

      if(current->child[letter] == NULL)
        current->child[letter] = new prefix_tree_node();

      current = current->child[letter];
    }
  current->count++;
  // Insert this string into Max Heap and sort them by counts
}

    // Data structure for storing in Heap will be something like this
    struct MaxHeapNode {
       int count;
       string Word;
    };

すべての単語を挿入した後、Wordを印刷し、Maxheapを繰り返してカウントする必要があります。

0
Dev Null Fin

Java 8ストリーム コレクター

public static Map<String, Integer> countRepetitions(String str) {
    return Arrays.stream(str.split(", "))
        .collect(Collectors.toMap(s -> s, s -> 1, (a, b) -> a + 1));
}

入力:"House, House, House, Dog, Dog, Dog, Dog, Cat"

出力:{Cat=1, House=3, Dog=4}

0
panibrat
package string;

import Java.util.HashMap;
import Java.util.Map;
import Java.util.Set;

public class DublicatewordinanArray {
public static void main(String[] args) {
String str = "This is Dileep Dileep Kumar Verma Verma";
DuplicateString(str);
    }
public static void DuplicateString(String str) {
String Word[] = str.split(" ");
Map < String, Integer > map = new HashMap < String, Integer > ();
for (String w: Word)
if (!map.containsKey(w)) {
map.put(w, 1);
    }
else {
map.put(w, map.get(w) + 1);
        }
Set < Map.Entry < String, Integer >> entrySet = map.entrySet();
 for (Map.Entry < String, Integer > entry: entrySet)
if (entry.getValue() > 1) {
 System.out.printf("%s : %d %n", entry.getKey(), entry.getValue());
}
 }
}
0
Dileep Verma

これが宿題の場合、言えるのは、String.split()HashMap<String,Integer>

(split()がすでに見つかっているのがわかります。その時点で正しい線に沿っています。)

0
biziclop

Collectors.groupingBy内でFunction.identity()を使用し、すべてをMAPに保存します。

String a  = "Gini Gina Gina Gina Gina Protijayi Protijayi "; 
        Map<String, Long> map11 = Arrays.stream(a.split(" ")).collect(Collectors
                .groupingBy(Function.identity(),Collectors.counting()));
        System.out.println(map11);
// output => {Gina=4, Gini=1, Protijayi=2}
0
Soudipta Dutta
    public static void main(String[] args){
    String string = "elamparuthi, elam, elamparuthi";
    String[] s = string.replace(" ", "").split(",");
    String[] op;
    String ops = "";

    for(int i=0; i<=s.length-1; i++){
        if(!ops.contains(s[i]+"")){
            if(ops != "")ops+=", "; 
            ops+=s[i];
        }

    }
    System.out.println(ops);
}
0
Elamparuthi

お役に立てれば :

public static int countOfStringInAText(String stringToBeSearched, String masterString){

    int count = 0;
    while (masterString.indexOf(stringToBeSearched)>=0){
      count = count + 1;
      masterString = masterString.substring(masterString.indexOf(stringToBeSearched)+1);
    }
    return count;
}
0
Akhil

以下のコードを使用してください。私の分析によると最も簡単です。あなたがそれを好きになることを願っています:

import Java.util.Arrays;
import Java.util.Collections;
import Java.util.HashMap;
import Java.util.HashSet;
import Java.util.List;
import Java.util.Scanner;
import Java.util.Set;

public class MostRepeatingWord {

    String mostRepeatedWord(String s){
        String[] splitted = s.split(" ");
        List<String> listString = Arrays.asList(splitted);
        Set<String> setString = new HashSet<String>(listString);
        int count = 0;
        int maxCount = 1;
        String maxRepeated = null;
        for(String inp: setString){
            count = Collections.frequency(listString, inp);
            if(count > maxCount){
                maxCount = count;
                maxRepeated = inp;
            }
        }
        return maxRepeated;
    }
    public static void main(String[] args) 
    {       
        System.out.println("Enter The Sentence: ");
        Scanner s = new Scanner(System.in);
        String input = s.nextLine();
        MostRepeatingWord mrw = new MostRepeatingWord();
        System.out.println("Most repeated Word is: " + mrw.mostRepeatedWord(input));

    }
}
0
Tarun Majumder

これがお役に立てば幸いです

public void countInPara(String str){

    Map<Integer,String> strMap = new HashMap<Integer,String>();
    List<String> paraWords = Arrays.asList(str.split(" "));
    Set<String> strSet = new LinkedHashSet<>(paraWords);
    int count;

    for(String Word : strSet) {
        count = Collections.frequency(paraWords, Word);
        strMap.put(count, strMap.get(count)==null ? Word : strMap.get(count).concat(","+Word));
    }

    for(Map.Entry<Integer,String> entry : strMap.entrySet())
        System.out.println(entry.getKey() +" :: "+ entry.getValue());
}
0
Harshit Thacker
import Java.util.ArrayList;
import Java.util.Arrays;
import Java.util.HashMap;
import Java.util.HashSet;
import Java.util.List;
import Java.util.Map;
import Java.util.Set;

public class DuplicateWord {

    public static void main(String[] args) {
        String para = "this is what it is this is what it can be";
        List < String > paraList = new ArrayList < String > ();
        paraList = Arrays.asList(para.split(" "));
        System.out.println(paraList);
        int size = paraList.size();

        int i = 0;
        Map < String, Integer > duplicatCountMap = new HashMap < String, Integer > ();
        for (int j = 0; size > j; j++) {
            int count = 0;
            for (i = 0; size > i; i++) {
                if (paraList.get(j).equals(paraList.get(i))) {
                    count++;
                    duplicatCountMap.put(paraList.get(j), count);
                }

            }

        }
        System.out.println(duplicatCountMap);
        List < Integer > myCountList = new ArrayList < > ();
        Set < String > myValueSet = new HashSet < > ();
        for (Map.Entry < String, Integer > entry: duplicatCountMap.entrySet()) {
            myCountList.add(entry.getValue());
            myValueSet.add(entry.getKey());
        }
        System.out.println(myCountList);
        System.out.println(myValueSet);
    }

}

入力:これはこれです

出力:

[これ、ある、何、それ、ある、これ、ある、何、それ、できる、]

{can = 1、what = 2、be = 1、this = 2、is = 3、it = 2}

[1、2、1、2、3、2]

[できる、何、これ、これ、それ]

0
//program to find number of repeating characters in a string
//Developed by Subash<[email protected]>


import Java.util.Scanner;

public class NoOfRepeatedChar

{

   public static void main(String []args)

   {

//input through key board

Scanner sc = new Scanner(System.in);

System.out.println("Enter a string :");

String s1= sc.nextLine();


    //formatting String to char array

    String s2=s1.replace(" ","");
    char [] ch=s2.toCharArray();

    int counter=0;

    //for-loop tocompare first character with the whole character array

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

        for(int j=0;j<ch.length;j++)
        {
             if(ch[i]==ch[j])
                count++; //if character is matching with others
        }
        if(count>1)
        {
            boolean flag=false;

            //for-loop to check whether the character is already refferenced or not 
            for (int k=i-1;k>=0 ;k-- )
            {
                if(ch[i] == ch[k] ) //if the character is already refferenced
                    flag=true;
            }
            if( !flag ) //if(flag==false) 
                counter=counter+1;
        }
    }
    if(counter > 0) //if there is/are any repeating characters
            System.out.println("Number of repeating charcters in the given string is/are " +counter);
    else
            System.out.println("Sorry there is/are no repeating charcters in the given string");
    }
}
0
subash

文字列から単語を取得したら、それは簡単です。 Java 10以降では、次のコードを試すことができます。

import Java.util.Arrays;
import Java.util.stream.Collectors;

public class StringFrequencyMap {
    public static void main(String... args) {
        String[] wordArray = {"House", "House", "House", "Dog", "Dog", "Dog", "Dog"};
        var freq = Arrays.stream(wordArray)
                         .collect(Collectors.groupingBy(x -> x, Collectors.counting()));
        System.out.println(freq);
    }
}

出力:

{House=3, Dog=4}
0
user2173372
import Java.util.HashMap;
import Java.util.Scanner;
public class class1 {
public static void main(String[] args) {
    Scanner in = new Scanner(System.in);
    String inpStr = in.nextLine();
    int key;

    HashMap<String,Integer> hm = new HashMap<String,Integer>();
    String[] strArr = inpStr.split(" ");

    for(int i=0;i<strArr.length;i++){
        if(hm.containsKey(strArr[i])){
            key = hm.get(strArr[i]);
            hm.put(strArr[i],key+1);

        }
        else{
            hm.put(strArr[i],1);
        }   
    }
    System.out.println(hm);
}

}

0
chirag kansal

String引数を渡すと、各Wordの繰り返しをカウントします

/**
 * @param string
 * @return map which contain the Word and value as the no of repatation
 */
public Map findDuplicateString(String str) {
    String[] stringArrays = str.split(" ");
    Map<String, Integer> map = new HashMap<String, Integer>();
    Set<String> words = new HashSet<String>(Arrays.asList(stringArrays));
    int count = 0;
    for (String Word : words) {
        for (String temp : stringArrays) {
            if (Word.equals(temp)) {
                ++count;
            }
        }
        map.put(Word, count);
        count = 0;
    }

    return map;

}

出力:

 Word1=2, Word2=4, Word2=1,. . .
0
loknath
package day2;

import Java.util.ArrayList;
import Java.util.HashMap;`enter code here`
import Java.util.List;

public class DuplicateWords {

    public static void main(String[] args) {
        String S1 = "House, House, House, Dog, Dog, Dog, Dog";
        String S2 = S1.toLowerCase();
        String[] S3 = S2.split("\\s");

        List<String> a1 = new ArrayList<String>();
        HashMap<String, Integer> hm = new HashMap<>();

        for (int i = 0; i < S3.length - 1; i++) {

            if(!a1.contains(S3[i]))
            {
                a1.add(S3[i]);
            }
            else
            {
                continue;
            }

            int Count = 0;

            for (int j = 0; j < S3.length - 1; j++)
            {
                if(S3[j].equals(S3[i]))
                {
                    Count++;
                }
            }

            hm.put(S3[i], Count);
        }

        System.out.println("Duplicate Words and their number of occurrences in String S1 : " + hm);
    }
}
0
Manikanta Bondu
public class Counter {

private static final int COMMA_AND_SPACE_PLACE = 2;

private String mTextToCount;
private ArrayList<String> mSeparateWordsList;

public Counter(String mTextToCount) {
    this.mTextToCount = mTextToCount;

    mSeparateWordsList = cutStringIntoSeparateWords(mTextToCount);
}

private ArrayList<String> cutStringIntoSeparateWords(String text)
{
    ArrayList<String> returnedArrayList = new ArrayList<>();


    if(text.indexOf(',') == -1)
    {
        returnedArrayList.add(text);
        return returnedArrayList;
    }

    int position1 = 0;
    int position2 = 0;

    while(position2 < text.length())
    {
        char c = ',';
        if(text.toCharArray()[position2] == c)
        {
            String tmp = text.substring(position1, position2);
            position1 += tmp.length() + COMMA_AND_SPACE_PLACE;
            returnedArrayList.add(tmp);
        }
        position2++;
    }

    if(position1 < position2)
    {
        returnedArrayList.add(text.substring(position1, position2));
    }

    return returnedArrayList;
}

public int[] countWords()
{
    if(mSeparateWordsList == null) return null;


    HashMap<String, Integer> wordsMap = new HashMap<>();

    for(String s: mSeparateWordsList)
    {
        int cnt;

        if(wordsMap.containsKey(s))
        {
            cnt = wordsMap.get(s);
            cnt++;
        } else {
            cnt = 1;
        }
        wordsMap.put(s, cnt);
    }                
    return printCounterResults(wordsMap);
}

private int[] printCounterResults(HashMap<String, Integer> m)
{        
    int index = 0;
    int[] returnedIntArray = new int[m.size()];

    for(int i: m.values())
    {
        returnedIntArray[index] = i;
        index++;
    }

    return returnedIntArray;

}

}

//program to find number of repeating characters in a string
//Developed by Rahul Lakhmara

import Java.util.*;

public class CountWordsInString {
    public static void main(String[] args) {
        String original = "I am rahul am i sunil so i can say am i";
        // making String type of array
        String[] originalSplit = original.split(" ");
        // if Word has only one occurrence
        int count = 1;
        // LinkedHashMap will store the Word as key and number of occurrence as
        // value
        Map<String, Integer> wordMap = new LinkedHashMap<String, Integer>();

        for (int i = 0; i < originalSplit.length - 1; i++) {
            for (int j = i + 1; j < originalSplit.length; j++) {
                if (originalSplit[i].equals(originalSplit[j])) {
                    // Increment in count, it will count how many time Word
                    // occurred
                    count++;
                }
            }
            // if Word is already present so we will not add in Map
            if (wordMap.containsKey(originalSplit[i])) {
                count = 1;
            } else {
                wordMap.put(originalSplit[i], count);
                count = 1;
            }
        }

        Set Word = wordMap.entrySet();
        Iterator itr = Word.iterator();
        while (itr.hasNext()) {
            Map.Entry map = (Map.Entry) itr.next();
            // Printing
            System.out.println(map.getKey() + " " + map.getValue());
        }
    }
}
0
Rahul Lakhmara
/*count no of Word in String using TreeMap we can use HashMap also but Word will not display in sorted order */

import Java.util.*;

public class Genric3
{
    public static void main(String[] args) 
    {
        Map<String, Integer> unique = new TreeMap<String, Integer>();
        String string1="Ram:Ram: Dog: Dog: Dog: Dog:leela:leela:house:house:shayam";
        String string2[]=string1.split(":");

        for (int i=0; i<string2.length; i++)
        {
            String string=string2[i];
            unique.put(string,(unique.get(string) == null?1:(unique.get(string)+1)));
        }

        System.out.println(unique);
    }
}      
0
Dalee Bisen

スペースのない文字列の場合、以下のコードを使用できます

private static void findRecurrence(String input) {
    final Map<String, Integer> map = new LinkedHashMap<>();
    for(int i=0; i<input.length(); ) {
        int pointer = i;
        int startPointer = i;
        boolean pointerHasIncreased = false;
        for(int j=0; j<startPointer; j++){
            if(pointer<input.length() && input.charAt(j)==input.charAt(pointer) && input.charAt(j)!=32){
                pointer++;
                pointerHasIncreased = true;
            }else{
                if(pointerHasIncreased){
                    break;
                }
            }
        }
        if(pointer - startPointer >= 2) {
            String Word = input.substring(startPointer, pointer);
            if(map.containsKey(Word)){
                map.put(Word, map.get(Word)+1);
            }else{
                map.put(Word, 1);
            }
            i=pointer;
        }else{
            i++;
        }
    }
    for(Map.Entry<String, Integer> entry : map.entrySet()){
        System.out.println(entry.getKey() + " = " + (entry.getValue()+1));
    }
}

「hahaha」または「ba na na」または「xxxyyyzzzxxxzzz」として一部の入力を渡すと、目的の出力が得られます。

0
Puneet Akhouri
import Java.util.HashMap;
import Java.util.LinkedHashMap;

public class CountRepeatedWords {

    public static void main(String[] args) {
          countRepeatedWords("Note that the order of what you get out of keySet is arbitrary. If you need the words to be sorted by when they first appear in your input String, you should use a LinkedHashMap instead.");
    }

    public static void countRepeatedWords(String wordToFind) {
        String[] words = wordToFind.split(" ");
        HashMap<String, Integer> wordMap = new LinkedHashMap<String, Integer>();

        for (String Word : words) {
            wordMap.put(Word,
                (wordMap.get(Word) == null ? 1 : (wordMap.get(Word) + 1)));
        }

            System.out.println(wordMap);
    }

}
0
Purushotham