有效的方法从字符串中删除所有空白?

我正在调用一个REST API，并收到一个XML响应。它返回一个工作区名称列表，并且我正在编写一个快速IsExistingWorkspace()方法。因为所有的工作空间都是由没有空格的连续字符组成的，我假设找出特定工作空间是否在列表中最简单的方法是删除所有空格(包括换行符)并这样做(XML是从web请求接收到的字符串):

XML.Contains("<name>" + workspaceName + "</name>");

我知道这是区分大小写的，我就靠这一点了。我只是需要一种方法来有效地删除字符串中的所有空白。我知道RegEx和LINQ可以做到，但我对其他想法持开放态度。我最关心的是速度。

803859 次浏览
小开
最佳答案

这是我所知道的最快的方法，即使你说你不想使用正则表达式:

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

如果您计划多次这样做，请在评论中注明@ hyperhuman，创建并存储一个Regex实例。这将节省每次构建它的开销，这比您想象的要昂贵得多。

private static readonly Regex sWhitespace = new Regex(@"\s+");
public static string ReplaceWhitespace(string input, string replacement)
{
return sWhitespace.Replace(input, replacement);
}
小开

我假设您的XML响应如下所示:

var xml = @"<names>
<name>
foo
</name>
<name>
bar
</name>
</names>";

处理XML的最佳方法是使用XML解析器，例如LINQ到XML:

var doc = XDocument.Parse(xml);


var containsFoo = doc.Root
.Elements("name")
.Any(e => ((string)e).Trim() == "foo");
小开

试试c#中字符串的替换方法。

XML.Replace(" ", string.Empty);
小开

下面是RegEx解决方案的一个简单的线性替代方案。我不知道哪个更快;你必须对它进行基准测试。

static string RemoveWhitespace(string input)
{
StringBuilder output = new StringBuilder(input.Length);


for (int index = 0; index < input.Length; index++)
{
if (!Char.IsWhiteSpace(input, index))
{
output.Append(input[index]);
}
}
return output.ToString();
}
小开

我有一种没有regexp的替代方法，它的性能似乎相当不错。这是Brandon Moretz回答的延续:

 public static string RemoveWhitespace(this string input)
{
return new string(input.ToCharArray()
.Where(c => !Char.IsWhiteSpace(c))
.ToArray());
}

我在一个简单的单元测试中测试了它:

[Test]
[TestCase("123 123 1adc \n 222", "1231231adc222")]
public void RemoveWhiteSpace1(string input, string expected)
{
string s = null;
for (int i = 0; i < 1000000; i++)
{
s = input.RemoveWhitespace();
}
Assert.AreEqual(expected, s);
}


[Test]
[TestCase("123 123 1adc \n 222", "1231231adc222")]
public void RemoveWhiteSpace2(string input, string expected)
{
string s = null;
for (int i = 0; i < 1000000; i++)
{
s = Regex.Replace(input, @"\s+", "");
}
Assert.AreEqual(expected, s);
}

对于1,000,000次尝试，第一个选项(不带regexp)的运行时间不到一秒(在我的机器上是700毫秒)，第二个需要3.5秒。

小开

只是一个选择，因为它看起来很漂亮:)-注意:henk回答是其中最快的。

input.ToCharArray()
.Where(c => !Char.IsWhiteSpace(c))
.Select(c => c.ToString())
.Aggregate((a, b) => a + b);

在"This is a simple Test"上测试1,000,000个循环

此方法= 1.74秒
Regex = 2.58秒
new String (Henks) = 0.82秒

小开

如果需要出色的性能，在这种情况下应该避免使用LINQ和正则表达式。我做了一些性能基准测试，似乎如果你想从字符串的开头和结尾去除空白，string. trim()是你的最终函数。

如果你需要从字符串中去除所有的空格，下面的方法是最快的:

    public static string RemoveWhitespace(this string input)
{
int j = 0, inputlen = input.Length;
char[] newarr = new char[inputlen];


for (int i = 0; i < inputlen; ++i)
{
char tmp = input[i];


if (!char.IsWhiteSpace(tmp))
{
newarr[j] = tmp;
++j;
}
}
return new String(newarr, 0, j);
}
小开

我需要用空格替换字符串中的空白，但不能重复空格。例如，我需要转换如下内容:

"a b   c\r\n d\t\t\t e"

来

"a b c d e"

我使用了以下方法

