Como contar a frequência de caracteres em uma string?

Eu preciso escrever algum tipo de loop que pode contar a freqüência de cada letra em uma string.
Por exemplo: “aasjjikkk” contaria 2 ‘a’, 1 ‘s’, 2 ‘j’, 1 ‘i’, 3 ‘k’. Em última análise, id como estes para acabar em um mapa com o caractere como a chave e a contagem como o valor. Alguma boa ideia de como fazer isso?

Você pode usar um mapa java e mapear um char para um int . Você pode, então, iterar sobre os caracteres na string e verificar se eles foram adicionados ao mapa, se tiverem, você pode incrementar seu valor.

Por exemplo:

 HashMap map = new HashMap(); String s = "aasjjikkk"; for (int i = 0; i < s.length(); i++) { char c = s.charAt(i); Integer val = map.get(c); if (val != null) { map.put(c, new Integer(val + 1)); } else { map.put(c, 1); } } 

No final, você terá uma contagem de todos os personagens que encontrou e poderá extrair suas frequências disso.

Alternativamente, você pode usar a solução da Bozho de usar um Multiset e contar o total de ocorrências.

Você pode usar um Multiset (de goiaba ). Isso lhe dará a contagem de cada object. Por exemplo:

 Multiset chars = HashMultiset.create(); for (int i = 0; i < string.length(); i++) { chars.add(string.charAt(i)); } 

Então, para cada personagem, você pode chamar chars.count('a') e retornar o número de ocorrências

Aqui está outra solução, desonesta como pode ser.

 public char getNumChar(String s) { char[] c = s.toCharArray(); String alphabet = "abcdefghijklmnopqrstuvwxyz"; int[] countArray = new int[26]; for (char x : c) { for (int i = 0; i < alphabet.length(); i++) { if (alphabet.charAt(i) == x) { countArray[i]++; } } } java.util.HashMap countList = new java.util.HashMap(); for (int i = 0; i < 26; i++) { countList.put(countArray[i], alphabet.charAt(i)); } java.util.Arrays.sort(countArray); int max = countArray[25]; return countList.get(max); } 

Uma maneira concisa de fazer isso é:

 Map frequencies = new HashMap<>(); for (char ch : input.toCharArray()) frequencies.put(ch, frequencies.getOrDefault(ch, 0) + 1); 

Usamos um for-each para percorrer todos os personagens. O frequencies.getOrDefault() obtém valor se a chave estiver presente ou retornar (como padrão) seu segundo argumento.

Bem, duas maneiras vêm à mente e depende da sua preferência:

  1. Classifique o array por caracteres. Então, contar cada personagem se torna trivial. Mas você terá que fazer uma cópia da matriz primeiro.

  2. Crie outro array inteiro de tamanho 26 (digamos freq) e str é o array de caracteres.

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

    freq[str[i] - 'a'] ++; //Assuming all characters are in lower case

Então o número de 'a' será armazenado em freq [0] e o número de 'z' será em freq [25]

Aqui está uma solução:

Defina seu próprio Pair :

 public class Pair { private char letter; private int count; public Pair(char letter, int count) { this.letter = letter; this.count= count; } public char getLetter(){return key;} public int getCount(){return count;} } 

Então você poderia fazer:

 public static Pair countCharFreq(String s) { String temp = s; java.util.List list = new java.util.ArrayList(); while(temp.length() != 0) { list.add(new Pair(temp.charAt(0), countOccurrences(temp, temp.charAt(0)))); temp.replaceAll("[" + temp.charAt(0) +"]",""); } } public static int countOccurrences(String s, char c) { int count = 0; for(int i = 0; i < s.length(); i++) { if(s.charAt(i) == c) count++; } return count; } 

Você pode usar um CharAdapter e um CharBag de Eclipse Collections e evitar o boxe para Character e Integer .

 CharBag bag = CharAdapter.adapt("aasjjikkk").toBag(); Assert.assertEquals(2, bag.occurrencesOf('a')); Assert.assertEquals(1, bag.occurrencesOf('s')); Assert.assertEquals(2, bag.occurrencesOf('j')); Assert.assertEquals(1, bag.occurrencesOf('i')); Assert.assertEquals(3, bag.occurrencesOf('k')); 

Nota: Eu sou um committer para collections do Eclipse.

Usando a API de stream do JDK-8:

 Map frequency = str.chars() .mapToObj(c -> (char)c) .collect(Collectors.groupingBy(Function.identity(), Collectors.counting())); 

ou se você quiser as chaves como inteiros:

 Map frequency = str.chars() .mapToObj(c -> (char)c) .collect(Collectors.groupingBy(Function.identity(), Collectors.summingInt(c -> 1))); 

