Wie zähle ich die Anzahl der vorkommen eines char in einen String?

Mein 'idiomatischer one-liner" für diese ist:

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

Warum schreiben Sie es selbst, wenn es schon in commons-lang?

Spring-Frameworks oneliner für diese ist:

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

Zusammenzufassen andere Antwort und was weiß ich, alle Möglichkeiten, dies zu tun mit einem one-liner:

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

1) Mit Apache Commons

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

2) Mit 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) Mit replaceAll (Fall 1)

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

5) Mit replaceAll (Fall 2)

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

6) Mit split

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

7) Mit Java8 (Fall 1)

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

8) Mit Java8 (Fall 2), kann für Sie besser sein unicode als Fall 1

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

9), Mit StringTokenizer

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

Kommentar: Seien Sie vorsichtig bei der StringTokenizer, für eine.b.c.d es wird funktionieren, aber für einen b....c....d oder ...ein.b.c.d oder a....b......c.....d... oder etc. es wird nicht funktionieren. Es wird einfach zählen . zwischen den Zeichen nur einmal

Mehr info in github

Perfomance test (mit JMH, mode = AverageTime, score 0.010 dann besser 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

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

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

Mein 'idiomatischer one-liner' Lösung:

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

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

Einem kürzeren Beispiel ist

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

Ich weiß nicht, wie die Idee der Zuweisung in einen neuen string für diesen Zweck. Und da der string bereits ein char-array in den Rücken, wo es speichert es den Wert der Zeichenfolge.charAt() ist praktisch kostenlos.

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

funktioniert der trick, ohne zusätzliche Zuteilungen müssen Sammlung, in 1 Zeile oder weniger, nur mit J2SE.

Inspiriert von Jon Skeet, ein nicht-loop-version, die nicht sprengen Sie Ihren stack. Auch nützlich Ausgangspunkt, wenn Sie möchten, verwenden Sie den fork-join-framework.

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

(Disclaimer: Nicht geprüft, nicht kompiliert, nicht sinnvoll.)

Vielleicht das beste (single-threaded, keine surrogate-pair-Unterstützung) Weise, 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;
}

Mit java-8 Sie können auch mithilfe von streams zu erreichen. Offensichtlich gibt es eine iteration hinter den kulissen, aber Sie nicht schreiben Sie es explizit!

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

Vollständiges Beispiel:

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

Nennen:

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

Falls Sie mit Spring framework, könnten Sie auch "StringUtils" - Klasse.
Die Methode wäre "countOccurrencesOf".

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

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

Hier ist ein etwas anderer Stil Rekursion Lö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);
}

Den folgenden source-code wird Ihnen nicht.von vorkommen einer bestimmten Zeichenkette in einem Wort, eingegeben durch user :-

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

    }
}

Mit Eclipse-Sammlungen

int count = CharAdapter.adapt("a.b.c.d").count(c -> c == '.');

Wenn du mehr als ein Zeichen zu zählen, die Sie verwenden können, eine CharBag wie folgt:

CharBag bag = CharAdapter.adapt("a.b.c.d").toBag();
int count = bag.occurrencesOf('.');

Hinweis: ich bin ein committer für Eclipse Sammlungen.

Versuchen Sie diese Methode:

StringTokenizer stOR = new StringTokenizer(someExpression, "||");
int orCount = stOR.countTokens()-1;

Warum sind Sie versuchen zu vermeiden, die Schleife? Ich meine, Sie können nicht zählen, die "Anzahl" Punkte, ohne zu überprüfen, jedes einzelne Zeichen des Strings, und rufen Sie eine beliebige Funktion, irgendwie wird es Schleife. Dies ist String.ersetzen, sollte eine Schleife überprüfen, ob der string angezeigt wird, so kann es ersetzen Sie jedes einzelne vorkommen.

Wenn Sie versuchen, den Ressourceneinsatz reduzieren, werden Sie es nicht tun würde, weil Sie erstellen Sie eine neue Zeichenfolge nur zum zählen der Punkte.

Nun, wenn wir reden über die rekursive "enter code here" - Methode, jemand sagte, dass es scheitern wird, aufgrund einer OutOfMemmoryException, ich glaube, er vergaß StackOverflowException.

Also meine Methode würde wie folgt Aussehen (ich weiß, es ist wie die anderen, aber dieses problem erfordert die Schleife):

