如何在C＃中用一个空格替换多个空格？

Question

如何在C＃中只用一个空格替换字符串中的多个空格？

示例：

1 2 3  4    5

将是：

1 2 3 4 5

Answer 1

我喜欢使用：

myString = Regex.Replace(myString, @"\s+", " ");

因为它会捕获任何类型的空格（例如制表符，换行符等），并用一个空格替换它们。

Answer 2

RegexOptions options = RegexOptions.None;
Regex regex = new Regex("[ ]{2,}", options);     
tempo = regex.Replace(tempo, " ");

Answer 3

string xyz = "1   2   3   4   5";
xyz = string.Join( " ", xyz.Split( new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries ));

Answer 4

我认为马特的答案是最好的，但我不相信这是对的。如果要替换换行符，则必须使用：

myString = Regex.Replace(myString, @"\s+", " ", RegexOptions.Multiline);

Answer 5

另一种使用LINQ的方法：

 var list = str.Split(' ').Where(s => !string.IsNullOrWhiteSpace(s));
 str = string.Join(" ", list);

Answer 6

这比所有这些简单得多：

while(str.Contains("  ")) str = str.Replace("  ", " ");

Answer 7

即使是简单的任务，正则表达式也会相当慢。这会创建一个可以在任何$b = imagecopyresampled ($dst_image, $src_image, 0, 0, 0, 0, 150, 150, 150, 150); 之外使用的扩展方法。

string

它将被用作：

    public static class StringExtension
    {
        public static String ReduceWhitespace(this String value)
        {
            var newString = new StringBuilder();
            bool previousIsWhitespace = false;
            for (int i = 0; i < value.Length; i++)
            {
                if (Char.IsWhiteSpace(value[i]))
                {
                    if (previousIsWhitespace)
                    {
                        continue;
                    }

                    previousIsWhitespace = true;
                }
                else
                {
                    previousIsWhitespace = false;
                }

                newString.Append(value[i]);
            }

            return newString.ToString();
        }
    }

Answer 8

myString = Regex.Replace(myString, " {2,}", " ");

Answer 9

对于那些不喜欢Regex的人，这里有一个使用StringBuilder的方法：

    public static string FilterWhiteSpaces(string input)
    {
        if (input == null)
            return string.Empty;

        StringBuilder stringBuilder = new StringBuilder(input.Length);
        for (int i = 0; i < input.Length; i++)
        {
            char c = input[i];
            if (i == 0 || c != ' ' || (c == ' ' && input[i - 1] != ' '))
                stringBuilder.Append(c);
        }
        return stringBuilder.ToString();
    }

在我的测试中，与静态编译的Regex相比，这种方法平均快16倍，中小型字符串非常大。与非编译或非静态正则表达式相比，这应该更快。

请注意，它不删除前导空格或尾随空格，只删除多次此类空格。

Answer 10

您只需在一行解决方案中执行此操作即可！

string s = "welcome to  london";
s.Replace(" ", "()").Replace(")(", "").Replace("()", " ");

如果您愿意，可以选择其他括号（甚至其他字符）。

Answer 11

这是一个较短的版本，只有在你执行此操作时才应该使用它，因为它每次调用时都会创建Regex类的新实例。

temp = new Regex(" {2,}").Replace(temp, " "); 

如果您不熟悉正则表达式，请参阅以下简短说明：

{2,}使正则表达式搜索其前面的字符，并查找2到无限次的子字符串。
.Replace(temp, " ")用空格替换字符串temp中的所有匹配项。

如果你想多次使用它，这是一个更好的选择，因为它在编译时创建了正则表达式IL：

Regex singleSpacify = new Regex(" {2,}", RegexOptions.Compiled);
temp = singleSpacify.Replace(temp, " ");

Answer 12

没有正则表达式，没有Linq ...删除前导空格和尾随空格以及将任何嵌入的多个空格段减少到一个空格

string myString = "   0 1 2  3   4               5  ";
myString = string.Join(" ", myString.Split(new char[] { ' ' }, 
StringSplitOptions.RemoveEmptyEntries));

结果：“0 1 2 3 4 5”

Answer 13

按照乔尔的说法巩固其他答案，并希望在我走的时候轻松改善：

您可以使用Regex.Replace()执行此操作：

string s = Regex.Replace (
    "   1  2    4 5", 
    @"[ ]{2,}", 
    " "
    );

或String.Split()：

static class StringExtensions
{
    public static string Join(this IList<string> value, string separator)
    {
        return string.Join(separator, value.ToArray());
    }
}

//...

string s = "     1  2    4 5".Split (
    " ".ToCharArray(), 
    StringSplitOptions.RemoveEmptyEntries
    ).Join (" ");

Answer 14

我刚刚写了一篇我喜欢的新Join，所以我想我会用它重新回答：

public static string Join<T>(this IEnumerable<T> source, string separator)
{
    return string.Join(separator, source.Select(e => e.ToString()).ToArray());
}

关于这一点的一个很酷的事情是它通过在元素上调用ToString（）来处理非字符串的集合。用法仍然相同：

//...

string s = "     1  2    4 5".Split (
    " ".ToCharArray(), 
    StringSplitOptions.RemoveEmptyEntries
    ).Join (" ");

Answer 15

