Come contare il numero di occorrenze di un carattere in una stringa?

Ho la corda

a.b.c.d

Voglio contare le occorrenze di "." in modo idiomatico, preferibilmente un liner.

(In precedenza avevo espresso questo vincolo come "senza loop", nel caso ti stia chiedendo perché tutti stiano cercando di rispondere senza usare un loop).

Il mio "idiomatico monolinea" per questo è:

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

Perché scriverlo da solo quando è già in lang comune ?

L'eleliner di Spring Framework per questo è:

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

Cosa ne pensi di questo. Non utilizza regexp al di sotto, quindi dovrebbe essere più veloce di alcune delle altre soluzioni e non utilizzerà un ciclo.

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

Riassumi le altre risposte e ciò che conosco in tutti i modi per farlo utilizzando un one-liner:

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

1) Utilizzo di Apache Commons

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

2) Utilizzo di Spring Framework

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

3) Utilizzo di sostituire

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

4) Utilizzo di ReplaceAll (caso 1)

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

5) Utilizzo di ReplaceAll (caso 2)

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

6) Utilizzo della divisione

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

7) Utilizzo di Java8 (caso 1)

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

8) L'uso di Java8 (caso 2) potrebbe essere migliore per Unicode rispetto al caso 1

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

9) Utilizzo di StringTokenizer

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

Dal commento : fai attenzione a StringTokenizer, per abcd funzionerà ma per un ... bc ... d o ... abcd o un .... b ...... c ..... d ... o ecc. non funzionerà. Conterà solo per. tra i personaggi solo una volta

Maggiori informazioni in github

Test delle prestazioni (usando JMH , mode = AverageTime, punteggio 0.010migliore allora 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

Prima o poi qualcosa deve essere ripetuto. È molto più semplice per te scrivere il ciclo (molto semplice) che usare qualcosa del genere splitche è molto più potente del necessario.

In ogni caso incapsulare il loop in un metodo separato, ad es

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

Quindi non è necessario avere il ciclo nel codice principale, ma il ciclo deve essere lì da qualche parte.

Ho avuto un'idea simile a Mladen, ma al contrario ...

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 (".") Sostituirà tutti i caratteri.

La soluzione di PhiLho usa ReplaceAll ("[^.]", ""), Che non ha bisogno di essere sfuggito, poiché [.] Rappresenta il carattere 'punto', non 'qualsiasi carattere'.

La mia soluzione "idiomatica one-liner":

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

Non ho idea del perché venga accettata una soluzione che utilizza StringUtils.

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

Un esempio più breve è

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

ecco una soluzione senza 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));

bene, c'è un ciclo, ma è invisibile :-)

- Yonatan

Non mi piace l'idea di allocare una nuova stringa per questo scopo. E poiché la stringa ha già un array di caratteri nella parte posteriore in cui memorizza il suo valore, String.charAt () è praticamente gratuito.

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

fa il trucco, senza allocazioni aggiuntive che hanno bisogno di raccolta, in 1 riga o meno, con solo J2SE.

Ok, ispirato alla soluzione di Yonatan, eccone uno che è puramente ricorsivo: gli unici metodi di libreria utilizzati sono length()e charAt(), nessuno dei quali esegue alcun ciclo:

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 la ricorsione conta come loop dipende dalla definizione esatta che usi, ma è probabilmente il più vicino possibile.

Non so se la maggior parte delle JVM eseguono la ricorsione della coda in questi giorni ... in caso contrario otterrai l'omonimo stack overflow per stringhe adeguatamente lunghe, ovviamente.

Ispirato da Jon Skeet, una versione non-loop che non farà esplodere il tuo stack. Utile anche punto di partenza se si desidera utilizzare il 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);
    }
}

(Dichiarazione di non responsabilità: non testata, non compilata, non ragionevole.)

Forse il modo migliore (single thread, nessun supporto per coppie surrogate) per scriverlo:

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

Non sono sicuro dell'efficienza di questo, ma è il codice più breve che potrei scrivere senza introdurre librerie di terze parti:

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

Con java-8puoi anche usare i flussi per raggiungere questo obiettivo. Ovviamente c'è un'iterazione dietro le quinte, ma non devi scriverla esplicitamente!

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

È inoltre possibile utilizzare la riduzione in Java 8 per risolvere questo problema:

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

Produzione:

3

Campione completo:

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

Chiamata:

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

Il modo più semplice per ottenere la risposta è il seguente:

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

Nel caso in cui utilizzi il framework Spring, potresti anche utilizzare la classe "StringUtils". Il metodo sarebbe "countOccurrencesOf".

È possibile utilizzare la split()funzione in un solo codice di riga

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

Mentre i metodi possono nasconderlo, non c'è modo di contare senza un ciclo (o ricorsione). Tuttavia, si desidera utilizzare un carattere [] per motivi di prestazioni.

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'uso di ReplaceAll (ovvero RE) non sembra il modo migliore di procedere.

Bene, con un compito abbastanza simile mi sono imbattuto in questo thread. Non ho visto alcuna limitazione del linguaggio di programmazione e poiché groovy funziona su un java vm: Ecco come sono stato in grado di risolvere il mio problema usando Groovy.

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

fatto.

Una soluzione molto più semplice sarebbe quella di dividere la stringa in base al carattere con cui la stai abbinando.

Per esempio,

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

Questo restituirà 4 nel caso di: getOccurences("o", "something about a quick brown fox");

Da qualche parte nel codice, qualcosa deve essere ripetuto. L'unico modo per aggirare questo è un completo srotolamento del ciclo:

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

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


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

... ecc., ma poi sei tu a eseguire il ciclo, manualmente, nell'editor di origine, anziché nel computer che lo eseguirà. Vedi lo pseudocodice:

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

Ecco una soluzione di ricorsione di stile leggermente diversa:

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

Perché non solo dividere il personaggio e quindi ottenere la lunghezza dell'array risultante. la lunghezza dell'array sarà sempre il numero di istanze + 1. Giusto?

Il seguente codice sorgente ti darà il numero di occorrenze di una determinata stringa in una parola inserita dall'utente: -

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