Comment puis-je compter le nombre d'occurrences d'un caractère dans une chaîne?

J'ai la ficelle

a.b.c.d

Je veux compter les occurrences de '.' de manière idiomatique, de préférence une doublure.

(Auparavant, j'avais exprimé cette contrainte comme "sans boucle", au cas où vous vous demanderiez pourquoi tout le monde essaie de répondre sans utiliser de boucle).

Mon «one-liner idiomatique» pour cela est:

int count = StringUtils.countMatches("a.b.c.d", ".");

Pourquoi l'écrire vous-même quand il est déjà en langage commun ?

Oneliner de Spring Framework pour cela est:

int occurance = StringUtils.countOccurrencesOf("a.b.c.d", ".");

Que dis-tu de ça. Il n'utilise pas regexp en dessous, donc devrait être plus rapide que certaines des autres solutions et n'utilisera pas de boucle.

int count = line.length() - line.replace(".", "").length();

Résumez les autres réponses et ce que je sais de toutes les façons de le faire en utilisant une ligne:

   String testString = "a.b.c.d";

1) Utiliser Apache Commons

int apache = StringUtils.countMatches(testString, ".");
System.out.println("apache = " + apache);

2) Utilisation de Spring Framework

int spring = org.springframework.util.StringUtils.countOccurrencesOf(testString, ".");
System.out.println("spring = " + spring);

3) Utilisation de replace

int replace = testString.length() - testString.replace(".", "").length();
System.out.println("replace = " + replace);

4) Utilisation de replaceAll (cas 1)

int replaceAll = testString.replaceAll("[^.]", "").length();
System.out.println("replaceAll = " + replaceAll);

5) Utilisation de replaceAll (cas 2)

int replaceAllCase2 = testString.length() - testString.replaceAll("\\.", "").length();
System.out.println("replaceAll (second case) = " + replaceAllCase2);

6) Utilisation du split

int split = testString.split("\\.",-1).length-1;
System.out.println("split = " + split);

7) Utilisation de Java8 (cas 1)

long java8 = testString.chars().filter(ch -> ch =='.').count();
System.out.println("java8 = " + java8);

8) Utiliser Java8 (cas 2), peut être meilleur pour unicode que le cas 1

long java8Case2 = testString.codePoints().filter(ch -> ch =='.').count();
System.out.println("java8 (second case) = " + java8Case2);

9) Utilisation de StringTokenizer

int stringTokenizer = new StringTokenizer(" " +testString + " ", ".").countTokens()-1;
System.out.println("stringTokenizer = " + stringTokenizer);

Du commentaire : Attention au StringTokenizer, pour abcd ça marchera mais pour a ... bc ... d ou ... abcd ou a .... b ...... c ..... d ... ou etc. cela ne fonctionnera pas. Ça va juste compter. entre les personnages juste une fois

Plus d'infos sur github

Test de performance (en utilisant JMH , mode = AverageTime, 0.010mieux score alors 0.351):

Benchmark              Mode  Cnt  Score    Error  Units
1. countMatches        avgt    5  0.010 ±  0.001  us/op
2. countOccurrencesOf  avgt    5  0.010 ±  0.001  us/op
3. stringTokenizer     avgt    5  0.028 ±  0.002  us/op
4. java8_1             avgt    5  0.077 ±  0.005  us/op
5. java8_2             avgt    5  0.078 ±  0.003  us/op
6. split               avgt    5  0.137 ±  0.009  us/op
7. replaceAll_2        avgt    5  0.302 ±  0.047  us/op
8. replace             avgt    5  0.303 ±  0.034  us/op
9. replaceAll_1        avgt    5  0.351 ±  0.045  us/op

Tôt ou tard, quelque chose doit boucler. Il est beaucoup plus simple d'écrire la boucle (très simple) que d'utiliser quelque chose commesplit qui est beaucoup plus puissant que nécessaire.

Par tous les moyens encapsuler la boucle dans une méthode distincte, par exemple

public static int countOccurrences(String haystack, char needle)
{
    int count = 0;
    for (int i=0; i < haystack.length(); i++)
    {
        if (haystack.charAt(i) == needle)
        {
             count++;
        }
    }
    return count;
}

Ensuite, vous n'avez pas besoin d'avoir la boucle dans votre code principal - mais la boucle doit être là quelque part.

J'avais une idée similaire à Mladen, mais le contraire ...

String s = "a.b.c.d";
int charCount = s.replaceAll("[^.]", "").length();
println(charCount);

String s = "a.b.c.d";
int charCount = s.length() - s.replaceAll("\\.", "").length();

ReplaceAll (".") Remplacerait tous les caractères.

