如何在c#中用一个空格替换多个空格?

如何用c#中的一个空格替换字符串中的多个空格?

例子:

1 2 3  4    5

是:

1 2 3 4 5
363893 次浏览
小开
最佳答案 
string sentence = "This is a sentence with multiple    spaces";
RegexOptions options = RegexOptions.None;
Regex regex = new Regex("[ ]{2,}", options);
sentence = regex.Replace(sentence, " ");
小开 
string xyz = "1   2   3   4   5";
xyz = string.Join( " ", xyz.Split( new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries ));
小开

根据Joel的说法，巩固其他答案，并希望随着我的前进略有改善:

你可以使用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 (" ");
小开

其实比这简单得多:

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

我喜欢用:

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

因为它将捕获任何类型的空白(例如制表符，换行符等)的运行，并将它们替换为单个空格。

小开

我刚刚写了一个我喜欢的新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 (" ");
小开 
myString = Regex.Replace(myString, " {2,}", " ");
小开

我认为Matt的答案是最好的，但我不认为它是完全正确的。如果你想替换换行符，你必须使用:

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

另一种使用LINQ的方法:

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

古老的茱莉安:

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

对于那些不喜欢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倍。与非编译或非静态Regex相比，这应该更快。

请记住，它会不删除开头或结尾空格，只会多次出现这种情况。

小开

我知道这很老了，但在尝试完成几乎相同的事情时偶然发现了它。在RegEx Buddy中找到了这个解决方案。该模式将用单个空格替换所有的双空格，并修剪开头和结尾空格。

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

因为我们处理的是空格，所以读起来有点困难，所以这里还是用“_”代替了“空格”。

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

“(?M:" construct启用“多行”选项。我通常喜欢在模式本身中包含任何我可以包含的选项，这样它就更独立了。

小开

您可以简单地在一行解决方案中做到这一点!

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

如果喜欢，可以选择其他括号(甚至其他字符)。

小开

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

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

如果你不太熟悉正则表达式，这里有一个简短的解释:

{2,}让正则表达式搜索它前面的字符，并在2到无限次之间查找子字符串 .Replace(temp, " ")将字符串temp中的所有匹配替换为空格

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

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

Regex即使执行简单的任务也会相当慢。这将创建一个可以在任何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();
}
}

它将被这样使用:

string testValue = "This contains     too          much  whitespace."
testValue = testValue.ReduceWhitespace();
// testValue = "This contains too much whitespace."
小开

# EYZ0

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());
小开

我可以用这个删除空格

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

不使用正则表达式:

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

可以在短弦上使用，但在有很多空格的长弦上表现不佳。

小开

没有Regex，没有Linq…删除开头和结尾空格，并将任何嵌入的多个空格段减少为一个空格

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

结果:“0 1 2 3 4 5”

小开

许多答案都提供了正确的输出，但对于那些寻找最佳性能的人来说，我确实将Nolanar的回答(这是性能的最佳答案)提高了大约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();
}


}
小开

使用正则表达式模式

    [ ]+    #only space


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

混合使用StringBuilder和Enumerable.Aggregate ()作为字符串扩展方法:

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


public static class StringExtension
{
public static string CondenseSpaces(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()
{
const string input = "     (five leading spaces)     (five internal spaces)     (five trailing spaces)     ";
        

Console.WriteLine(" Input: \"{0}\"", input);
Console.WriteLine("Output: \"{0}\"", StringExtension.CondenseSpaces(input));
}
}

执行这个程序产生以下输出:

 Input: "     (five leading spaces)     (five internal spaces)     (five trailing spaces)     "
Output: " (five leading spaces) (five internal spaces) (five trailing spaces) "
小开 
// 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";
小开

这里是轻微的修改在Nolonar原来的答案上。

检查字符是否只是一个空格，而是任何空白，使用这个:

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

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();
}
小开

我仔细查看了建议的解决方案，但没有找到一个可以处理我的情况下可接受的空白字符的混合，例如:

  • 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)

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

这不会正确地处理窗口换行，但它也很容易调整工作，不知道正则表达式那么好-可能是有可能适合单一模式。

小开

要不耍流氓?

public static string MinimizeWhiteSpace(
this string _this)
{
if (_this != null)
{
var returned = new StringBuilder();
var inWhiteSpace = false;
var length = _this.Length;
for (int i = 0; i < length; i++)
{
var character = _this[i];
if (char.IsWhiteSpace(character))
{
if (!inWhiteSpace)
{
inWhiteSpace = true;
returned.Append(' ');
}
}
else
{
inWhiteSpace = false;
returned.Append(character);
}
}
return returned.ToString();
}
else
{
return null;
}
}
小开

下面的代码将所有多个空格删除为一个空格

    public string RemoveMultipleSpacesToSingle(string str)
{
string text = str;
do
{
//text = text.Replace("  ", " ");
text = Regex.Replace(text, @"\s+", " ");
} while (text.Contains("  "));
return text;
}
小开

您可以使用RemoveDoubleSpaces ()这样的方法创建StringsExtensions文件。

StringsExtensions.cs

public static string RemoveDoubleSpaces(this string value)
{
Regex regex = new Regex("[ ]{2,}", RegexOptions.None);
value = regex.Replace(value, " ");


// this removes space at the end of the value (like "demo ")
// and space at the start of the value (like " hi")
value = value.Trim(' ');


return value;
}

然后你可以这样使用它:

string stringInput =" hi here     is  a demo ";


string stringCleaned = stringInput.RemoveDoubleSpaces();

提交答案