从字符串中删除所有空格的有效方法
本文关键字：空格 有效 方法 字符串 删除 | 更新日期: 2023-09-27 17:58:21
我正在调用一个 REST API，并收到一个 XML 响应。它返回工作区名称的列表，我正在编写一个快速IsExistingWorkspace()方法。由于所有工作区都由没有空格的连续字符组成，因此我假设确定特定工作区是否在列表中的最简单方法是删除所有空格(包括换行符(并执行此操作(XML是从Web请求接收的字符串(：
XML.Contains("<name>" + workspaceName + "</name>");
我知道它是区分大小写的，我依赖于它。我只需要一种方法来有效地删除字符串中的所有空格。我知道RegEx和LINQ可以做到这一点，但我对其他想法持开放态度。我主要只关心速度。
这是我所知道的最快的方法，即使你说你不想使用正则表达式：
Regex.Replace(XML, @"'s+", "");
注释中的信用@hypehuman，如果您计划多次执行此操作，请创建并存储正则表达式实例。这将节省每次构建它的开销，这比您想象的要昂贵。
private static readonly Regex sWhitespace = new Regex(@"'s+");
public static string ReplaceWhitespace(string input, string replacement)
{
return sWhitespace.Replace(input, replacement);
}
我有一种没有正则表达式的替代方法，它似乎表现得很好。这是布兰登·莫瑞兹(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 次尝试，第一个选项(没有正则表达式(在不到一秒(在我的机器上为 700 毫秒(内运行，第二个选项需要 3.5 秒。
尝试在
C# 中替换字符串的方法。
XML.Replace(" ", string.Empty);
我的解决方案是使用拆分和加入，它的速度非常快，实际上是这里最快的答案。
str = string.Join("", str.Split(default(string[]), StringSplitOptions.RemoveEmptyEntries));
带有空格的简单字符串上的 10,000 个循环的计时，包括新行和制表符
- 拆分/加入 = 60 毫秒
- LINQ 字符数组 = 94 毫秒
- 正则表达式 = 437 毫秒
通过将其包装在方法中以赋予它意义来改进它，并在我们使用它时使其成为扩展方法......
public static string RemoveWhitespace(this string str) {
return string.Join("", str.Split(default(string[]), StringSplitOptions.RemoveEmptyEntries));
}
在Henks答案的基础上，我用他的答案创建了一些测试方法，并添加了一些更优化的方法。我发现结果因输入字符串的大小而异。因此，我用两个结果集进行了测试。在最快的方法中，链接源具有更快的方法。但是，由于它被描述为不安全，我把它排除在外。
长输入字符串结果：
- 就地字符数组：2021 毫秒(日落任务的答案(-(原始来源(
- 字符串拆分然后连接：4277ms(Kernowcode的答案(
- 字符串读取器：6082 ms
- 使用本机字符的 LINQ。Is空白：7357 ms
- LINQ：7746 毫秒(亨克的答案(
- ForLoop： 32320 ms
- 正则表达式编译： 37157 ms
- 正则表达式：42940 ms
短输入字符串结果：
- InPlaceCharArray： 108 ms (Sunsetquest的答案( - (原始来源(
- 字符串拆分然后连接：294 毫秒(Kernowcode 的答案(
- 字符串读取器：327 ms
- ForLoop： 343 ms
- 使用本机字符的 LINQ。IsWhitespace： 624 ms
- LINQ：645ms (Henk 的答案(
- 正则表达式编译： 1671 ms
- 正则表达式：2599 ms
代码：
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的漂亮一行。
只是一个替代方案，因为它看起来很不错 :) - 注意：亨克斯的回答是其中最快的。
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 秒
正则表达式 = 2.58 秒
new String (Henks( = 0.82 秒
我在Felipe Machado的CodeProject上找到了一篇很好的文章(在Richard Robertson的帮助下(
他测试了十种不同的方法。这是最快的安全版本...
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);
}
和最快的不安全版本...(日落探索 5/26/2021 的一些说明(
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';
}
}
Stian Standahl在Stack Overflow上也有一些不错的独立基准测试，也显示了Felipe的功能如何比下一个最快的函数快300%。另外，对于我修改的那个，我使用了这个技巧。
如果需要出色的性能，在这种情况下应避免使用 LINQ 和正则表达式。我做了一些性能基准测试，似乎如果你想从字符串的开头和结尾去除空格，字符串。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);
}
正则表达式是矫枉过正的;只需在字符串上使用扩展名(感谢 Henk(。这是微不足道的，应该是框架的一部分。无论如何，这是我的实现：
public static partial class Extension
{
public static string RemoveWhiteSpace(this string self)
{
return new string(self.Where(c => !Char.IsWhiteSpace(c)).ToArray());
}
}
我想很多人来这里是为了删除空格。
string s = "my string is nice";
s = s.replace(" ", "");
我需要用空格替换字符串中的空格，而不是重复的空格。 例如，我需要转换如下内容：
"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();
}
这是正则表达式解决方案的简单线性替代方案。我不确定哪个更快;你必须对它进行基准测试。
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();
}
我假设您的 XML 响应如下所示：
var xml = @"<names>
<name>
foo
</name>
<name>
bar
</name>
</names>";
方法是使用 XML 解析器，例如 LINQ to XML：
var doc = XDocument.Parse(xml);
var containsFoo = doc.Root
.Elements("name")
.Any(e => ((string)e).Trim() == "foo");
我们可以使用：
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());
}
这是另一个变体：
public static string RemoveAllWhitespace(string aString)
{
return String.Join(String.Empty, aString.Where(aChar => aChar !Char.IsWhiteSpace(aChar)));
}
与大多数其他解决方案一样，我还没有执行详尽的基准测试，但这足以满足我的目的。
从字符串中删除所有空格的直接方法，"example"是您的初始字符串。
String.Concat(example.Where(c => !Char.IsWhiteSpace(c))
我
发现不同的结果是正确的。我正在尝试用一个空格替换所有空格，并且正则表达式非常慢。
return( Regex::Replace( text, L"'s+", L" " ) );
对我来说最有效的(在 cli 中(C++是：
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 分钟后中止。
它可以说不像使用正则表达式或使用Char.IsWhiteSpace那样富有表现力，但以下是迄今为止最简洁的版本：
public static string RemoveWhitespace(this string input)
{
return string.Concat(input.Split(null));
}
这利用了 Split() 的Split(Char[])重载，它接受其唯一参数的null，并将该值解释为"在所有空格上拆分"(与使用空char数组或default(char[])的结果相同(。
在内部，它使用 Char.IsWhiteSpace 来确定是否应该在给定字符上拆分：
如果
separator参数null或不包含任何字符，则该方法将空格字符视为分隔符。空格字符由 Unicode 标准定义，如果将空格字符传递给它，则 Char.IsWhiteSpace 方法将返回true。