string转int - c#字符串




你将如何计算字符串中的字符串(实际上是字符)的出现? (19)

LINQ适用于所有集合,并且由于字符串只是一个字符集合,所以这个漂亮的小单行如何:

var count = source.Count(c => c == '/');

确保你有using System.Linq; 在代码文件的顶部,因为.Count是来自该命名空间的扩展方法。

我正在做一些事情,我意识到我想在一个字符串中能找到多少个/ s,然后它让我感到震惊,有几种方法可以做到,但无法决定什么是最好的(或最简单的)是。

目前,我正在采取如下方式:

string source = "/once/upon/a/time/";
int count = source.Length - source.Replace("/", "").Length;

但我根本不喜欢它,任何接受者?

我真的不想挖掘RegEx ,对吗?

我知道我的字符串将会有我正在搜索的术语,所以你可以假设...

当然对于长度大于1的字符串,

string haystack = "/once/upon/a/time";
string needle = "/";
int needleCount = ( haystack.Length - haystack.Replace(needle,"").Length ) / needle.Length;

编辑:

source.Split('/').Length-1

在C#中,一个不错的String SubString计数器是这个意想不到的棘手问题:

public static int CCount(String haystack, String needle)
{
    return haystack.Split(new[] { needle }, StringSplitOptions.None).Length - 1;
}

如果你想能够搜索整个字符串,而不仅仅是字符:

src.Select((c, i) => src.Substring(i)).Count(sub => sub.StartsWith(target))

读为“,对于字符串中的每个字符,将从该字符开始的字符串的其余部分作为子字符串;如果它以目标字符串开头,则对其进行计数。


如果您使用的是.NET 3.5,则可以使用LINQ进行单行操作:

int count = source.Count(f => f == '/');

如果你不想使用LINQ,你可以这样做:

int count = source.Split('/').Length - 1;

您可能会惊讶地发现,您的原始技术似乎比其中的任何一种都快30%! 我刚刚用“/ once / upon / a / time /”做了一个快速的基准测试,结果如下:

你的原稿= 12
source.Count = 19s
source.Split = 17s
foreach( 来自bobwienholt的回答 )= 10s

(时间是50000次迭代,所以你不可能注意到真实世界中的很多差异。)


字符串出现的通用函数:

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

对于任何想要使用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;
    }
}

对于字符串分隔符的情况(不适用于char类型,如主题所述):
string source =“@@@ once @@@ upon @@@ a @@@ time @@@”;
int count = source.Split(new [] {“@@@”},StringSplitOptions.RemoveEmptyEntries).Length - 1;

海报的原始源值(“/一次/一次/一次/”)自然分隔符是一个字符'/'和响应解释source.Split(char [])选项,但...


我最初的看法给了我一些东西:

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。

编辑后添加一个位,将charIndex(像它应该)添加substring.Length - 1 ,它在11.6秒。

编辑2:我使用了一个有26个双字符字符串的字符串,这里是更新到相同示例文本的时间:

干草堆针(OP版):7.8秒

建议的机制:4.6秒。

编辑3:添加单个角色角落案例,它进入了1.2秒。

编辑4:对于上下文:使用了5000万次迭代。


我认为最简单的方法是使用正则表达式。 通过这种方式,您可以使用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;

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

需要做一些类似的测试来自字符串的条件语句。

用单个字符替换我正在寻找的东西,并计算单个字符的实例。

很明显,您正在使用的单个字符需要在字符串中不存在之前进行检查,以免发生错误计数。


Regex.Matches( Regex.Escape(input),  "stringToMatch" ).Count

private int CountWords(string text, string word) {
    int count = (text.Length - text.Replace(word, "").Length) / word.Length;
    return count;
}

因为最初的解决方案对于字符来说是最快的,所以我认为它也适用于字符串。 所以这是我的贡献。

对于上下文:我在日志文件中查找“失败”和“成功”等字词。

Gr,Ben


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

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

string s = "65 fght 6565 4665 hjk";
int count = 0;
foreach (Match m in Regex.Matches(s, "65"))
  count++;

string search = "/string";
var occurrences = (regex.Match(search, @"\/")).Count;

这将在程序每次发现“/ s”时进行计数(区分大小写),并将其数量存储在变量“occurrences”中


string source = "/once/upon/a/time/";
int count = 0, n = 0;
while ((n = source.IndexOf('/', n) + 1) != 0) count++;

理查德沃森答案的一个变种,在提高效率的同时稍微提高了字符串中字符出现的次数,并减少了代码!

尽管我必须说,没有广泛地测试每一种情况,我确实看到了通过使用以下方面的显着提高速度:

int count = 0;
for (int n = 0; n < source.Length; n++) if (source[n] == '/') count++;

string source = "/once/upon/a/time/";
int count = 0;
int n = 0;

while ((n = source.IndexOf('/', n)) != -1)
{
   n++;
   count++;
}

在我的电脑上,它的速度比每字符解决方案快5000万次迭代快2秒。

2013修订版:

将字符串更改为char []并遍历该字符串。 在总共50m迭代的时间内再削减一两秒!

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 []技术已经。 不过,我认为逆转技巧在这方面是新的。

迭代C#中的字符串中的单个字符的最快方法是什么?





string