我正在做一些事情，我意识到我想要在一个字符串中找到多少个/s，然后我突然想到，有几种方法可以做到这一点，但不能决定哪种是最好的(或最简单的)。
目前我想说的是:
string source = "/once/upon/a/time/";
int count = source.Length - source.Replace("/", "").Length;
但我一点都不喜欢，有人愿意吗?
我并不想为此挖掘出正则表达式，对吧?
我知道我的字符串将包含我要搜索的项，所以你可以假设…
当然对于长度为> 1的字符串，
string haystack = "/once/upon/a/time";
string needle = "/";
int needleCount = ( haystack.Length - haystack.Replace(needle,"").Length ) / needle.Length;
当前回答
string source = "/once/upon/a/time/";
int count = 0;
int n = 0;
while ((n = source.IndexOf('/', n)) != -1)
{
n++;
count++;
}
在我的电脑上，这比5000万次迭代的每个字符解决方案快2秒左右。
2013年修订:
将字符串更改为char[]并遍历该字符串。将5000万次迭代的总时间进一步缩短一到两秒!
char[] testchars = source.ToCharArray();
foreach (char c in testchars)
{
if (c == '/')
count++;
}
这个更快:
char[] testchars = source.ToCharArray();
int length = testchars.Length;
for (int n = 0; n < length; n++)
{
if (testchars[n] == '/')
count++;
}
为了更好地衡量，从数组的末尾迭代到0似乎是最快的，大约5%。
int length = testchars.Length;
for (int n = length-1; n >= 0; n--)
{
if (testchars[n] == '/')
count++;
}
我想知道为什么这可能是谷歌周围(我记得一些关于反向迭代更快)，并遇到了这个SO问题，烦人地使用字符串char[]技术。不过，我认为在这种情况下，反转技巧是新的。
在c#中迭代字符串中单个字符的最快方法是什么?
其他回答
对于字符串分隔符的情况(而不是字符情况，如主题所述): 字符串源= "@@ once@@@upon@@ a@@@time@@@"; Int count = source。Split(new[] {"@@@"}， StringSplitOptions.RemoveEmptyEntries)。长度- 1; 海报的原始源值("/once/upon/a/time/")自然分隔符是一个字符'/'，并且响应确实解释了source. split (char[])选项…
public static int GetNumSubstringOccurrences(string text, string search)
{
int num = 0;
int pos = 0;
if (!string.IsNullOrEmpty(text) && !string.IsNullOrEmpty(search))
{
while ((pos = text.IndexOf(search, pos)) > -1)
{
num ++;
pos += search.Length;
}
}
return num;
}
字符串中的字符串:
在“..”中找到“etc”。JD JD JD JD等等。JDJDJDJDJDJDJDJD等等。”
var strOrigin = " .. JD JD JD JD etc. and etc. JDJDJDJDJDJDJDJD and etc.";
var searchStr = "etc";
int count = (strOrigin.Length - strOrigin.Replace(searchStr, "").Length)/searchStr.Length.
在丢弃这个不健全/笨拙之前检查性能…
string s = "65 fght 6565 4665 hjk";
int count = 0;
foreach (Match m in Regex.Matches(s, "65"))
count++;
Split (may)胜过IndexOf(用于字符串)。
上面的基准测试似乎表明Richard Watson是最快的字符串，这是错误的(可能差异来自我们的测试数据，但由于下面的原因，它看起来很奇怪)。
如果我们更深入地研究这些方法在.NET中的实现(对于Luke H, Richard Watson方法)，
IndexOf取决于区域性，它将尝试检索/创建ReadOnlySpan，检查是否必须忽略大小写等。最后执行不安全/本机调用。 Split能够处理多个分隔符，并有一些StringSplitOptions 并且必须创建字符串[]数组并用分割结果填充它(所以做一些子字符串)。根据字符串出现的数量，Split可能比IndexOf更快。
顺便说一下，我做了一个简化版本的IndexOf(它可以更快，如果我使用指针和不安全，但不勾选应该是ok的大多数)，它至少快了4个数量级。
基准测试(来源GitHub)
通过搜索一个常见的单词(the)或一个小句子 莎士比亚，理查三世。
| Method | Mean | Error | StdDev | Ratio |
|---|---|---|---|---|
| Richard_LongInLong | 67.721 us | 1.0278 us | 0.9614 us | 1.00 |
| Luke_LongInLong | 1.960 us | 0.0381 us | 0.0637 us | 0.03 |
| Fab_LongInLong | 1.198 us | 0.0160 us | 0.0142 us | 0.02 |
| -------------------- | -----------: | ----------: | ----------: | ------: |
| Richard_ShortInLong | 104.771 us | 2.8117 us | 7.9304 us | 1.00 |
| Luke_ShortInLong | 2.971 us | 0.0594 us | 0.0813 us | 0.03 |
| Fab_ShortInLong | 2.206 us | 0.0419 us | 0.0411 us | 0.02 |
| --------------------- | ----------: | ---------: | ---------: | ------: |
| Richard_ShortInShort | 115.53 ns | 1.359 ns | 1.135 ns | 1.00 |
| Luke_ShortInShort | 52.46 ns | 0.970 ns | 0.908 ns | 0.45 |
| Fab_ShortInShort | 28.47 ns | 0.552 ns | 0.542 ns | 0.25 |
public int GetOccurrences(string input, string needle)
{
int count = 0;
unchecked
{
if (string.IsNullOrEmpty(input) || string.IsNullOrEmpty(needle))
{
return 0;
}
for (var i = 0; i < input.Length - needle.Length + 1; i++)
{
var c = input[i];
if (c == needle[0])
{
for (var index = 0; index < needle.Length; index++)
{
c = input[i + index];
var n = needle[index];
if (c != n)
{
break;
}
else if (index == needle.Length - 1)
{
count++;
}
}
}
}
}
return count;
}