private static string RemoveWhiteSpace(string value)
{
if (value == null) { return null; }
var sb = new StringBuilder();


var lastCharWs = false;
foreach (var c in value)
{
if (char.IsWhiteSpace(c))
{
if (lastCharWs) { continue; }
sb.Append(' ');
lastCharWs = true;
}
else
{
sb.Append(c);
lastCharWs = false;
}
}
return sb.ToString();
}
小开

Regex太夸张了;只是在字符串上使用扩展(感谢Henk)。这是微不足道的，应该是框架的一部分。总之，这是我的实现:

public static partial class Extension
{
public static string RemoveWhiteSpace(this string self)
{
return new string(self.Where(c => !Char.IsWhiteSpace(c)).ToArray());
}
}
小开

我发现不同的结果是正确的。我试图用一个空格替换所有空白，正则表达式非常慢。

return( Regex::Replace( text, L"\s+", L" " ) );

对我来说(在c++ cli中)最有效的方法是:

String^ ReduceWhitespace( String^ text )
{
String^ newText;
bool    inWhitespace = false;
Int32   posStart = 0;
Int32   pos      = 0;
for( pos = 0; pos < text->Length; ++pos )
{
wchar_t cc = text[pos];
if( Char::IsWhiteSpace( cc ) )
{
if( !inWhitespace )
{
if( pos > posStart ) newText += text->Substring( posStart, pos - posStart );
inWhitespace = true;
newText += L' ';
}
posStart = pos + 1;
}
else
{
if( inWhitespace )
{
inWhitespace = false;
posStart = pos;
}
}
}


if( pos > posStart ) newText += text->Substring( posStart, pos - posStart );


return( newText );
}

我首先尝试了上面的例程，分别替换每个字符，但不得不切换到为非空格部分执行子字符串。当应用到1,200,000字符的字符串时:

  • 上面的程序可以在25秒内完成
  • 上面的程序+单独的字符替换在95秒内
  • 正则表达式在15分钟后中止。
小开

我的解决方案是使用分裂和连接，它是令人惊讶的快，事实上是这里最快的顶部答案。

str = string.Join("", str.Split(default(string[]), StringSplitOptions.RemoveEmptyEntries));

计时10,000循环的简单字符串与空白inc新行和制表符

  • 分裂/连接= 60毫秒
  • Linq chararray = 94毫秒
  • Regex = 437毫秒

通过在方法中包装它来改进它，赋予它意义，同时也使它成为一个扩展方法……

public static string RemoveWhitespace(this string str) {
return string.Join("", str.Split(default(string[]), StringSplitOptions.RemoveEmptyEntries));
}
小开

这是另一种变体:

public static string RemoveAllWhitespace(string aString)
{
return String.Join(String.Empty, aString.Where(aChar => aChar !Char.IsWhiteSpace(aChar)));
}

与大多数其他解决方案一样，我没有执行详尽的基准测试，但这对于我的目的来说已经足够好了。

小开

在henk回答的基础上，我用他的答案创建了一些测试方法，并添加了一些更优化的方法。我发现输入字符串的大小不同，结果也不同。因此，我使用两个结果集进行了测试。在最快的方法中，链接源有更快的方法。但是，由于它的特点是不安全的，我把它省略了。

长输入字符串结果:

  1. InPlaceCharArray: 2021 ms (Sunsetquest的回答) - (原始来源)
  2. 字符串分离，然后连接:4277ms (Kernowcode的回答)
  3. 字符串读取器:6082毫秒
  4. LINQ使用原生char。IsWhitespace: 7357 ms
  5. LINQ: 7746 ms (Henk的回答)
  6. ForLoop: 32320毫秒
  7. RegexCompiled: 37157毫秒
  8. Regex: 42940毫秒

短输入字符串结果:

  1. InPlaceCharArray: 108 ms (Sunsetquest的回答) - (原始来源)
  2. 字符串分离然后连接:294 ms (Kernowcode的回答)
  3. 字符串读取器:327毫秒
  4. ForLoop: 343毫秒
  5. LINQ使用原生char。IsWhitespace: 624毫秒
  6. LINQ: 645ms (Henk的回答)
  7. RegexCompiled: 1671 ms
  8. Regex: 2599毫秒

代码:

public class RemoveWhitespace
{
public static string RemoveStringReader(string input)
{
var s = new StringBuilder(input.Length); // (input.Length);
using (var reader = new StringReader(input))
{
int i = 0;
char c;
for (; i < input.Length; i++)
{
c = (char)reader.Read();
if (!char.IsWhiteSpace(c))
{
s.Append(c);
}
}
}


return s.ToString();
}


public static string RemoveLinqNativeCharIsWhitespace(string input)
{
return new string(input.ToCharArray()
.Where(c => !char.IsWhiteSpace(c))
.ToArray());
}


public static string RemoveLinq(string input)
{
return new string(input.ToCharArray()
.Where(c => !Char.IsWhiteSpace(c))
.ToArray());
}


public static string RemoveRegex(string input)
{
return Regex.Replace(input, @"\s+", "");
}


private static Regex compiled = new Regex(@"\s+", RegexOptions.Compiled);
public static string RemoveRegexCompiled(string input)
{
return compiled.Replace(input, "");
}


public static string RemoveForLoop(string input)
{
for (int i = input.Length - 1; i >= 0; i--)
{
if (char.IsWhiteSpace(input[i]))
{
input = input.Remove(i, 1);
}
}
return input;
}


public static string StringSplitThenJoin(this string str)
{
return string.Join("", str.Split(default(string[]), StringSplitOptions.RemoveEmptyEntries));
}


public static string RemoveInPlaceCharArray(string input)
{
var len = input.Length;
var src = input.ToCharArray();
int dstIdx = 0;
for (int i = 0; i < len; i++)
{
var ch = src[i];
switch (ch)
{
case '\u0020':
case '\u00A0':
case '\u1680':
case '\u2000':
case '\u2001':
case '\u2002':
case '\u2003':
case '\u2004':
case '\u2005':
case '\u2006':
case '\u2007':
case '\u2008':
case '\u2009':
case '\u200A':
case '\u202F':
case '\u205F':
case '\u3000':
case '\u2028':
case '\u2029':
case '\u0009':
case '\u000A':
case '\u000B':
case '\u000C':
case '\u000D':
case '\u0085':
continue;
default:
src[dstIdx++] = ch;
break;
}
}
return new string(src, 0, dstIdx);
}
}

测试:

[TestFixture]
public class Test
{
// Short input
//private const string input = "123 123 \t 1adc \n 222";
//private const string expected = "1231231adc222";


// Long input
private const string input = "123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222123 123 \t 1adc \n 222";
private const string expected = "1231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc2221231231adc222";


private const int iterations = 1000000;


[Test]
public void RemoveInPlaceCharArray()
{
string s = null;
var stopwatch = Stopwatch.StartNew();
for (int i = 0; i < iterations; i++)
{
s = RemoveWhitespace.RemoveInPlaceCharArray(input);
}


stopwatch.Stop();
Console.WriteLine("InPlaceCharArray: " + stopwatch.ElapsedMilliseconds + " ms");
Assert.AreEqual(expected, s);
}


[Test]
public void RemoveStringReader()
{
string s = null;
var stopwatch = Stopwatch.StartNew();
for (int i = 0; i < iterations; i++)
{
s = RemoveWhitespace.RemoveStringReader(input);
}


stopwatch.Stop();
Console.WriteLine("String reader: " + stopwatch.ElapsedMilliseconds + " ms");
Assert.AreEqual(expected, s);
}


[Test]
public void RemoveLinqNativeCharIsWhitespace()
{
string s = null;
var stopwatch = Stopwatch.StartNew();
for (int i = 0; i < iterations; i++)
{
s = RemoveWhitespace.RemoveLinqNativeCharIsWhitespace(input);
}


stopwatch.Stop();
Console.WriteLine("LINQ using native char.IsWhitespace: " + stopwatch.ElapsedMilliseconds + " ms");
Assert.AreEqual(expected, s);
}


[Test]
public void RemoveLinq()
{
string s = null;
var stopwatch = Stopwatch.StartNew();
for (int i = 0; i < iterations; i++)
{
s = RemoveWhitespace.RemoveLinq(input);
}


stopwatch.Stop();
Console.WriteLine("LINQ: " + stopwatch.ElapsedMilliseconds + " ms");
Assert.AreEqual(expected, s);
}


[Test]
public void RemoveRegex()
{
string s = null;
var stopwatch = Stopwatch.StartNew();
for (int i = 0; i < iterations; i++)
{
s = RemoveWhitespace.RemoveRegex(input);
}


stopwatch.Stop();
Console.WriteLine("Regex: " + stopwatch.ElapsedMilliseconds + " ms");


Assert.AreEqual(expected, s);
}


[Test]
public void RemoveRegexCompiled()
{
string s = null;
var stopwatch = Stopwatch.StartNew();
for (int i = 0; i < iterations; i++)
{
s = RemoveWhitespace.RemoveRegexCompiled(input);
}


stopwatch.Stop();
Console.WriteLine("RegexCompiled: " + stopwatch.ElapsedMilliseconds + " ms");


Assert.AreEqual(expected, s);
}


[Test]
public void RemoveForLoop()
{
string s = null;
var stopwatch = Stopwatch.StartNew();
for (int i = 0; i < iterations; i++)
{
s = RemoveWhitespace.RemoveForLoop(input);
}


stopwatch.Stop();
Console.WriteLine("ForLoop: " + stopwatch.ElapsedMilliseconds + " ms");


Assert.AreEqual(expected, s);
}


[TestMethod]
public void StringSplitThenJoin()
{
string s = null;
var stopwatch = Stopwatch.StartNew();
for (int i = 0; i < iterations; i++)
{
s = RemoveWhitespace.StringSplitThenJoin(input);
}


stopwatch.Stop();
Console.WriteLine("StringSplitThenJoin: " + stopwatch.ElapsedMilliseconds + " ms");


Assert.AreEqual(expected, s);
}
}

