¿Cómo contar la frecuencia de los caracteres en una cadena?

Necesito escribir algún tipo de ciclo que pueda contar la frecuencia de cada letra en una cadena.
Por ejemplo: “aasjjikkk” contaría 2 ‘a’, 1 ‘s’, 2 ‘j’, 1 ‘i’, 3 ‘k’. En definitiva, id como estos para terminar en un mapa con el personaje como clave y el recuento como valor. ¿Alguna buena idea de cómo hacer esto?

Puede usar un mapa de Java y asignar un char a un int . Luego puede iterar sobre los caracteres en la cadena y verificar si se han agregado al mapa, si es así, puede incrementar su valor.

Por ejemplo:

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

Al final contarás todos los personajes que encontraste y podrás extraer sus frecuencias de eso.

Alternativamente, puede usar la solución de Bozho de usar un Multiset y contar las ocurrencias totales.

Puedes usar un Multiset (de guayaba ). Te dará el conteo de cada objeto. Por ejemplo:

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

Luego, para cada personaje, puede llamar a chars.count('a') y devuelve el número de apariciones

Aquí hay otra solución, por más dudosa que pueda 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); } 

Una forma concisa de hacer esto es:

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

Usamos un for-each para recorrer cada personaje. frequencies.getOrDefault() obtiene valor si la clave está presente o devuelve (de manera predeterminada) su segundo argumento.

Bueno, dos maneras vienen a la mente y depende de tu preferencia:

  1. Ordenar la matriz por caracteres. Entonces, contar cada personaje se vuelve trivial. Pero primero tendrá que hacer una copia de la matriz.

  2. Cree otra matriz entera de tamaño 26 (digamos freq) y str es la matriz de caracteres.

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

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

Entonces, el número de 'a' 'se almacenará en la frecuencia [0] y el número de' z '' estará en la frecuencia [25]

Aquí hay una solución:

Defina su propio 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;} } 

Entonces podrías hacer:

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

Puede usar CharAdapter y CharBag de Eclipse Collections y evitar el boxeo en 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: soy un committer para las colecciones de Eclipse.

Usando la API de transmisión a partir de JDK-8:

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

o si quieres las claves como Enteros:

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

Otra variante:

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

Como no había una solución Java 8, se pensó en publicar una. Además, esta solución es mucho más ordenada, legible y concisa que algunas de las otras soluciones mencionadas aquí.

 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 

Si no es necesario que sea súper rápido, simplemente cree una matriz de enteros, un número entero para cada letra (solo alfabético, por lo tanto, ¿números enteros 2 * 26? O ¿hay datos binarios posibles?). ir a través de la cadena de un char a la vez, obtener el índice del entero responsable (por ejemplo, si solo tiene caracteres alfabéticos puede tener ‘A’ en el índice 0 y obtener ese índice restando cualquier ‘A’ a ‘Z’ ‘A’ solo como un ejemplo de cómo puede obtener índices razonablemente rápidos) e incrementar el valor en ese índice.

Hay varias micro optimizaciones para hacer esto más rápido (si es necesario).

Puede usar una Hashtable con cada carácter como la clave y el recuento total se convierte en el 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; } 

Esto es similar a la respuesta de xunil154, excepto que una cadena se convierte en una matriz de caracteres y una hoja de direcciones enlazada se utiliza para mantener el orden de inserción de los 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

Salida = a6s2t3v2g3i3j3k4l2

El código posible en corto usando un HashMap. (Sin líneas forzadas)

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

Pruebe el siguiente código, espero que sea útil para usted,

 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 

SALIDA DE MUESTRA: ingrese el patrón hombre ingrese el String dhimanman FREQUENCY == 2

Gracias. Codificación feliz.

 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