Trovare parole ripetute su una stringa e contare le ripetizioni

Question

Ho bisogno di trovare le parole ripetute su una stringa e quindi di contare quante volte sono state ripetute. Quindi, fondamentalmente, se la stringa di input è questo:

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

Ho bisogno di creare un nuovo elenco di stringa senza ripetizioni e salvare qualche altra parte la quantità di ripetizioni per ogni parola, come ad esempio:

Nuova stringa: " casa, Cane"

Nuovo Int Array: [3, 4]

c'è un modo per farlo facilmente con Java? Sono riuscito a separare la stringa usando s.split(), ma come faccio a contare le ripetizioni ed eliminarle sulla nuova stringa? Grazie!

Answer 1

Hai fatto il duro lavoro. Ora si può semplicemente utilizzare un Map per contare le occorrenze:

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); 
} 

Utilizzando map.get(word) vi dirà molte volte si è verificato una sola parola. È possibile costruire un nuovo elenco scorrendo map.keySet():

for (String word : occurrences.keySet()) { 
    //do something with word 
} 

Nota che l'ordine di ciò che si ottiene da keySet è arbitraria. Se hai bisogno che le parole vengano ordinate quando appaiono per la prima volta nella stringa di input, dovresti utilizzare invece lo LinkedHashMap.

Answer 2

Se si tratta di un compito a casa, quindi tutto quello che posso dire è: utilizzare String.split() e HashMap<String,Integer>.

(vedo che hai trovato split() già. Sei nella giusta direzione, allora.)

Answer 3

Come detto da altri usano String :: split(), seguita da alcuni mappa (HashMap o LinkedHashMap) e quindi unisci il risultato. Per completezza, inserire il codice.

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(); 
    } 
} 

Nuova stringa è Output = House, Dog

Int array (o meglio lista) Values = [3, 4] (si può usare List :: toArray) per ottenere un array.

Answer 4

/*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); 
    } 
}  

Answer 5

È possibile utilizzare la struttura dati Prefix tree (trie) per memorizzare parole e tenere traccia del conteggio delle parole all'interno del prefisso Tree prefisso.

#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; 
    }; 

Dopo aver inserito tutte le parole, è necessario stampare parola e contare iterando Maxheap.

Answer 6

//program to find number of repeating characters in a string 
//Developed by Subash<subash_senapati@ymail.com> 


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"); 
    } 
} 

Answer 7

Prova questo,

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)); 
    } 
} 

}

Answer 8

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")); 


} 

Answer 9

Se si passa un argomento String conterà la ripetizione di ogni parola

/** 
* @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; 

} 

uscita:

Word1=2, word2=4, word2=1,. . . 

Answer 10

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); 
    } 

} 

Answer 11

Spero che questo vi aiuterà a

pubblico countInPara void (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()); 
} 

Answer 12

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)); 
     } 

    } 
} 

Answer 13

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); 
    } 

} 

ingresso: questo è quello che è questo è cosa può essere

uscita:

[questo, è, cosa, è, è, questo, è, quello, che, può, essere]

{può = 1, che cosa = 2, sarà = 1, questo = 2, è = 3, it = 2}

[1, 2, 1, 2, 3, 2]

[può, ciò, essere, questo, è,]

Answer 14

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); 
} 

}

Answer 15

Si prega di utilizzare il seguente codice. È il più semplice secondo la mia analisi. Spero che vi piacerà:

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)); 

    } 
} 

Answer 16

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); 
    } 
} 

Answer 17

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; 

} 

}

Answer 18

//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()); 
     } 
    } 
} 

Answer 19

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); 
} 

Answer 20

Essa può aiutare in qualche modo.

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); 

Answer 21

Qui, i passaggi per il conteggio parole utilizzate in una stringa

1. Crea vuoto HashMap di tipo String & intero
2. dividere la stringa utilizzando spazio un delimitatore ed assegnare a String []
3. Iterate attraverso l'array String [] dopo la divisione utilizzando il ciclo for-each
4. Nota: convertiremo tutte le stringhe in minuscolo prima di cercare case-insensit ive scopo
5. Controllare se particolare parola è già presente nel HashMap utilizzando il metodo di Map
containsKey (k) il metodo di interfaccia Map
6. Se contiene, quindi aumentare il valore di conteggio da 1 utilizzando put (K, V)
7. Altrimenti inserire utilizzando il metodo put() di Mappa con valore di conteggio da 1
8. Infine, stampa Mappa utilizzando keySet() o entrySet() metodo di Map.Entry interfaccia

Il programma completo è po 'lungo, come sta leggendo il contenuto della stringa dal file locale. È possibile controllare articolo sul link qui sotto incollato

http://www.benchresources.net/count-and-print-number-of-repeated-word-occurrences-in-a-string-in-java/

Answer 22

For Strings senza spazio, siamo in grado di utilizzare il sotto menzionato codice di

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)); 
    } 
} 

Passando qualche input come "hahaha" o "ba na na "o" xxxyyyzzzxxxzzz "fornisce l'output desiderato.