La solution de PhiLho utilise ReplaceAll ("[^.]", ""), Qui n'a pas besoin d'être échappé, car [.] Représente le caractère 'point', pas 'n'importe quel caractère'.

Ma solution `` one-liner idiomatique '':

int count = "a.b.c.d".length() - "a.b.c.d".replace(".", "").length();

Je ne sais pas pourquoi une solution qui utilise StringUtils est acceptée.

String s = "a.b.c.d";
long result = s.chars().filter(ch -> ch == '.').count();

Un exemple plus court est

String text = "a.b.c.d";
int count = text.split("\\.",-1).length-1;

voici une solution sans boucle:

public static int countOccurrences(String haystack, char needle, int i){
    return ((i=haystack.indexOf(needle, i)) == -1)?0:1+countOccurrences(haystack, needle, i+1);}


System.out.println("num of dots is "+countOccurrences("a.b.c.d",'.',0));

eh bien, il y a une boucle, mais elle est invisible :-)

- Yonatan

Je n'aime pas l'idée d'allouer une nouvelle chaîne à cet effet. Et comme la chaîne a déjà un tableau de caractères à l'arrière où elle stocke sa valeur, String.charAt () est pratiquement libre.

for(int i=0;i<s.length();num+=(s.charAt(i++)==delim?1:0))

fait l'affaire, sans allocations supplémentaires qui doivent être collectées, en 1 ligne ou moins, avec seulement J2SE.

D'accord, inspiré par la solution de Yonatan, en voici une qui est purement récursive - les seules méthodes de bibliothèque utilisées sont length()et charAt(), aucune ne fait de boucle:

public static int countOccurrences(String haystack, char needle)
{
    return countOccurrences(haystack, needle, 0);
}

private static int countOccurrences(String haystack, char needle, int index)
{
    if (index >= haystack.length())
    {
        return 0;
    }

    int contribution = haystack.charAt(index) == needle ? 1 : 0;
    return contribution + countOccurrences(haystack, needle, index+1);
}

Le fait que la récursivité compte comme une boucle dépend de la définition exacte que vous utilisez, mais elle est probablement aussi proche que possible.

Je ne sais pas si la plupart des JVM font une récursion de queue ces jours-ci ... sinon vous obtiendrez le débordement de pile éponyme pour des chaînes convenablement longues, bien sûr.

Inspiré par Jon Skeet, une version sans boucle qui ne soufflera pas votre pile. Point de départ également utile si vous souhaitez utiliser le framework fork-join.

public static int countOccurrences(CharSequeunce haystack, char needle) {
    return countOccurrences(haystack, needle, 0, haystack.length);
}

// Alternatively String.substring/subsequence use to be relatively efficient
//   on most Java library implementations, but isn't any more [2013].
private static int countOccurrences(
    CharSequence haystack, char needle, int start, int end
) {
    if (start == end) {
        return 0;
    } else if (start+1 == end) {
        return haystack.charAt(start) == needle ? 1 : 0;
    } else {
        int mid = (end+start)>>>1; // Watch for integer overflow...
        return
            countOccurrences(haystack, needle, start, mid) +
            countOccurrences(haystack, needle, mid, end);
    }
}

(Avertissement: non testé, non compilé, non raisonnable.)

Peut-être la meilleure façon (monothread, pas de support de paire de substitution) de l'écrire:

public static int countOccurrences(String haystack, char needle) {
    int count = 0;
    for (char c : haystack.toCharArray()) {
        if (c == needle) {
           ++count;
        }
    }
    return count;
}

Je ne suis pas sûr de l'efficacité de cela, mais c'est le code le plus court que j'ai pu écrire sans apporter de bibliothèques tierces:

public static int numberOf(String target, String content)
{
    return (content.split(target).length - 1);
}

Avec java-8vous pouvez également utiliser des flux pour y parvenir. Évidemment, il y a une itération dans les coulisses, mais vous n'avez pas à l'écrire explicitement!

public static long countOccurences(String s, char c){
    return s.chars().filter(ch -> ch == c).count();
}

countOccurences("a.b.c.d", '.'); //3
countOccurences("hello world", 'l'); //3

Il est également possible d'utiliser réduire dans Java 8 pour résoudre ce problème:

int res = "abdsd3$asda$asasdd$sadas".chars().reduce(0, (a, c) -> a + (c == '$' ? 1 : 0));
System.out.println(res);

Production:

3

Échantillon complet:

public class CharacterCounter
{

  public static int countOccurrences(String find, String string)
  {
    int count = 0;
    int indexOf = 0;

    while (indexOf > -1)
    {
      indexOf = string.indexOf(find, indexOf + 1);
      if (indexOf > -1)
        count++;
    }

    return count;
  }
}

