我正在做的事情，我意识到我想要计算我能在字符串中找到多少/，然后它让我感到震惊，有几种方法可以做到，但无法决定什么是最好的（或最简单的）。
目前我正在寻找类似的东西：
string source = "/once/upon/a/time/";
int count = source.Length - source.Replace("/", "").Length;
但我完全不喜欢它，任何接受者？
我真的不想为此挖出RegEx，是吗？
我知道我的字符串会有我正在搜索的字词，所以你可以认为......
当然对于字符串其中 长度＆gt; 1 ，
string haystack = "/once/upon/a/time";
string needle = "/";
int needleCount = ( haystack.Length - haystack.Replace(needle,"").Length ) / needle.Length;
答案 0 :(得分：898)
如果您使用的是.NET 3.5，则可以使用LINQ：
进行单行编写int count = source.Count(f => f == '/');
如果您不想使用LINQ，可以使用：
int count = source.Split('/').Length - 1;
您可能会惊讶地发现，您的原始技术似乎比其中任何一种快约30％！我刚用“/ once / on / a / time /”做了快速基准测试，结果如下：
您的原件= 12s
source.Count = 19s
source.Split = 17s
foreach（from bobwienholt's answer）= 10s
（时间是50,000,000次迭代，所以你不太可能注意到现实世界中的太多差异。）
答案 1 :(得分：164)
string source = "/once/upon/a/time/";
int count = 0;
foreach (char c in source)
if (c == '/') count++;
必须比source.Replace()本身更快。
答案 2 :(得分：127)
int count = new Regex(Regex.Escape(needle)).Matches(haystack).Count;
答案 3 :(得分：82)
如果您希望能够搜索整个字符串，而不仅仅是字符：
src.Select((c, i) => src.Substring(i))
.Count(sub => sub.StartsWith(target))
读取为“对于字符串中的每个字符，将该字符的其余部分从该字符开始作为子字符串;如果它以目标字符串开头，则计算它。”
答案 4 :(得分：61)
我做了一些研究，发现Richard Watson's解决方案在大多数情况下都是最快的。这是包含帖子中每个解决方案结果的表格（除了那些使用 Regex ，因为它在解析字符串时抛出异常，如“test {test”）
Name | Short/char | Long/char | Short/short| Long/short | Long/long |
Inspite | 134| 1853| 95| 1146| 671|
LukeH_1 | 346| 4490| N/A| N/A| N/A|
LukeH_2 | 152| 1569| 197| 2425| 2171|
Bobwienholt | 230| 3269| N/A| N/A| N/A|
Richard Watson| 33| 298| 146| 737| 543|
StefanosKargas| N/A| N/A| 681| 11884| 12486|
您可以看到，如果在短字符串（10-50个字符）中查找短子串（1-5个字符）的出现次数，则首选原始算法。
此外，对于多字符子字符串，您应该使用以下代码（基于Richard Watson's解决方案）
int count = 0, n = 0;
if(substring != "")
{
while ((n = source.IndexOf(substring, n, StringComparison.InvariantCulture)) != -1)
{
n += substring.Length;
++count;
}
}
答案 5 :(得分：53)
LINQ适用于所有集合，因为字符串只是一个字符集合，所以这个漂亮的小单行如何：
var count = source.Count(c => c == '/');
确保代码文件顶部有using System.Linq;，因为.Count是该命名空间的扩展方法。
答案 6 :(得分：47)
string source = "/once/upon/a/time/";
int count = 0;
int n = 0;
while ((n = source.IndexOf('/', n)) != -1)
{
n++;
count++;
}
在我的计算机上，它比5000万次迭代的每个角色解决方案快约2秒。
2013年修订：
将字符串更改为char []并迭代它。将总时间再缩短一两秒，进行50米迭代！
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++;
}
我想知道为什么会这样，并且谷歌搜索（我记得有关反向迭代更快的事情），并且发现了这个烦人地使用字符串char []技术的问题。不过，我认为逆转技巧在这方面是新的。
What is the fastest way to iterate through individual characters in a string in C#?
答案 7 :(得分：45)
这两者仅适用于单字符搜索术语......
countOccurences("the", "the answer is the answer");
int countOccurences(string needle, string haystack)
{
return (haystack.Length - haystack.Replace(needle,"").Length) / needle.Length;
}
对于更长的针可能会更好......
但必须有一种更优雅的方式。 ：）
答案 8 :(得分：19)
修改
source.Split('/').Length-1
答案 9 :(得分：14)
Regex.Matches(input, Regex.Escape("stringToMatch")).Count
答案 10 :(得分：14)
在C＃中，一个不错的String SubString计数器就是这个意想不到的棘手问题：
public static int CCount(String haystack, String needle)
{
return haystack.Split(new[] { needle }, StringSplitOptions.None).Length - 1;
}
答案 11 :(得分：11)
string s = "65 fght 6565 4665 hjk";
int count = 0;
foreach (Match m in Regex.Matches(s, "65"))
count++;
答案 12 :(得分：11)
private int CountWords(string text, string word) {
int count = (text.Length - text.Replace(word, "").Length) / word.Length;
return count;
}
因为原始解决方案对于字符来说是最快的，所以我认为它也适用于字符串。所以这是我的贡献。
对于上下文：我在日志文件中寻找“失败”和“成功”等字样。
GR， 本
答案 13 :(得分：7)
对于任何想要使用String扩展方法的人来说，
这里是我使用的，它基于最好的答案：
public static class StringExtension
{
/// <summary> Returns the number of occurences of a string within a string, optional comparison allows case and culture control. </summary>
public static int Occurrences(this System.String input, string value, StringComparison stringComparisonType = StringComparison.Ordinal)
{
if (String.IsNullOrEmpty(value)) return 0;
int count = 0;
int position = 0;
while ((position = input.IndexOf(value, position, stringComparisonType)) != -1)
{
position += value.Length;
count += 1;
}
return count;
}
/// <summary> Returns the number of occurences of a single character within a string. </summary>
public static int Occurrences(this System.String input, char value)
{
int count = 0;
foreach (char c in input) if (c == value) count += 1;
return count;
}
}
答案 14 :(得分：6)
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;
}
答案 15 :(得分：5)
我认为最简单的方法是使用正则表达式。通过这种方式，您可以获得与使用myVar.Split（'x'）相同的拆分计数，但是在多字符设置中。
string myVar = "do this to count the number of words in my wording so that I can word it up!";
int count = Regex.Split(myVar, "word").Length;
答案 16 :(得分：3)
string search = "/string";
var occurrences = (regex.Match(search, @"\/")).Count;
每次程序找到＆＃34; / s＆＃34;完全（区分大小写）和 它的出现次数将存储在变量＆＃34; occurrence＆＃34;
中答案 17 :(得分：2)
字符串中的字符串：
查找＆＃34;等＆＃34; in＆＃34; .. JD JD JD JD等JDJDJDJDJDJDJDJD等等＃34;
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.
检查性能，然后将其丢弃为不健全/笨拙......
答案 18 :(得分：2)
我觉得我们缺少某些类型的子字符串计数，例如不安全的逐字节比较。我把原始海报的方法和我能想到的任何方法放在一起。
这些是我做的字符串扩展。
namespace Example
{
using System;
using System.Text;
public static class StringExtensions
{
public static int CountSubstr(this string str, string substr)
{
return (str.Length - str.Replace(substr, "").Length) / substr.Length;
}
public static int CountSubstr(this string str, char substr)
{
return (str.Length - str.Replace(substr.ToString(), "").Length);
}
public static int CountSubstr2(this string str, string substr)
{
int substrlen = substr.Length;
int lastIndex = str.IndexOf(substr, 0, StringComparison.Ordinal);
int count = 0;
while (lastIndex != -1)
{
++count;
lastIndex = str.IndexOf(substr, lastIndex + substrlen, StringComparison.Ordinal);
}
return count;
}
public static int CountSubstr2(this string str, char substr)
{
int lastIndex = str.IndexOf(substr, 0);
int count = 0;
while (lastIndex != -1)
{
++count;
lastIndex = str.IndexOf(substr, lastIndex + 1);
}
return count;
}
public static int CountChar(this string str, char substr)
{
int length = str.Length;
int count = 0;
for (int i = 0; i < length; ++i)
if (str[i] == substr)
++count;
return count;
}
public static int CountChar2(this string str, char substr)
{
int count = 0;
foreach (var c in str)
if (c == substr)
++count;
return count;
}
public static unsafe int CountChar3(this string str, char substr)
{
int length = str.Length;
int count = 0;
fixed (char* chars = str)
{
for (int i = 0; i < length; ++i)
if (*(chars + i) == substr)
++count;
}
return count;
}
public static unsafe int CountChar4(this string str, char substr)
{
int length = str.Length;
int count = 0;
fixed (char* chars = str)
{
for (int i = length - 1; i >= 0; --i)
if (*(chars + i) == substr)
++count;
}
return count;
}
public static unsafe int CountSubstr3(this string str, string substr)
{
int length = str.Length;
int substrlen = substr.Length;
int count = 0;
fixed (char* strc = str)
{
fixed (char* substrc = substr)
{
int n = 0;
for (int i = 0; i < length; ++i)
{
if (*(strc + i) == *(substrc + n))
{
++n;
if (n == substrlen)
{
++count;
n = 0;
}
}
else
n = 0;
}
}
}
return count;
}
public static int CountSubstr3(this string str, char substr)
{
return CountSubstr3(str, substr.ToString());
}
public static unsafe int CountSubstr4(this string str, string substr)
{
int length = str.Length;
int substrLastIndex = substr.Length - 1;
int count = 0;
fixed (char* strc = str)
{
fixed (char* substrc = substr)
{
int n = substrLastIndex;
for (int i = length - 1; i >= 0; --i)
{
if (*(strc + i) == *(substrc + n))
{
if (--n == -1)
{
++count;
n = substrLastIndex;
}
}
else
n = substrLastIndex;
}
}
}
return count;
}
public static int CountSubstr4(this string str, char substr)
{
return CountSubstr4(str, substr.ToString());
}
}
}
接着是测试代码...
static void Main()
{
const char matchA = '_';
const string matchB = "and";
const string matchC = "muchlongerword";
const string testStrA = "_and_d_e_banna_i_o___pfasd__and_d_e_banna_i_o___pfasd_";
const string testStrB = "and sdf and ans andeians andano ip and and sdf and ans andeians andano ip and";
const string testStrC =
"muchlongerword amuchlongerworsdfmuchlongerwordsdf jmuchlongerworijv muchlongerword sdmuchlongerword dsmuchlongerword";
const int testSize = 1000000;
Console.WriteLine(testStrA.CountSubstr('_'));
Console.WriteLine(testStrA.CountSubstr2('_'));
Console.WriteLine(testStrA.CountSubstr3('_'));
Console.WriteLine(testStrA.CountSubstr4('_'));
Console.WriteLine(testStrA.CountChar('_'));
Console.WriteLine(testStrA.CountChar2('_'));
Console.WriteLine(testStrA.CountChar3('_'));
Console.WriteLine(testStrA.CountChar4('_'));
Console.WriteLine(testStrB.CountSubstr("and"));
Console.WriteLine(testStrB.CountSubstr2("and"));
Console.WriteLine(testStrB.CountSubstr3("and"));
Console.WriteLine(testStrB.CountSubstr4("and"));
Console.WriteLine(testStrC.CountSubstr("muchlongerword"));
Console.WriteLine(testStrC.CountSubstr2("muchlongerword"));
Console.WriteLine(testStrC.CountSubstr3("muchlongerword"));
Console.WriteLine(testStrC.CountSubstr4("muchlongerword"));
var timer = new Stopwatch();
timer.Start();
for (int i = 0; i < testSize; ++i)
testStrA.CountSubstr(matchA);
timer.Stop();
Console.WriteLine("CS1 chr: " + timer.Elapsed.TotalMilliseconds + "ms");
timer.Restart();
for (int i = 0; i < testSize; ++i)
testStrB.CountSubstr(matchB);
timer.Stop();
Console.WriteLine("CS1 and: " + timer.Elapsed.TotalMilliseconds + "ms");
timer.Restart();
for (int i = 0; i < testSize; ++i)
testStrC.CountSubstr(matchC);
timer.Stop();
Console.WriteLine("CS1 mlw: " + timer.Elapsed.TotalMilliseconds + "ms");
timer.Restart();
for (int i = 0; i < testSize; ++i)
testStrA.CountSubstr2(matchA);
timer.Stop();
Console.WriteLine("CS2 chr: " + timer.Elapsed.TotalMilliseconds + "ms");
timer.Restart();
for (int i = 0; i < testSize; ++i)
testStrB.CountSubstr2(matchB);
timer.Stop();
Console.WriteLine("CS2 and: " + timer.Elapsed.TotalMilliseconds + "ms");
timer.Restart();
for (int i = 0; i < testSize; ++i)
testStrC.CountSubstr2(matchC);
timer.Stop();
Console.WriteLine("CS2 mlw: " + timer.Elapsed.TotalMilliseconds + "ms");
timer.Restart();
for (int i = 0; i < testSize; ++i)
testStrA.CountSubstr3(matchA);
timer.Stop();
Console.WriteLine("CS3 chr: " + timer.Elapsed.TotalMilliseconds + "ms");
timer.Restart();
for (int i = 0; i < testSize; ++i)
testStrB.CountSubstr3(matchB);
timer.Stop();
Console.WriteLine("CS3 and: " + timer.Elapsed.TotalMilliseconds + "ms");
timer.Restart();
for (int i = 0; i < testSize; ++i)
testStrC.CountSubstr3(matchC);
timer.Stop();
Console.WriteLine("CS3 mlw: " + timer.Elapsed.TotalMilliseconds + "ms");
timer.Restart();
for (int i = 0; i < testSize; ++i)
testStrA.CountSubstr4(matchA);
timer.Stop();
Console.WriteLine("CS4 chr: " + timer.Elapsed.TotalMilliseconds + "ms");
timer.Restart();
for (int i = 0; i < testSize; ++i)
testStrB.CountSubstr4(matchB);
timer.Stop();
Console.WriteLine("CS4 and: " + timer.Elapsed.TotalMilliseconds + "ms");
timer.Restart();
for (int i = 0; i < testSize; ++i)
testStrC.CountSubstr4(matchC);
timer.Stop();
Console.WriteLine("CS4 mlw: " + timer.Elapsed.TotalMilliseconds + "ms");
timer.Restart();
for (int i = 0; i < testSize; ++i)
testStrA.CountChar(matchA);
timer.Stop();
Console.WriteLine("CC1 chr: " + timer.Elapsed.TotalMilliseconds + "ms");
timer.Restart();
for (int i = 0; i < testSize; ++i)
testStrA.CountChar2(matchA);
timer.Stop();
Console.WriteLine("CC2 chr: " + timer.Elapsed.TotalMilliseconds + "ms");
timer.Restart();
for (int i = 0; i < testSize; ++i)
testStrA.CountChar3(matchA);
timer.Stop();
Console.WriteLine("CC3 chr: " + timer.Elapsed.TotalMilliseconds + "ms");
timer.Restart();
for (int i = 0; i < testSize; ++i)
testStrA.CountChar4(matchA);
timer.Stop();
Console.WriteLine("CC4 chr: " + timer.Elapsed.TotalMilliseconds + "ms");
}
结果：CSX对应CountSubstrX，CCX对应CountCharX。 “ chr”在字符串中搜索“ _”，“ and”在字符串中搜索“ and”，而“ mlw”在字符串中搜索“ muchlongerword”
CS1 chr: 824.123ms
CS1 and: 586.1893ms
CS1 mlw: 486.5414ms
CS2 chr: 127.8941ms
CS2 and: 806.3918ms
CS2 mlw: 497.318ms
CS3 chr: 201.8896ms
CS3 and: 124.0675ms
CS3 mlw: 212.8341ms
CS4 chr: 81.5183ms
CS4 and: 92.0615ms
CS4 mlw: 116.2197ms
CC1 chr: 66.4078ms
CC2 chr: 64.0161ms
CC3 chr: 65.9013ms
CC4 chr: 65.8206ms
最后，我有一个包含360万个字符的文件。重复了100,000次“ derp adfderdserp dfaerpderp deasderp”。我使用上述方法在文件内搜索“ derp”，结果是这些结果的100倍。
CS1Derp: 1501.3444ms
CS2Derp: 1585.797ms
CS3Derp: 376.0937ms
CS4Derp: 271.1663ms
所以我的第四种方法绝对是赢家，但实际上，如果一个360万个字符文件100次仅花了1586毫秒（最坏的情况），那么所有这些都可以忽略不计。
顺便说一句，我还使用100倍CountSubstr和CountChar方法扫描了360万个字符文件中的'd'字符。结果...
CS1 d : 2606.9513ms
CS2 d : 339.7942ms
CS3 d : 960.281ms
CS4 d : 233.3442ms
CC1 d : 302.4122ms
CC2 d : 280.7719ms
CC3 d : 299.1125ms
CC4 d : 292.9365ms
据此，原始的海报方法对于大干草堆中的单个字符的针非常不利。
注意：所有值已更新为“发行版本”输出。我第一次发布此内容时，意外地忘记了建立在Release模式上。我的某些声明已被修改。
答案 19 :(得分：2)
var conditionalStatement = conditionSetting.Value;
//order of replace matters, remove == before =, incase of ===
conditionalStatement = conditionalStatement.Replace("==", "~").Replace("!=", "~").Replace('=', '~').Replace('!', '~').Replace('>', '~').Replace('<', '~').Replace(">=", "~").Replace("<=", "~");
var listOfValidConditions = new List<string>() { "!=", "==", ">", "<", ">=", "<=" };
if (conditionalStatement.Count(x => x == '~') != 1)
{
result.InvalidFieldList.Add(new KeyFieldData(batch.DECurrentField, "The IsDoubleKeyCondition does not contain a supported conditional statement. Contact System Administrator."));
result.Status = ValidatorStatus.Fail;
return result;
}
需要做类似于从字符串测试条件语句的操作。
用单个字符替换我想要的东西并计算单个字符的实例。
显然，在发生这种情况之前，需要检查您使用的单个字符是否存在于字符串中，以避免错误计数。
答案 20 :(得分：2)
string source = "/once/upon/a/time/";
int count = 0, n = 0;
while ((n = source.IndexOf('/', n) + 1) != 0) count++;
Richard Watson答案的一个变体，提高效率的速度越快，字符串中字符出现的次数越多，代码越少！
虽然我必须说，如果不对每个场景进行广泛测试，我确实通过使用以下方式看到了非常显着的速度提升：
int count = 0;
for (int n = 0; n < source.Length; n++) if (source[n] == '/') count++;
答案 21 :(得分：2)
出现字符串的通用函数：
public int getNumberOfOccurencies(String inputString, String checkString)
{
if (checkString.Length > inputString.Length || checkString.Equals("")) { return 0; }
int lengthDifference = inputString.Length - checkString.Length;
int occurencies = 0;
for (int i = 0; i < lengthDifference; i++) {
if (inputString.Substring(i, checkString.Length).Equals(checkString)) { occurencies++; i += checkString.Length - 1; } }
return occurencies;
}
答案 22 :(得分：1)
string s = "HOWLYH THIS ACTUALLY WORKSH WOWH";
int count = 0;
for (int i = 0; i < s.Length; i++)
if (s[i] == 'H') count++;
它只是检查字符串中的每个字符，如果字符是您要搜索的字符，请添加一个来计算。
答案 23 :(得分：1)
如果您check out this webpage，则会对15种不同的方法进行基准测试，包括使用并行循环。
最快的方式似乎是使用单线程for循环（如果你有.Net版本＆lt; 4.0）或parallel.for循环（如果使用带有数千个检查的.Net＆gt; 4.0）。
假设＆＃34; ss＆＃34;是你的搜索字符串，＆＃34; ch＆＃34;是你的角色数组（如果你有多个你正在寻找的字符），这里是单线程运行时间最快的代码的基本要点：
for (int x = 0; x < ss.Length; x++)
{
for (int y = 0; y < ch.Length; y++)
{
for (int a = 0; a < ss[x].Length; a++ )
{
if (ss[x][a] == ch[y])
//it's found. DO what you need to here.
}
}
}
也提供了基准源代码，因此您可以运行自己的测试。
答案 24 :(得分：1)
以为我会将我的扩展方法抛入环中（有关详细信息，请参阅注释）。我没有做任何正式的替补标记，但我认为对于大多数情况来说它必须非常快。
编辑：好的 - 所以这个问题让我想知道我们当前实现的性能如何与这里提出的一些解决方案相叠加。我决定做一个小板凳标记，发现我们的解决方案非常符合Richard Watson提供的解决方案的性能，直到您使用大字符串（100 Kb +），大型子串（32 Kb +）进行积极搜索）和许多嵌入式重复（10K +）。那时我们的解决方案速度慢了2到4倍。鉴于此以及我们非常喜欢Richard Watson提出的解决方案这一事实，我们已相应地重构了我们的解决方案。我只想让任何可能从中受益的人都可以使用它。
我们最初的解决方案：
/// <summary>
/// Counts the number of occurrences of the specified substring within
/// the current string.
/// </summary>
/// <param name="s">The current string.</param>
/// <param name="substring">The substring we are searching for.</param>
/// <param name="aggressiveSearch">Indicates whether or not the algorithm
/// should be aggressive in its search behavior (see Remarks). Default
/// behavior is non-aggressive.</param>
/// <remarks>This algorithm has two search modes - aggressive and
/// non-aggressive. When in aggressive search mode (aggressiveSearch =
/// true), the algorithm will try to match at every possible starting
/// character index within the string. When false, all subsequent
/// character indexes within a substring match will not be evaluated.
/// For example, if the string was 'abbbc' and we were searching for
/// the substring 'bb', then aggressive search would find 2 matches
/// with starting indexes of 1 and 2. Non aggressive search would find
/// just 1 match with starting index at 1. After the match was made,
/// the non aggressive search would attempt to make it's next match
/// starting at index 3 instead of 2.</remarks>
/// <returns>The count of occurrences of the substring within the string.</returns>
public static int CountOccurrences(this string s, string substring,
bool aggressiveSearch = false)
{
// if s or substring is null or empty, substring cannot be found in s
if (string.IsNullOrEmpty(s) || string.IsNullOrEmpty(substring))
return 0;
// if the length of substring is greater than the length of s,
// substring cannot be found in s
if (substring.Length > s.Length)
return 0;
var sChars = s.ToCharArray();
var substringChars = substring.ToCharArray();
var count = 0;
var sCharsIndex = 0;
// substring cannot start in s beyond following index
var lastStartIndex = sChars.Length - substringChars.Length;
while (sCharsIndex <= lastStartIndex)
{
if (sChars[sCharsIndex] == substringChars[0])
{
// potential match checking
var match = true;
var offset = 1;
while (offset < substringChars.Length)
{
if (sChars[sCharsIndex + offset] != substringChars[offset])
{
match = false;
break;
}
offset++;
}
if (match)
{
count++;
// if aggressive, just advance to next char in s, otherwise,
// skip past the match just found in s
sCharsIndex += aggressiveSearch ? 1 : substringChars.Length;
}
else
{
// no match found, just move to next char in s
sCharsIndex++;
}
}
else
{
// no match at current index, move along
sCharsIndex++;
}
}
return count;
}
这是我们修订的解决方案：
/// <summary>
/// Counts the number of occurrences of the specified substring within
/// the current string.
/// </summary>
/// <param name="s">The current string.</param>
/// <param name="substring">The substring we are searching for.</param>
/// <param name="aggressiveSearch">Indicates whether or not the algorithm
/// should be aggressive in its search behavior (see Remarks). Default
/// behavior is non-aggressive.</param>
/// <remarks>This algorithm has two search modes - aggressive and
/// non-aggressive. When in aggressive search mode (aggressiveSearch =
/// true), the algorithm will try to match at every possible starting
/// character index within the string. When false, all subsequent
/// character indexes within a substring match will not be evaluated.
/// For example, if the string was 'abbbc' and we were searching for
/// the substring 'bb', then aggressive search would find 2 matches
/// with starting indexes of 1 and 2. Non aggressive search would find
/// just 1 match with starting index at 1. After the match was made,
/// the non aggressive search would attempt to make it's next match
/// starting at index 3 instead of 2.</remarks>
/// <returns>The count of occurrences of the substring within the string.</returns>
public static int CountOccurrences(this string s, string substring,
bool aggressiveSearch = false)
{
// if s or substring is null or empty, substring cannot be found in s
if (string.IsNullOrEmpty(s) || string.IsNullOrEmpty(substring))
return 0;
// if the length of substring is greater than the length of s,
// substring cannot be found in s
if (substring.Length > s.Length)
return 0;
int count = 0, n = 0;
while ((n = s.IndexOf(substring, n, StringComparison.InvariantCulture)) != -1)
{
if (aggressiveSearch)
n++;
else
n += substring.Length;
count++;
}
return count;
}
答案 25 :(得分：1)
string Name = "Very good nice one is very good but is very good nice one this is called the term";
bool valid=true;
int count = 0;
int k=0;
int m = 0;
while (valid)
{
k = Name.Substring(m,Name.Length-m).IndexOf("good");
if (k != -1)
{
count++;
m = m + k + 4;
}
else
valid = false;
}
Console.WriteLine(count + " Times accures");
答案 26 :(得分：1)
我最初的看法给了我类似的东西：
public static int CountOccurrences(string original, string substring)
{
if (string.IsNullOrEmpty(substring))
return 0;
if (substring.Length == 1)
return CountOccurrences(original, substring[0]);
if (string.IsNullOrEmpty(original) ||
substring.Length > original.Length)
return 0;
int substringCount = 0;
for (int charIndex = 0; charIndex < original.Length; charIndex++)
{
for (int subCharIndex = 0, secondaryCharIndex = charIndex; subCharIndex < substring.Length && secondaryCharIndex < original.Length; subCharIndex++, secondaryCharIndex++)
{
if (substring[subCharIndex] != original[secondaryCharIndex])
goto continueOuter;
}
if (charIndex + substring.Length > original.Length)
break;
charIndex += substring.Length - 1;
substringCount++;
continueOuter:
;
}
return substringCount;
}
public static int CountOccurrences(string original, char @char)
{
if (string.IsNullOrEmpty(original))
return 0;
int substringCount = 0;
for (int charIndex = 0; charIndex < original.Length; charIndex++)
if (@char == original[charIndex])
substringCount++;
return substringCount;
}
使用替换和分割的大海捞针方法产生21秒以上，而这大约需要15.2秒。
在添加一个将substring.Length - 1添加到charIndex的位（就像它应该）之后进行编辑，它是11.6秒。
编辑2：我使用了一个包含26个双字符串的字符串，以下是更新为相同示例文本的时间：
大海捞针（OP版）：7.8秒
建议机制：4.6秒。
编辑3：添加单个字符的角落情况，它变为1.2秒。
编辑4：对于上下文：使用了5000万次迭代。
答案 27 :(得分：1)
对于字符串分隔符的情况（不是对于char情况，如主题所说）：
string source =“@@@ once @@@ on @@@ a @@@ time @@@”;
int count = source.Split（new [] {“@@@”}，StringSplitOptions.RemoveEmptyEntries）.Length - 1;
海报的原始源值（“/ once / on / a / time /”）自然分隔符是一个char'/'，响应确实解释了source.Split（char []）选项虽然......
答案 28 :(得分：1)
str="aaabbbbjjja";
int count = 0;
int size = str.Length;
string[] strarray = new string[size];
for (int i = 0; i < str.Length; i++)
{
strarray[i] = str.Substring(i, 1);
}
Array.Sort(strarray);
str = "";
for (int i = 0; i < strarray.Length - 1; i++)
{
if (strarray[i] == strarray[i + 1])
{
count++;
}
else
{
count++;
str = str + strarray[i] + count;
count = 0;
}
}
count++;
str = str + strarray[strarray.Length - 1] + count;
这用于计算字符的出现次数。对于此示例，输出将为“a4b4j3”
答案 29 :(得分：1)
从 .NET 5（Net core 2.1+ 和 NetStandard 2.1）开始，我们有了一个新的迭代速度之王。
“跨度
和 String 有一个内置成员，它返回一个 Span
int count = 0;
foreach( var c in source.AsSpan())
{
if (c == '/')
count++;
}
我的测试显示比直接 foreach 快 62%。我还与 Span
Starting test, 10000000 iterations
(base) foreach = 673 ms
fastest to slowest
foreach Span = 252 ms 62.6%
Span [i--] = 282 ms 58.1%
Span [i++] = 402 ms 40.3%
for [i++] = 454 ms 32.5%
for [i--] = 867 ms -28.8%
Replace = 1905 ms -183.1%
Split = 2109 ms -213.4%
Linq.Count = 3797 ms -464.2%
答案 30 :(得分：0)
使用System.Linq;
int CountOf =>“ A :: B C :: D” .Split（“ ::”）。长度-1;
答案 31 :(得分：0)
**计算字符或字符串**
string st = "asdfasdfasdfsadfasdf/asdfasdfas/dfsdfsdafsdfsd/fsadfasdf/dff";
int count = 0;
int location = 0;
while (st.IndexOf("/", location + 1) > 0)
{
count++;
location = st.IndexOf("/", location + 1);
}
MessageBox.Show(count.ToString());