public static int numberOf(String str,int c) {
    int res=0;
    if(str==null)
        return res;
    for(int i=0;i<str.length();i++)
        if(c==str.charAt(i))
            res++;
    return res;
}

String[] parts = text.split(".");
int occurances = parts.length - 1;

" It's a great day at O.S.G. Dallas! "
     -- Famous Last Words

Gut, es ist ein Fall von zu wissen, Ihre Java -, vor allem Ihre grundlegende grundlegende Verständnis der Sammlung von Klassen, die bereits in Java. Wenn man sich während des gesamten posting hier, es ist so ziemlich alles kurz von Stephen Hawkings Erklärung, den Ursprung des Universums, Darwin 's Taschenbuch auf Evolution und Gene Roddenberry' s Star Trek-cast-Auswahl, warum Sie ging mit William Shatner kurz, wie Sie dies schnell und einfach tun...

... muss ich mehr sagen?

Versuchen, diesen code:

package com.java.test;

import java.util.HashMap;
import java.util.Map;

public class TestCuntstring {

    public static void main(String[] args) {

        String name = "Bissssmmayaa";
        char[] ar = new char[name.length()];
        for (int i = 0; i < name.length(); i++) {
            ar[i] = name.charAt(i);
        }
        Map<Character, String> map=new HashMap<Character, String>();
        for (int i = 0; i < ar.length; i++) {
            int count=0;
            for (int j = 0; j < ar.length; j++) {
                if(ar[i]==ar[j]){
                    count++;
                }
            }
            map.put(ar[i], count+" no of times");
        }
        System.out.println(map);
    }

}

public static void getCharacter(String str){

        int count[]= new int[256];

        for(int i=0;i<str.length(); i++){


            count[str.charAt(i)]++;

        }
        System.out.println("The ascii values are:"+ Arrays.toString(count));

        //Now display wht character is repeated how many times

        for (int i = 0; i < count.length; i++) {
            if (count[i] > 0)
               System.out.println("Number of " + (char) i + ": " + count[i]);
        }


    }
}

Ich habe versucht, auf Ihre Frage mit einer switch-Anweisung, aber ich Bedarf noch eine for-Schleife Parsen der Zeichenfolge . fühlen Sie sich frei zu kommentieren, wenn ich kann, verbessern den code

public class CharacterCount {
public static void main(String args[])
{
    String message="hello how are you";
    char[] array=message.toCharArray();
    int a=0;
    int b=0;
    int c=0;
    int d=0;
    int e=0;
    int f=0;
    int g=0;
    int h=0;
    int i=0;
    int space=0;
    int j=0;
    int k=0;
    int l=0;
    int m=0;
    int n=0;
    int o=0;
    int p=0;
    int q=0;
    int r=0;
    int s=0;
    int t=0;
    int u=0;
    int v=0;
    int w=0;
    int x=0;
    int y=0;
    int z=0;


    for(char element:array)
    {
        switch(element)
        {
        case 'a':
        a++;
        break;
        case 'b':
        b++;
        break;
        case 'c':c++;
        break;

        case 'd':d++;
        break;
        case 'e':e++;
        break;
        case 'f':f++;
        break;

        case 'g':g++;
        break;
        case 'h':
        h++;
        break;
        case 'i':i++;
        break;
        case 'j':j++;
        break;
        case 'k':k++;
        break;
        case 'l':l++;
        break;
        case 'm':m++;
        break;
        case 'n':m++;
        break;
        case 'o':o++;
        break;
        case 'p':p++;
        break;
        case 'q':q++;
        break;
        case 'r':r++;
        break;
        case 's':s++;
        break;
        case 't':t++;
        break;
        case 'u':u++;
        break;
        case 'v':v++;
        break;
        case 'w':w++;
        break;
        case 'x':x++;
        break;
        case 'y':y++;
        break;
        case 'z':z++;
        break;
        case ' ':space++;
        break;
        default :break;
        }
    }
    System.out.println("A "+a+" B "+ b +" C "+c+" D "+d+" E "+e+" F "+f+" G "+g+" H "+h);
    System.out.println("I "+i+" J "+j+" K "+k+" L "+l+" M "+m+" N "+n+" O "+o+" P "+p);
    System.out.println("Q "+q+" R "+r+" S "+s+" T "+t+" U "+u+" V "+v+" W "+w+" X "+x+" Y "+y+" Z "+z);
    System.out.println("SPACE "+space);
}

}