编辑:从Kernowcode测试了一个漂亮的一行。

小开

我发现这是一篇很好的文章在CodeProject由Felipe Machado(通过理查德·罗伯逊的帮助)

他测试了十种不同的方法。这是最快的< >强安全< / >强版本…

public static string TrimAllWithInplaceCharArray(string str) {


var len = str.Length;
var src = str.ToCharArray();
int dstIdx = 0;


for (int i = 0; i < len; i++) {
var ch = src[i];


switch (ch) {


case '\u0020': case '\u00A0': case '\u1680': case '\u2000': case '\u2001':


case '\u2002': case '\u2003': case '\u2004': case '\u2005': case '\u2006':


case '\u2007': case '\u2008': case '\u2009': case '\u200A': case '\u202F':


case '\u205F': case '\u3000': case '\u2028': case '\u2029': case '\u0009':


case '\u000A': case '\u000B': case '\u000C': case '\u000D': case '\u0085':
continue;


default:
src[dstIdx++] = ch;
break;
}
}
return new string(src, 0, dstIdx);
}

最快的< /强> < >强不安全版本…(Sunsetquest 2021年5月26日的一些改进)

public static unsafe void RemoveAllWhitespace(ref string str)
{
fixed (char* pfixed = str)
{
char* dst = pfixed;
for (char* p = pfixed; *p != 0; p++)
{
switch (*p)
{
case '\u0020': case '\u00A0': case '\u1680': case '\u2000': case '\u2001':
case '\u2002': case '\u2003': case '\u2004': case '\u2005': case '\u2006':
case '\u2007': case '\u2008': case '\u2009': case '\u200A': case '\u202F':
case '\u205F': case '\u3000': case '\u2028': case '\u2029': case '\u0009':
case '\u000A': case '\u000B': case '\u000C': case '\u000D': case '\u0085':
continue;


default:
*dst++ = *p;
break;
}
}


uint* pi = (uint*)pfixed;
ulong len = ((ulong)dst - (ulong)pfixed) >> 1;
pi[-1] = (uint)len;
pfixed[len] = '\0';
}
}

在Stack Overflow上还有一些由Stian Standahl编写的漂亮的独立的基准，这些独立的基准也显示了Felipe的函数是如何比下一个最快的函数快300%。另外，对于我修改的那个，我使用了这技巧。

小开

我们可以用:

    public static string RemoveWhitespace(this string input)
{
if (input == null)
return null;
return new string(input.ToCharArray()
.Where(c => !Char.IsWhiteSpace(c))
.ToArray());
}
小开

使用Linq，你可以这样写一个可读的方法:

    public static string RemoveAllWhitespaces(this string source)
{
return string.IsNullOrEmpty(source) ? source : new string(source.Where(x => !char.IsWhiteSpace(x)).ToArray());
}
小开

我想很多人来这里是为了消除空格。：

string s = "my string is nice";
s = s.replace(" ", "");
小开

从字符串中删除所有空格的简单方法"example"是初始字符串。

String.Concat(example.Where(c => !Char.IsWhiteSpace(c))

提交答案