Appel:

int occurrences = CharacterCounter.countOccurrences("l", "Hello World.");
System.out.println(occurrences); // 3

La façon la plus simple d'obtenir la réponse est la suivante:

public static void main(String[] args) {
    String string = "a.b.c.d";
    String []splitArray = string.split("\\.",-1);
    System.out.println("No of . chars is : " + (splitArray.length-1));
}

Si vous utilisez Spring Framework, vous pouvez également utiliser la classe "StringUtils". La méthode serait "countOccurrencesOf".

Vous pouvez utiliser la split()fonction dans un seul code de ligne

int noOccurence=string.split("#",-1).length-1;

public static int countOccurrences(String container, String content){
    int lastIndex, currIndex = 0, occurrences = 0;
    while(true) {
        lastIndex = container.indexOf(content, currIndex);
        if(lastIndex == -1) {
            break;
        }
        currIndex = lastIndex + content.length();
        occurrences++;
    }
    return occurrences;
}

import java.util.Scanner;

class apples {

    public static void main(String args[]) {    
        Scanner bucky = new Scanner(System.in);
        String hello = bucky.nextLine();
        int charCount = hello.length() - hello.replaceAll("e", "").length();
        System.out.println(charCount);
    }
}//      COUNTS NUMBER OF "e" CHAR´s within any string input

Bien que les méthodes puissent le masquer, il n'y a aucun moyen de compter sans boucle (ou récursivité). Vous souhaitez cependant utiliser un caractère [] pour des raisons de performances.

public static int count( final String s, final char c ) {
  final char[] chars = s.toCharArray();
  int count = 0;
  for(int i=0; i<chars.length; i++) {
    if (chars[i] == c) {
      count++;
    }
  }
  return count;
}

L'utilisation de replaceAll (c'est-à-dire RE) ne semble pas être la meilleure solution.

Eh bien, avec une tâche assez similaire, je suis tombé sur ce fil. Je n'ai vu aucune restriction de langage de programmation et puisque groovy s'exécute sur une machine virtuelle java: voici comment j'ai pu résoudre mon problème en utilisant Groovy.

"a.b.c.".count(".")

terminé.

Une solution beaucoup plus facile serait de simplement diviser la chaîne en fonction du caractère avec lequel vous le faites correspondre.

Par exemple,

int getOccurences(String characters, String string) { String[] words = string.split(characters); return words.length - 1; }

Cela retournera 4 dans le cas de: getOccurences("o", "something about a quick brown fox");

Quelque part dans le code, quelque chose doit boucler. Le seul moyen de contourner cela est un déroulement complet de la boucle:

int numDots = 0;
if (s.charAt(0) == '.') {
    numDots++;
}

if (s.charAt(1) == '.') {
    numDots++;
}


if (s.charAt(2) == '.') {
    numDots++;
}

... etc, mais c'est vous qui faites la boucle, manuellement, dans l'éditeur de source - au lieu de l'ordinateur qui l'exécutera. Voir le pseudocode:

create a project
position = 0
while (not end of string) {
    write check for character at position "position" (see above)
}
write code to output variable "numDots"
compile program
hand in homework
do not think of the loop that your "if"s may have been optimized and compiled to

Voici une solution de récursion de style légèrement différente:

public static int countOccurrences(String haystack, char needle)
{
    return countOccurrences(haystack, needle, 0);
}

private static int countOccurrences(String haystack, char needle, int accumulator)
{
    if (haystack.length() == 0) return accumulator;
    return countOccurrences(haystack.substring(1), needle, haystack.charAt(0) == needle ? accumulator + 1 : accumulator);
}

Pourquoi ne pas simplement diviser le caractère, puis obtenir la longueur du tableau résultant. la longueur du tableau sera toujours le nombre d'instances + 1. N'est-ce pas?

Le code source suivant vous donnera pas d'occurrences d'une chaîne donnée dans un mot entré par l'utilisateur: -

import java.util.Scanner;

public class CountingOccurences {

    public static void main(String[] args) {

        Scanner inp= new Scanner(System.in);
        String str;
        char ch;
        int count=0;

        System.out.println("Enter the string:");
        str=inp.nextLine();

        while(str.length()>0)
        {
            ch=str.charAt(0);
            int i=0;

            while(str.charAt(i)==ch)
            {
                count =count+i;
                i++;
            }

            str.substring(count);
            System.out.println(ch);
            System.out.println(count);
        }

    }
}

int count = (line.length() - line.replace("str", "").length())/"str".length();