Comment compter la fréquence des caractères dans une chaîne de caractères?
j'ai besoin d'écrire une sorte de boucle qui peut compter la fréquence de chaque lettre dans une chaîne de caractères.
Par exemple: "aasjjikkk" compterait 2 'a', 1, 's', 2 'j', 1 'i', 3 'k'. Finalement id comme ceux-ci pour finir dans une carte avec le caractère comme la clé et le compte comme la valeur. Toute bonne idée de comment faire cela?
19 réponses
vous pouvez utiliser une carte java et une carte a char à un int. Vous pouvez ensuite itérer les caractères dans la chaîne et vérifier s'ils ont été ajoutés à la carte, s'ils l'ont été, vous pouvez alors augmenter sa valeur.
Par exemple:
HashMap<Character, Integer> map = new HashMap<Character, Integer>();
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);
}
}
a la fin vous aurez un compte de tous les caractères que vous avez rencontrés et vous pourrez en extraire leurs fréquences.
alternativement, vous pouvez utiliser la solution de Bozho d'utiliser un Multiset et compter le total nombre d'occurences.
Vous pouvez utiliser un Multiset (goyave). Il vous donnera le nombre de chaque objet. Par exemple:
Multiset<Character> chars = HashMultiset.create();
for (int i = 0; i < string.length(); i++) {
chars.add(string.charAt(i));
}
puis pour chaque caractère vous pouvez appeler chars.count('a') et elle renvoie le nombre d'occurrences
Voici une autre solution, aussi douteuse soit-elle.
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<Integer, Character> countList = new java.util.HashMap<Integer, Character>();
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);
}
Une manière concise à faire c'est:
Map<Character,Integer> frequencies = new HashMap<>();
for (char ch : input.toCharArray())
frequencies.put(ch, frequencies.getOrDefault(ch, 0) + 1);
nous utilisons un pour-chacun pour boucler chaque caractère. frequencies.getOrDefault() obtient la valeur si la clé est présente ou renvoie (par défaut) son second argument.
Eh bien, deux façons viennent à l'esprit et cela dépend de votre préférence:
trier le tableau par caractères. Puis, compter chaque caractère devient trivial. Mais vous devrez d'abord faire une copie du tableau.
Créer un autre tableau d'entiers de taille 26 (dire freq) et str est le tableau de caractères.
for(int i = 0; i < str.length; i ++)freq[str[i] - 'a'] ++; //Assuming all characters are in lower case
Voici une solution:
Définissez votre propre 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;}
}
Ensuite, tu pourrais faire:
public static Pair countCharFreq(String s)
{
String temp = s;
java.util.List<Pair> list = new java.util.ArrayList<Pair>();
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;
}
Vous pouvez utiliser un CharAdapter et CharBag Collections Eclipse et éviter la boxe à Character et 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'));
Note: je suis un committer pour Eclipse Collections.
Utiliser le flux de données de l'API du JDK-8:
Map<Character, Long> frequency =
str.chars()
.mapToObj(c -> (char)c)
.collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));
ou si vous voulez les touches comme les Entiers:
Map<Character, Integer> frequency =
str.chars()
.mapToObj(c -> (char)c)
.collect(Collectors.groupingBy(Function.identity(), Collectors.summingInt(c -> 1)));
une Autre variante:
Map<Character, Integer> frequency =
str.chars()
.mapToObj(c -> (char)c)
.collect(Collectors.toMap(Function.identity(), c -> 1, Math::addExact));
comme il n'y avait pas de solution Java 8, j'ai pensé en poster une. Aussi, cette solution est beaucoup plus lisible, concis et lisibles que d'autres solutions mentionnées ici.
String string = "aasjjikkk";
Map<Character, Long> characterFrequency = string.chars() // creates an IntStream
.mapToObj(c -> (char) c) // converts the IntStream to Stream<Character>
.collect(Collectors.groupingBy(c -> c, Collectors.counting())); // creates a
// Map<Character, Long>
// where the Long is
// the frequency
si cela n'a pas besoin d'être super-rapide il suffit de créer un tableau d'entiers, un entier pour chaque lettre (seulement alphabétiques donc 2*26 entiers? ou des données binaires possibles?). passer par la chaîne un char à la fois, obtenir l'index de l'entier responsable (par exemple, si vous n'avez que des caractères alphabétiques, vous pouvez avoir 'a' être à l'index 0 et obtenir cet index en soustrayant n'importe quel 'A' à 'Z' par 'A' Juste comme un exemple de comment vous pouvez obtenir des indices raisonnablement rapides) et incrémenter la valeur dans ce index.
il y a plusieurs micro-optimisations pour rendre cela plus rapide (si nécessaire).
Vous pouvez utiliser un Hashtable avec chaque caractère comme la clé et le nombre total devient la valeur.
Hashtable<Character,Integer> table = new Hashtable<Character,Integer>();
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;
}
c'est similaire à la réponse de xunil154, sauf qu'une chaîne est faite d'un tableau de caractères et qu'un hashmap lié est utilisé pour maintenir l'ordre d'insertion des caractères.
String text = "aasjjikkk";
char[] charArray = text.toCharArray();
Map<Character, Integer> freqList = new LinkedHashMap<Character, Integer>();
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<Character,Integer> hashCount=new HashMap<>();
Character c;
for(int i=0; i<input.length();i++)
{
c =input.charAt(i);
if(hashCount.get(c)!=null){
hashCount.put(c, hashCount.get(c)+1);
}else{
hashCount.put(c, 1);
}
}
Iterator it = hashCount.entrySet().iterator();
System.out.println("char : frequency");
while (it.hasNext()) {
Map.Entry pairs = (Map.Entry)it.next();
System.out.println(pairs.getKey() + " : " + pairs.getValue());
it.remove();
}
}
}
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; i<s1.length(); i++)
{
if(ch[i]==var || ch[i]==var-32)
{
count++;
}
}
if(count>0){
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<Character, Integer> zip = new HashMap<Character, Integer>();
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<Character, Integer> entry : zip.entrySet()) {
myMapKeyValue = Character.toString(entry.getKey()).concat(
Integer.toString(entry.getValue()));
myValue.append(myMapKeyValue);
}
System.out.println(myValue);
}
}
Entrée= aaaajjjggggtttssvkklaiiikk
Sortie= a6s2t3v2g3i3j3k4l2
le code possible court-circuité en utilisant un HashMap. (Sans énergique de la ligne de sauve)
private static Map<Character, Integer> findCharacterFrequency(String str) {
Map<Character, Integer> map = new HashMap<>();
for (char ch : str.toCharArray()) {
/* Using getOrDefault(), since Java1.8 */
map.put(ch, map.getOrDefault(ch, 0) + 1);
}
return map;
}
s'il vous Plaît essayer le code donné ci-dessous, l'espoir qu'il sera utile à vous,
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<ch.length-1; i++)
{
int k=i;
int j1=i+1;
int j=0;
int j11=j;
int j2=j+1;
{
while(k<ch.length && j11<ch1.length && ch[k]==ch1[j11])
{
k++;
j11++;
}
int l=k+j1;
int m=j11+j2;
if( l== m)
{
count=1;
count++;
}
}
}
return count;
}
public static void main (String[] args) {
Scanner sc=new Scanner(System.in);
System.out.println("enter the pattern");
String s1=sc.next();
System.out.println("enter the String");
String s2=sc.next();
int res=frequency(s1, s2);
System.out.println("FREQUENCY==" +res);
}
}
SORTIE DE L'ÉCHANTILLON: entrez le modèle homme entrez la Chaîne dhimanman Fréquence= = 2
Merci à vous.Heureux de codage.
Question: prenez la chaîne par un utilisateur et obtenez la fréquence de chaque caractère.!!!!!!!!!!
import java.util.HashMap;
import java.util.Scanner;
public class FrequencyPrograme {
public static void main(String str[]){
HashMap<Character,Integer> frequency=new HashMap<Character,Integer>();
Scanner inputString=new Scanner(System.in);
System.out.print("Please enter the string.");
String String =inputString.next();
for(int i=0; i<String .length();i++){
char ch=String .charAt(i);
Integer value=frequency.get(ch);
if(value!=null){
frequency.put(ch, new Integer(value+1));
}else{
frequency.put(ch, 1);
}
}
System.out.println(frequency);
}
}
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<str.length();i++)
{
arr[i]=str.charAt(i);
}
for(int j=0;j<str.length();j++)
{
int c=0;
for(int k=0;k<str.length();k++)
{
if(arr[j]==arr[k])
c++;
}
hs.add(arr[j]+"="+c+",");
}
Iterator it=hs.iterator();
while(it.hasNext())
{
System.out.print(it.next());
}
}
}