Wie zähle ich die Anzahl der Vorkommen eines Zeichens in einem String?

Ich habe die Schnur

a.b.c.d

Ich möchte die Vorkommen von '.' auf eine idiomatische Weise, vorzugsweise ein Einzeiler.

(Zuvor hatte ich diese Einschränkung als "ohne Schleife" ausgedrückt, falls Sie sich fragen, warum alle versuchen, ohne Schleife zu antworten.)

Mein 'idiomatischer Einzeiler' dafür ist:

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

Warum selbst schreiben, wenn es bereits in Commons Lang ist ?

Der Oneliner von Spring Framework hierfür ist:

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

Wie wäre es damit. Es verwendet keinen regulären Ausdruck darunter, sollte also schneller sein als einige der anderen Lösungen und keine Schleife verwenden.

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

Fassen Sie andere Antworten zusammen und wissen Sie, wie ich dies mit einem Einzeiler tun kann:

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

1) Verwenden von Apache Commons

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

2) Verwenden von Spring Frameworks

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

3) Mit ersetzen

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

4) Verwenden von replaceAll (Fall 1)

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

5) Verwenden von replaceAll (Fall 2)

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

6) Split verwenden

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

7) Verwenden von Java8 (Fall 1)

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

8) Die Verwendung von Java8 (Fall 2) ist für Unicode möglicherweise besser als für Fall 1

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

9) Verwenden von StringTokenizer

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

Aus dem Kommentar : Seien Sie vorsichtig mit dem StringTokenizer, für abcd funktioniert es, aber für a ... bc ... d oder ... abcd oder a .... b ...... c ..... d ... oder etc. es wird nicht funktionieren. Es wird nur zählen. zwischen Zeichen nur einmal

Mehr Infos in Github

Leistungstest (mit JMH , mode = AverageTime, 0.010besser abschneiden als 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

Früher oder später muss sich etwas wiederholen. Es ist für Sie viel einfacher, die (sehr einfache) Schleife zu schreiben, als etwas zu verwenden, splitdas viel leistungsfähiger ist als Sie benötigen.

Kapselung der Schleife auf jeden Fall in einer separaten Methode, z

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

Dann brauchen Sie die Schleife nicht in Ihrem Hauptcode - aber die Schleife muss irgendwo da sein.

Ich hatte eine ähnliche Idee wie Mladen, aber das Gegenteil ...

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 (".") Würde alle Zeichen ersetzen.

Die Lösung von PhiLho verwendet ReplaceAll ("[^.]", ""), Das nicht maskiert werden muss, da [.] Das Zeichen 'Punkt' und nicht 'irgendein Zeichen' darstellt.

Meine "idiomatische Einzeiler" -Lösung:

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

Haben Sie keine Ahnung, warum eine Lösung, die StringUtils verwendet, akzeptiert wird.

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

Ein kürzeres Beispiel ist

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

Hier ist eine Lösung ohne Schleife:

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

Nun, es gibt eine Schleife, aber sie ist unsichtbar :-)

- Yonatan

Ich mag die Idee nicht, einen neuen String für diesen Zweck zuzuweisen. Und da der String bereits ein char-Array auf der Rückseite hat, in dem er seinen Wert speichert, ist String.charAt () praktisch kostenlos.

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

erledigt den Trick ohne zusätzliche Zuordnungen, die in einer Zeile oder weniger erfasst werden müssen, mit nur J2SE.

Okay, inspiriert von Yonatans Lösung, hier ist eine, die rein rekursiv ist - die einzigen verwendeten Bibliotheksmethoden sind length()und charAt(), von denen keine eine Schleife ausführt:

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

Ob Rekursion als Schleife zählt, hängt davon ab, welche genaue Definition Sie verwenden, aber sie ist wahrscheinlich so nah wie möglich.

Ich weiß nicht, ob die meisten JVMs heutzutage eine Schwanzrekursion durchführen ... wenn nicht, erhalten Sie natürlich den gleichnamigen Stapelüberlauf für entsprechend lange Zeichenfolgen.

Inspiriert von Jon Skeet, einer Non-Loop-Version, die Ihren Stack nicht sprengt. Auch ein nützlicher Ausgangspunkt, wenn Sie das Fork-Join-Framework verwenden möchten.

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

(Haftungsausschluss: Nicht getestet, nicht kompiliert, nicht sinnvoll.)

Vielleicht die beste Möglichkeit (Single-Threaded, keine Ersatzpaar-Unterstützung), es zu schreiben:

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

Ich bin mir nicht sicher, wie effizient dies ist, aber es ist der kürzeste Code, den ich schreiben kann, ohne Bibliotheken von Drittanbietern einzubringen:

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

Mit Java-8Sie können auch Streams verwenden, um dies zu erreichen. Natürlich gibt es eine Iteration hinter den Kulissen, aber Sie müssen sie nicht explizit schreiben!

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

Es ist auch möglich, redu in Java 8 zu verwenden, um dieses Problem zu lösen:

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

Ausgabe:

3

Komplette Probe:

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

Anruf:

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

Der einfachste Weg, um die Antwort zu erhalten, ist wie folgt:

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

Wenn Sie das Spring-Framework verwenden, können Sie auch die Klasse "StringUtils" verwenden. Die Methode wäre "countOccurrencesOf".

Sie können die split()Funktion in nur einem Zeilencode verwenden

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

Während Methoden es ausblenden können, gibt es keine Möglichkeit, ohne eine Schleife (oder Rekursion) zu zählen. Sie möchten jedoch aus Leistungsgründen ein char [] verwenden.

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

Die Verwendung von replaceAll (das ist RE) klingt nicht nach dem besten Weg.

Nun, mit einer ganz ähnlichen Aufgabe bin ich auf diesen Thread gestoßen. Ich habe keine Einschränkung der Programmiersprache festgestellt und da groovy auf einem Java-VM ausgeführt wird: So konnte ich mein Problem mit Groovy lösen.

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

erledigt.

Eine viel einfachere Lösung wäre, die Zeichenfolge nur anhand des Zeichens zu teilen, mit dem Sie sie abgleichen.

Zum Beispiel,

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

Dies ergibt 4 im Fall von: getOccurences("o", "something about a quick brown fox");

Irgendwo im Code muss sich etwas wiederholen. Der einzige Weg, dies zu umgehen, ist ein vollständiges Abrollen der Schleife:

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

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


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

... usw., aber dann sind Sie derjenige, der die Schleife manuell im Quellcode-Editor ausführt - anstelle des Computers, auf dem sie ausgeführt wird. Siehe den 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

Hier ist eine etwas andere Rekursionslösung:

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

Warum nicht einfach das Zeichen teilen und dann die Länge des resultierenden Arrays ermitteln? Die Array-Länge ist immer die Anzahl der Instanzen + 1. Richtig?

Der folgende Quellcode gibt Ihnen die Anzahl der Vorkommen einer bestimmten Zeichenfolge in einem vom Benutzer eingegebenen Wort an: -

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