我知道这已经很老了，但在尝试完成几乎相同的事情时遇到了这个问题。在RegEx Buddy中找到了这个解决方案。此模式将使用单个空格替换所有双空格，并修剪前导和尾随空格。

pattern: (?m:^ +| +$|( ){2,})
replacement: $1

由于我们处理的是空白空间，所以它有点难以阅读，所以这里再次将“空格”替换为“_”。

pattern: (?m:^_+|_+$|(_){2,})  <-- don't use this, just for illustration.

“（？m：”构造启用了“多行”选项。我通常喜欢在模式中包含任何我可以选择的选项，因此它更加自包含。

Answer 16

尝试此方法

private string removeNestedWhitespaces(char[] st)
{
    StringBuilder sb = new StringBuilder();
    int indx = 0, length = st.Length;
    while (indx < length)
    {
        sb.Append(st[indx]);
        indx++;
        while (indx < length && st[indx] == ' ')
            indx++;
        if(sb.Length > 1  && sb[0] != ' ')
            sb.Append(' ');
    }
    return sb.ToString();
}

像这样使用它：

string test = removeNestedWhitespaces("1 2 3  4    5".toCharArray());

Answer 17

我可以用这个

删除空格

while word.contains("  ")  //double space
   word = word.Replace("  "," "); //replace double space by single space.
word = word.trim(); //to remove single whitespces from start & end.

Answer 18

许多答案都提供了正确的输出，但对于那些寻求最佳表现的人来说，我确实将Nolanar's answer（性能的最佳答案）提高了大约10％。

public static string MergeSpaces(this string str)
{

    if (str == null)
    {
        return null;
    }
    else
    {
        StringBuilder stringBuilder = new StringBuilder(str.Length);

        int i = 0;
        foreach (char c in str)
        {
            if (c != ' ' || i == 0 || str[i - 1] != ' ')
                stringBuilder.Append(c);
            i++;
        }
        return stringBuilder.ToString();
    }

}

Answer 19

这是Nolonar original answer上的轻微修改。

检查字符是否不仅是空格，而且是任何空格，请使用以下命令：

它将用单个空格替换任何多个空格字符。

public static string FilterWhiteSpaces(string input)
{
    if (input == null)
        return string.Empty;

    var stringBuilder = new StringBuilder(input.Length);
    for (int i = 0; i < input.Length; i++)
    {
        char c = input[i];
        if (i == 0 || !char.IsWhiteSpace(c) || (char.IsWhiteSpace(c) && 
            !char.IsWhiteSpace(strValue[i - 1])))
            stringBuilder.Append(c);
    }
    return stringBuilder.ToString();
}

Answer 20

旧skool：

string oldText = "   1 2  3   4    5     ";
string newText = oldText
                    .Replace("  ", " " + (char)22 )
                    .Replace( (char)22 + " ", "" )
                    .Replace( (char)22 + "", "" );

Assert.That( newText, Is.EqualTo( " 1 2 3 4 5 " ) );

Answer 21

不使用正则表达式：

while (myString.IndexOf("  ", StringComparison.CurrentCulture) != -1)
{
    myString = myString.Replace("  ", " ");
}

可以在短字符串上使用，但在具有大量空格的长字符串上表现不佳。

Answer 22

使用正则表达式模式

    [ ]+    #only space

   var text = Regex.Replace(inputString, @"[ ]+", " ");

Answer 23

将StringBuilder和Enumerable.Aggregate()的混合作为字符串的扩展方法：

using System;
using System.Linq;
using System.Text;

public static class StringExtension
{
    public static string StripSpaces(this string s)
    {
        return s.Aggregate(new StringBuilder(), (acc, c) =>
        {
            if (c != ' ' || acc.Length > 0 && acc[acc.Length-1] != ' ')
                acc.Append(c);

            return acc;
        }).ToString();
    }

    public static void Main()
    {
        Console.WriteLine("\"" + StringExtension.StripSpaces("1   Hello       World  2   ") + "\"");
    }
}

输入：

"1   Hello       World  2   "

输出：

"1 Hello World 2 "

Answer 24

      // Mysample string
            string str ="hi you           are          a demo";

            //Split the words based on white sapce
            var demo= str .Split(' ').Where(s => !string.IsNullOrWhiteSpace(s));

            //Join the values back and add a single space in between
                    str = string.Join(" ", demo);

//output: string str ="hi you are a demo";

Answer 25

我查看了提议的解决方案，找不到可以处理我的情况可接受的空白字符混合的解决方案，例如：

• Regex.Replace(input, @"\s+", " ") - 它会吃掉你的换行符，如果它们与空格混合，例如 \n \n 序列将被替换为
• Regex.Replace(source, @"(\s)\s+", "$1") - 它将取决于空格的第一个字符，这意味着它可能会再次占用您的换行符
• Regex.Replace(source, @"[ ]{2,}", " ") - 当混合有空白字符时它不会正常工作 - 例如 "\t \t "

可能并不完美，但对我来说快速的解决方案是：

Regex.Replace(input, @"\s+", 
(match) => match.Value.IndexOf('\n') > -1 ? "\n" : " ", RegexOptions.Multiline)

想法是 - 换行胜过空格和制表符。

这不会正确处理 Windows 换行符，但也很容易调整以使用它，不太了解正则表达式 - 可能适合单个模式。