Outra variante:

 Map frequency = str.chars() .mapToObj(c -> (char)c) .collect(Collectors.toMap(Function.identity(), c -> 1, Math::addExact)); 

Como não havia solução Java 8, pensamos em postar um. Além disso, esta solução é muito mais clara, legível e concisa do que algumas das outras soluções mencionadas aqui.

 String string = "aasjjikkk"; Map characterFrequency = string.chars() // creates an IntStream .mapToObj(c -> (char) c) // converts the IntStream to Stream .collect(Collectors.groupingBy(c -> c, Collectors.counting())); // creates a // Map // where the Long is // the frequency 

Se isso não precisa ser super-rápido, basta criar uma matriz de inteiros, um inteiro para cada letra (apenas alfabético, então 2 * 26 inteiros? Ou qualquer dado binário possível?). passar pela string um caractere por vez, obter o índice do inteiro responsável (por exemplo, se você tiver apenas caracteres alfabéticos, pode ter ‘A’ no índice 0 e obter esse índice subtraindo qualquer ‘A’ a ‘Z’ por ‘A’ apenas como um exemplo de como você pode obter índices razoavelmente rápidos) e incrementar o valor nesse índice.

Existem várias micro-otimizações para tornar isso mais rápido (se necessário).

Você pode usar uma Hashtable com cada caractere como a chave e a contagem total se torna o valor.

 Hashtable table = new Hashtable(); String str = "aasjjikkk"; for( c in str ) { if( table.get(c) == null ) table.put(c,1); else table.put(c,table.get(c) + 1); } for( elem in table ) { println "elem:" + elem; } 

Isso é semelhante à resposta de xunil154, exceto pelo fato de que uma string é feita com uma matriz char e um hashmap vinculado é usado para manter a ordem de inserção dos caracteres.

 String text = "aasjjikkk"; char[] charArray = text.toCharArray(); Map freqList = new LinkedHashMap(); for(char key : charArray) { if(freqList.containsKey(key)) { freqList.put(key, freqList.get(key) + 1); } else freqList.put(key, 1); } 
 NOTE, this will also count the frequencies of empty spaces import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Map.Entry; import java.util.Scanner; public class FrequenceyOfCharacters { public static void main(String[] args) { System.out.println("Please enter the string to count each character frequencey: "); Scanner sc=new Scanner(System.in); String input=sc.nextLine(); frequenceyCount(input); } private static void frequenceyCount(String input) { Map hashCount=new HashMap<>(); Character c; for(int i=0; i 
 import java.util.*; class Charfrequency { public static void main(String a[]){ Scanner sc=new Scanner(System.in); System.out.println("Enter Your String :"); String s1=sc.nextLine(); int count,j=1; char var='a'; char ch[]=s1.toCharArray(); while(j< =26) { count=0; for(int i=0; i0){ System.out.println("Frequency of "+var+" is "+count); } var++; j++; } } } 
 package com.rishi.zava; import java.util.HashMap; import java.util.Map; import java.util.Map.Entry; public class ZipString { public static void main(String arg[]) { String input = "aaaajjjgggtttssvvkkllaaiiikk"; int len = input.length(); Map zip = new HashMap(); for (int j = 0; len > j; j++) { int count = 0; for (int i = 0; len > i; i++) { if (input.charAt(j) == input.charAt(i)) { count++; } } zip.put(input.charAt(j), count); } StringBuffer myValue = new StringBuffer(); String myMapKeyValue = ""; for (Entry entry : zip.entrySet()) { myMapKeyValue = Character.toString(entry.getKey()).concat( Integer.toString(entry.getValue())); myValue.append(myMapKeyValue); } System.out.println(myValue); } } 

Entrada = aaaajjjgggtttssvvkkllaaiiikk

Saída = a6s2t3v2g3i3j3k4l2

O código possível em curto usando um HashMap. (Sem linha forte salva)

 private static Map findCharacterFrequency(String str) { Map map = new HashMap<>(); for (char ch : str.toCharArray()) { /* Using getOrDefault(), since Java1.8 */ map.put(ch, map.getOrDefault(ch, 0) + 1); } return map; } 

Por favor, tente o código abaixo, espero que seja útil para você,

 import java.util.Scanner; class String55 { public static int frequency(String s1,String s2) { int count=0; char ch[]=s1.toCharArray(); char ch1[]=s2.toCharArray(); for (int i=0;i 

SAMPLE OUTPUT: insira o padrão man insira o String dhimanman FREQUENCY == 2

Codificação Thank-you.Happy.

 import java.io.FileInputStream; import java.util.HashSet; import java.util.Iterator; public class CountFrequencyOfCharater { public static void main(String args[]) throws Exception { HashSet hs=new HashSet(); String str="hey how are you?"; char arr[]=new char[str.length()]; for(int i=0;i