Como posso contar o número de ocorrências de um caractere em uma String?

Eu tenho a corda

a.b.c.d

Quero contar as ocorrências de '.' de uma maneira idiomática, preferencialmente de uma linha.

(Anteriormente, eu havia expressado essa restrição como "sem loop", caso você esteja se perguntando por que todo mundo está tentando responder sem usar um loop).

Meu 'one-liner idiomático' para isso é:

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

Por que você mesmo escrever quando já está em comum ?

O oneliner do Spring Framework para isso é:

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

Que tal agora. Ele não usa regexp por baixo, portanto deve ser mais rápido que algumas das outras soluções e não usará um loop.

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

Resuma outra resposta e o que eu sei de todas as maneiras de fazer isso usando uma única linha:

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

1) Usando o Apache Commons

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

2) Usando o Spring Framework

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

3) Usando substituir

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

4) Usando replaceAll (caso 1)

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

5) Usando replaceAll (caso 2)

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

6) Usando split

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

7) Usando Java8 (caso 1)

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

8) Usando Java8 (caso 2), pode ser melhor para unicode do que para o caso 1

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

9) Usando StringTokenizer

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

Do comentário : Tenha cuidado com o StringTokenizer, pois abcd funcionará, mas para um ... bc ... d ou ... abcd ou a .... b ...... c ..... d ... ou etc. não funcionará. Apenas conta para. entre caracteres apenas uma vez

Mais informações no github

Teste de desempenho (usando JMH , mode = AverageTime, com 0.010melhor pontuação 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

Mais cedo ou mais tarde, algo precisa se repetir. É muito mais simples escrever o loop (muito simples) do que usar algo como o splitque é muito mais poderoso do que você precisa.

Por todos os meios, encapsule o loop em um método separado, por exemplo

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

Então você não precisa ter o loop no seu código principal - mas o loop precisa estar em algum lugar.

Tive uma ideia parecida com a de Mladen, mas o oposto ...

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 (".") Substituiria todos os caracteres.

A solução da PhiLho usa ReplaceAll ("[^.]", ""), Que não precisa ser escapado, pois [.] Representa o caractere 'ponto', não 'qualquer caractere'.

Minha solução 'idiomática de uma linha':

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

Não faço ideia por que uma solução que usa StringUtils é aceita.

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

Um exemplo mais curto é

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

aqui está uma solução sem loop:

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

bem, existe um loop, mas é invisível :-)

- Yonatan

Não gosto da idéia de alocar uma nova string para esse fim. E como a string já possui uma matriz de caracteres na parte de trás, onde armazena seu valor, String.charAt () é praticamente gratuito.

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

faz o truque, sem alocações adicionais que precisam de coleta, em 1 linha ou menos, apenas com J2SE.

Ok, inspirado na solução de Yonatan, aqui está um que é puramente recursivo - os únicos métodos de biblioteca usados ​​são length()e charAt(), nenhum dos quais faz loop:

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

Se a recursão conta como loop depende de qual definição exata você usa, mas provavelmente é o mais próximo possível.

Não sei se a maioria das JVMs faz recursão de cauda atualmente ... se não, você obterá o estouro de pilha de mesmo nome para seqüências longas apropriadas, é claro.

Inspirado por Jon Skeet, uma versão sem loop que não estraga sua pilha. Também é um ponto de partida útil se você deseja usar a estrutura de junção de forquilha.

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

(Isenção de responsabilidade: não testado, não compilado, não sensato.)

Talvez a melhor (sem suporte a um par substituto) de thread único:

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

Não tenho certeza sobre a eficiência disso, mas é o código mais curto que eu poderia escrever sem trazer bibliotecas de terceiros:

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

Com java-8você também pode usar fluxos para conseguir isso. Obviamente, há uma iteração nos bastidores, mas você não precisa escrevê-la explicitamente!

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

Também é possível usar o reduzir no Java 8 para resolver esse problema:

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

Resultado:

3

Amostra completa:

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

Ligar:

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

A maneira mais simples de obter a resposta é a seguinte:

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

Caso esteja usando o Spring framework, você também pode usar a classe "StringUtils". O método seria "countOccurrencesOf".

Você pode usar a split()função em apenas um código de linha

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

Embora os métodos possam ocultá-lo, não há como contar sem um loop (ou recursão). Você deseja usar um char [] por razões de desempenho.

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

O uso de replaceAll (ou seja, RE) não parece o melhor caminho a percorrer.

Bem, com uma tarefa bem parecida, me deparei com este Tópico. Eu não vi nenhuma restrição de linguagem de programação e como o groovy é executado em um java vm: Aqui está como eu consegui resolver meu problema usando o Groovy.

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

feito.

Uma solução muito mais fácil seria dividir a string com base no caractere com o qual você está combinando.

Por exemplo,

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

Isso retornará 4 no caso de: getOccurences("o", "something about a quick brown fox");

Em algum lugar do código, algo precisa fazer um loop. A única maneira de contornar isso é um desenrolar completo do loop:

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

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


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

... etc, mas é você quem executa o loop manualmente no editor de código-fonte - em vez do computador que o executará. Veja o pseudocódigo:

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

Aqui está uma solução de recursão de estilo um pouco diferente:

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

Por que não apenas dividir o caractere e obter o comprimento da matriz resultante. o comprimento da matriz sempre será o número de instâncias + 1. Certo?

O seguinte código-fonte não fornecerá nenhuma ocorrência de uma determinada sequência em uma palavra inserida pelo usuário: -

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