Rechercher des occurrences de caractères dans une chaîne Java
J'aimerais compter les occurrences d'un caractère dans une chaîne, supposons que j'ai la chaîne "aaaab", comment pourrais-je compter le nombre de a qu'il contient?
Le code semble beaucoup plus facile à lire si vous n'utilisez pas d'expressions régulières.
int count = 0;
for(int i =0; i < string.length(); i++)
if(string.charAt(i) == 'a')
count++;
count contient maintenant le nombre de 'a' dans votre chaîne. Et cela fonctionne dans le temps optimal.
Les expressions régulières sont bien pour la correspondance de motif. Mais juste une boucle régulière fera le travail ici.
Guava's CharMatcher API est assez puissant et concis:
CharMatcher.is('a').countIn("aaaab"); //returns 4
String string = "aaab";
int count = string.length() - string.replaceAll("a", "").length();
au lieu de "a", utilisez une expression régulière comme "[a-zA-Z]" pour compter tous les caractères Word
Essayez d’utiliser Apache Commons 'StringUtils :
int count = StringUtils.countMatches("aaaab", "a");
// count = 4
int count = 0;
for (char c : string.toCharArray())
if (c == 'a')
count++;
Une simple boucle sur les personnages le ferait.
public int countChars(char c, String s) {
int result = 0;
for (int i = 0, n = s.length(); i < n; i++) {
if (s.charAt(i) == c) {
result++;
}
}
return result;
}
Voici une solution vraiment courte sans aucune bibliothèque supplémentaire:
String input = "aaaab";
int i = -1, count = 0;
while( (i = input.indexOf( 'a', i + 1 ) ) != -1 ) count++;
System.out.println( count );
Les expressions régulières ne sont pas particulièrement douées pour compter des choses simples. Pensez ant + sledgehammer. Ils savent bien briser des chaînes complexes.
Quoi qu’il en soit, voici une solution qui intéresse l’opérateur: utiliser une regex pour compter les «a»:
public class Reggie {
public static void main(String[] args) {
Pattern pattern = Pattern.compile("[^a]*a");
Matcher matcher = pattern.matcher("aaabbbaaabbabababaaabbbbba");
int count = 0;
while(matcher.find()) {
count++;
}
System.out.println(count+" matches");
}
}
C'est une façon assez lente de le faire, comme l'ont souligné d'autres. Pire encore, ce n'est pas le plus facile et certainement pas le plus susceptible d'être exempt de bogues. Quoi qu'il en soit, si vous vouliez quelque chose d'un peu plus complexe que 'a', l'expression rationnelle deviendrait plus appropriée à mesure que la chaîne demandée deviendrait plus complexe. Par exemple, si vous voulez choisir des montants en dollars dans une longue chaîne, une expression régulière pourrait être la meilleure réponse.
Maintenant, à propos de la regex: [^a]*a
Ce [^a]* signifie "correspond à zéro ou plusieurs caractères non" a ". Cela nous permet de dévorer un crud non-'a 'depuis le début d'une chaîne: Si l'entrée est' bbba ', alors [^a]* correspondra à' bbb '. Cela ne correspond pas au "a". Ne vous inquiétez pas, le «a» à la fin de la regex dit «correspond exactement à un« a »». Donc, notre expression rationnelle dit, "correspond à zéro ou plusieurs caractères non-'a' qui sont suivis d'un 'a'".
D'accord. Vous pouvez maintenant en savoir plus sur Pattern et Matcher. En bref, le motif est une expression régulière compilée. Compiler une regex coûte cher, alors je crée la mienne statique pour qu'elle ne soit compilée qu'une seule fois. Le Matcher est une classe qui appliquera une chaîne à un motif pour voir si elle correspond. Matcher a des informations d'état qui lui permettent d'explorer une chaîne en appliquant un motif à plusieurs reprises.
La boucle dit en gros: "Matcher, parcourez la chaîne en cherchant la prochaine occurrence du motif. Si nous le trouvons, incrémente le compteur". Notez que les séquences de caractères trouvées par Matcher ne sont pas simplement «a». Il trouve des séquences telles que: 'a', 'bbba', 'bba', 'ba', etc. C'est-à-dire des chaînes qui ne contiennent pas de 'a' à l'exception de leur dernier caractère.
String searchFor = "a";
String base = "aaaab";
int count=0;
int index =base.indexOf(searchFor);
while(index!=-1){
++count;
index = base.indexOf(searchFor, index+searchFor.length());
}
System.out.println(count);
public static void main(String[] args) {
Map<Character, Integer> data = new HashMap<Character, Integer>();
String s = "aaaab";
char[] chars = s.toCharArray();
for (char a : chars) {
if (data.containsKey(a)) {
int value = data.get(a);
data.put(a, value + 1);
} else {
data.put(a, 1);
}
}
Iterator it = data.entrySet().iterator();
while (it.hasNext()) {
Map.Entry pairs = (Map.Entry) it.next();
System.out.println(pairs.getKey() + " = " + pairs.getValue());
}
}
Voici ma logique ...
public class OccurenceOf_Character {
public static void main(String[] args) {
Scanner input=new Scanner(System.in);
System.out.println(" Enter a string");
String str = input.nextLine();
System.out.println(" Enter a character");
String character=input.next();
int l = character.length();
char c=character.charAt(0);
int count=0;
for(int i=0;i<str.length();i++)
{
if(str.charAt(i) == c)
{
count=count+1;
}
}
System.out.println(count);
}
}
Vous pouvez utiliser la classe StringUtils fournie par Apache commons . StringUtils.countMatches (String originalString, String subCharacterSequesnce)
String s1="parasanna";
StringBuffer sb=new StringBuffer();
boolean print = false;
for (int i=0; i<s1.length(); i++){
int count=1;
char c=s1.charAt(i);
sb.append(c);
for (int j=1; j<sb.length(); j++) {
char c2=sb.charAt(j-1);
if (c==c2) {
count++;
}
}
System.out.println(c+"=="+count);
}
Java 8
Approche 1 - Obtient l'occurrence d'un seul caractère
String sentence = "Aaron ate apples upon a rock";
long counted = IntStream.range(0, sentence.length())
.filter(i->sentence.charAt(i) == 'a')
.count();
System.out.println("First approach: " + counted);
Approche 2 - Permet de spécifier le caractère
String sentence = "Aaron ate apples upon a rock";
BiFunction<String, Character, Long> counter = (s,c) -> {
return IntStream.range(0, s.length())
.filter(i->s.charAt(i) == c)
.count();
};
System.out.println("Second approach (with 'a'): " + counter.apply(sentence, 'a'));
System.out.println("Second approach (with 'o'): " + counter.apply(sentence, 'o'));
Approche 3 - Compte les occurrences de tous les caractères
String sentence = "Aaron ate apples upon a rock";
Map<Character, Long> counts = IntStream.range(0, sentence.length())
.mapToObj(i->sentence.charAt(i))
.collect(Collectors.groupingBy(o->o, Collectors.counting()));
System.out.println("Third approach for every character... ");
counts.keySet().stream()
.forEach(key -> System.out.println("'" + key + "'->" + counts.get(key)));
Vous pouvez simplement utiliser ceci:
String a = "i am here as junior Java programmer";
Set temp = new HashSet();
char[] chararray=a.toCharArray();
Set temp=new HashSet();
for(int i=0;i<chararray.length;i++)
{
int count=0;
for (int j=0;j<chararray.length;j++) {
if (chararray[i]==chararray[j]) {
count++;
}
}
if (temp.add(chararray[i])!=false)
System.out.println("Character "+chararray[i]+" occur "+count);
}
public static void main(String[] args) throws IOException
{
//String s1="parasanna";
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
System.out.println("enter string:");
String s1 = br.readLine();
StringBuffer sb=new StringBuffer(s1);
while(sb.length() != 0)
{
char c = sb.charAt(0);
int cnt = 0;
for(int i=0; i< sb.length(); i++)
{
if(c == sb.charAt(i))
{
cnt++;
sb.deleteCharAt(i);
i--;
}
}
System.out.println(c + " occurance is:" + cnt);
}
}