好吧，在一个非常相似的任务中，我偶然发现了这个线程。 我没有看到任何编程语言的限制，因为groovy运行在java虚拟机上: 这里是我如何能够解决我的问题使用Groovy。

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

完成了。

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

灵感来自Jon Skeet，一个非循环版本，不会吹你的堆栈。如果你想使用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);
    }
}

(免责声明:未经测试，未经编译，不合理。)

也许最好的(单线程，不支持代理对)编写方法是:

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

试试这个方法:

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

试试下面的代码:

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

}

你为什么要避开这个循环?我的意思是，如果不检查字符串的每一个字符，你就不能计算“numberOf”点，如果你调用任何函数，它都会以某种方式循环。这是字符串。Replace应该执行一个循环验证字符串是否出现，以便它可以替换每一个出现的字符串。

如果你试图减少资源使用，你不会这样做，因为你创建一个新的字符串只是为了计数点。

现在，如果我们讨论递归的“在这里输入代码”方法，有人说它会因为OutOfMemmoryException而失败，我想他忘记了StackOverflowException。

所以我的方法是这样的(我知道它像其他的，但是，这个问题需要循环):

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