String.Split 方法

定义

返回的字符串数组包含此实例中的子字符串(由指定字符串或 Unicode 字符数组的元素分隔)。

重载

Split(Char, Int32, StringSplitOptions)

基于指定的分隔字符和(可选)选项将字符串拆分为最大数量的子字符串。 根据提供的字符分隔符将字符串拆分为最大数量的子字符串,可以选择忽略结果中的空子字符串。

Split(String[], Int32, StringSplitOptions)

基于指定的分隔字符串和(可选)选项将字符串拆分为最大数量的子字符串。

Split(Char[], Int32, StringSplitOptions)

基于指定的分隔字符和(可选)选项将字符串拆分为最大数量的子字符串。

Split(String[], StringSplitOptions)

基于指定的分隔字符串和(可选)选项将字符串拆分为子字符串。

Split(String, Int32, StringSplitOptions)

基于指定的分隔字符串和(可选)选项将字符串拆分为最大数量的子字符串。

Split(Char[], StringSplitOptions)

根据指定的分隔字符和选项将字符串拆分为子字符串。

Split(Char[], Int32)

根据指定的分隔字符将一个字符串拆分成最大数量的子字符串。

Split(Char, StringSplitOptions)

基于指定的分隔字符和(可选)选项将字符串拆分为子字符串。

Split(String, StringSplitOptions)

根据提供的字符串分隔符将字符串拆分为多个子字符串。

Split(Char[])

根据指定的分隔字符将字符串拆分为子字符串。

注解

Split 用于将分隔的字符串拆分为子字符串。 您可以使用字符数组或字符串数组来指定零个或多个分隔字符或字符串。 如果未指定任何分隔字符,则将字符串拆分为空白字符。

使用方法的重载 Split ,可以限制方法) (方法返回的子字符串的数量 Split(Char[], Int32) ,以指定是否在和方法) (的结果中包含空字符串和/或剪裁子字符串 Split(Char[], StringSplitOptions) Split(String[], StringSplitOptions) ,或者 () Split(Char[], Int32, StringSplitOptions)Split(String[], Int32, StringSplitOptions) 方法。

提示

Split方法并非总是将分隔的字符串拆分为子字符串的最佳方式。 如果您不希望提取分隔字符串的所有子字符串,或者您想要基于某个模式(而不是一组分隔符字符)分析字符串,请考虑使用正则表达式,或将使用方法返回字符索引的搜索方法之一组合起来 Substring 。 有关详细信息,请参阅 从字符串中提取子字符串。

示例

下面的示例显示了三种不同的 String.Split() 重载。 第一个示例调用 Split(Char[]) 重载,并传入单个分隔符。

string s = "You win some. You lose some.";

string[] subs = s.Split(' ');

foreach (var sub in subs)
{
    Console.WriteLine($"Substring: {sub}");
}

// This example produces the following output:
//
// Substring: You
// Substring: win
// Substring: some.
// Substring: You
// Substring: lose
// Substring: some.

正如你所看到的那样,两个子字符串之间包含句点字符 (.)。 如果要排除句点字符,可以将句点字符添加为额外的分隔符。 下面的示例演示了如何执行此操作。

string s = "You win some. You lose some.";

string[] subs = s.Split(' ', '.');

foreach (var sub in subs)
{
    Console.WriteLine($"Substring: {sub}");
}

// This example produces the following output:
//
// Substring: You
// Substring: win
// Substring: some
// Substring:
// Substring: You
// Substring: lose
// Substring: some
// Substring:

子字符串之间的句点消息,但现在包含了两个额外的空子字符串。 这些空子字符串表示单词与其后的句点之间的子字符串。 若要从生成的数组中删除空字符串,可以调用 Split(Char[], StringSplitOptions) 重载,并为 options 参数指定 StringSplitOptions.RemoveEmptyEntries

string s = "You win some. You lose some.";
char[] separators = new char[] { ' ', '.' };

string[] subs = s.Split(separators, StringSplitOptions.RemoveEmptyEntries);

foreach (var sub in subs)
{
    Console.WriteLine($"Substring: {sub}");
}

// This example produces the following output:
//
// Substring: You
// Substring: win
// Substring: some
// Substring: You
// Substring: lose
// Substring: some

各个重载的部分 String.Split() 包含进一步的示例。

Split(Char, Int32, StringSplitOptions)

基于指定的分隔字符和(可选)选项将字符串拆分为最大数量的子字符串。 根据提供的字符分隔符将字符串拆分为最大数量的子字符串,可以选择忽略结果中的空子字符串。

public string[] Split (char separator, int count, StringSplitOptions options = System.StringSplitOptions.None);
member this.Split : char * int * StringSplitOptions -> string[]
Public Function Split (separator As Char, count As Integer, Optional options As StringSplitOptions = System.StringSplitOptions.None) As String()

参数

separator
Char

一个字符,用于分隔此实例中的子字符串。

count
Int32

数组中预期的最大元素数。

options
StringSplitOptions

枚举值的按位组合,指定是否剪裁子字符串并包括空子字符串。

返回

String[]

一个数组,该数组包含此实例中的至多 count 个子字符串,这些子字符串由 separator 分隔。

注解

如果字符串已被拆分 - 1 次,但尚未到达字符串的末尾,则返回的数组中的最后一个字符串将包含此实例的剩余尾随子字符串, count 保持不变。

适用于

Split(String[], Int32, StringSplitOptions)

基于指定的分隔字符串和(可选)选项将字符串拆分为最大数量的子字符串。

public:
 cli::array <System::String ^> ^ Split(cli::array <System::String ^> ^ separator, int count, StringSplitOptions options);
public string[] Split (string[] separator, int count, StringSplitOptions options);
public string[] Split (string[]? separator, int count, StringSplitOptions options);
[System.Runtime.InteropServices.ComVisible(false)]
public string[] Split (string[] separator, int count, StringSplitOptions options);
member this.Split : string[] * int * StringSplitOptions -> string[]
[<System.Runtime.InteropServices.ComVisible(false)>]
member this.Split : string[] * int * StringSplitOptions -> string[]
Public Function Split (separator As String(), count As Integer, options As StringSplitOptions) As String()

参数

separator
String[]

分隔此字符串中子字符串的字符串、不包含分隔符的空数组或 null

count
Int32

要返回的子字符串的最大数量。

options
StringSplitOptions

枚举值的按位组合,用于指定是否剪裁子字符串并包含空子字符串。

返回

String[]

一个数组,其元素包含此字符串中的子字符串,这些子字符串由 separator 中的一个或多个字符串分隔。 有关详细信息,请参阅“备注”部分。

属性

例外

count 为负数。

options 不是 StringSplitOptions 值之一。

示例

下面的示例使用 StringSplitOptions 枚举来包括或排除方法生成的子字符串 Split

// This example demonstrates the String.Split(Char[], Boolean) and 
//                               String.Split(Char[], Int32, Boolean) methods
using namespace System;
void Show( array<String^>^entries )
{
   Console::WriteLine( "The return value contains these {0} elements:", entries->Length );
   System::Collections::IEnumerator^ myEnum = entries->GetEnumerator();
   while ( myEnum->MoveNext() )
   {
      String^ entry = safe_cast<String^>(myEnum->Current);
      Console::Write( "<{0}>", entry );
   }

   Console::Write( "{0}{0}", Environment::NewLine );
}

int main()
{
   String^ s = ",one,,,two,,,,,three,,";
   array<Char>^sep = gcnew array<Char>{
      ','
   };
   array<String^>^result;
   
   //
   Console::WriteLine( "The original string is \"{0}\".", s );
   Console::WriteLine( "The separation character is '{0}'.", sep[ 0 ] );
   Console::WriteLine();
   
   //
   Console::WriteLine( "Split the string and return all elements:" );
   result = s->Split( sep, StringSplitOptions::None );
   Show( result );
   
   //
   Console::WriteLine( "Split the string and return all non-empty elements:" );
   result = s->Split( sep, StringSplitOptions::RemoveEmptyEntries );
   Show( result );
   
   //
   Console::WriteLine( "Split the string and return 2 elements:" );
   result = s->Split( sep, 2, StringSplitOptions::None );
   Show( result );
   
   //
   Console::WriteLine( "Split the string and return 2 non-empty elements:" );
   result = s->Split( sep, 2, StringSplitOptions::RemoveEmptyEntries );
   Show( result );
}

/*
This example produces the following results:

The original string is ",one,,,two,,,,,three,,".
The separation character is ','.

Split the string and return all elements:
The return value contains these 12 elements:
<><one><><><two><><><><><three><><>

Split the string and return all non-empty elements:
The return value contains these 3 elements:
<one><two><three>

Split the string and return 2 elements:
The return value contains these 2 elements:
<><one,,,two,,,,,three,,>

Split the string and return 2 non-empty elements:
The return value contains these 2 elements:
<one><,,two,,,,,three,,>

*/
// This example demonstrates the String.Split() methods that use
// the StringSplitOptions enumeration.
string s1 = ",ONE,,TWO,,,THREE,,";
string s2 = "[stop]" +
            "ONE[stop][stop]" +
            "TWO[stop][stop][stop]" +
            "THREE[stop][stop]";
char[] charSeparators = new char[] { ',' };
string[] stringSeparators = new string[] { "[stop]" };
string[] result;
// ------------------------------------------------------------------------------
// Split a string delimited by characters.
// ------------------------------------------------------------------------------
Console.WriteLine("1) Split a string delimited by characters:\n");

// Display the original string and delimiter characters.
Console.WriteLine($"1a) The original string is \"{s1}\".");
Console.WriteLine($"The delimiter character is '{charSeparators[0]}'.\n");

// Split a string delimited by characters and return all elements.
Console.WriteLine("1b) Split a string delimited by characters and " +
                  "return all elements:");
result = s1.Split(charSeparators, StringSplitOptions.None);
Show(result);

// Split a string delimited by characters and return all non-empty elements.
Console.WriteLine("1c) Split a string delimited by characters and " +
                  "return all non-empty elements:");
result = s1.Split(charSeparators, StringSplitOptions.RemoveEmptyEntries);
Show(result);

// Split the original string into the string and empty string before the
// delimiter and the remainder of the original string after the delimiter.
Console.WriteLine("1d) Split a string delimited by characters and " +
                  "return 2 elements:");
result = s1.Split(charSeparators, 2, StringSplitOptions.None);
Show(result);

// Split the original string into the string after the delimiter and the
// remainder of the original string after the delimiter.
Console.WriteLine("1e) Split a string delimited by characters and " +
                  "return 2 non-empty elements:");
result = s1.Split(charSeparators, 2, StringSplitOptions.RemoveEmptyEntries);
Show(result);

// ------------------------------------------------------------------------------
// Split a string delimited by another string.
// ------------------------------------------------------------------------------
Console.WriteLine("2) Split a string delimited by another string:\n");

// Display the original string and delimiter string.
Console.WriteLine($"2a) The original string is \"{s2}\".");
Console.WriteLine($"The delimiter string is \"{stringSeparators[0]}\".\n");

// Split a string delimited by another string and return all elements.
Console.WriteLine("2b) Split a string delimited by another string and " +
                  "return all elements:");
result = s2.Split(stringSeparators, StringSplitOptions.None);
Show(result);

// Split the original string at the delimiter and return all non-empty elements.
Console.WriteLine("2c) Split a string delimited by another string and " +
                  "return all non-empty elements:");
result = s2.Split(stringSeparators, StringSplitOptions.RemoveEmptyEntries);
Show(result);

// Split the original string into the empty string before the
// delimiter and the remainder of the original string after the delimiter.
Console.WriteLine("2d) Split a string delimited by another string and " +
                  "return 2 elements:");
result = s2.Split(stringSeparators, 2, StringSplitOptions.None);
Show(result);

// Split the original string into the string after the delimiter and the
// remainder of the original string after the delimiter.
Console.WriteLine("2e) Split a string delimited by another string and " +
                  "return 2 non-empty elements:");
result = s2.Split(stringSeparators, 2, StringSplitOptions.RemoveEmptyEntries);
Show(result);

// Display the array of separated strings using a local function
void Show(string[] entries)
{
    Console.WriteLine($"The return value contains these {entries.Length} elements:");
    foreach (string entry in entries)
    {
        Console.Write($"<{entry}>");
    }
    Console.Write("\n\n");
}

/*
This example produces the following results:

1) Split a string delimited by characters:

1a) The original string is ",ONE,,TWO,,,THREE,,".
The delimiter character is ','.

1b) Split a string delimited by characters and return all elements:
The return value contains these 9 elements:
<><ONE><><TWO><><><THREE><><>

1c) Split a string delimited by characters and return all non-empty elements:
The return value contains these 3 elements:
<ONE><TWO><THREE>

1d) Split a string delimited by characters and return 2 elements:
The return value contains these 2 elements:
<><ONE,,TWO,,,THREE,,>

1e) Split a string delimited by characters and return 2 non-empty elements:
The return value contains these 2 elements:
<ONE><TWO,,,THREE,,>

2) Split a string delimited by another string:

2a) The original string is "[stop]ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]".
The delimiter string is "[stop]".

2b) Split a string delimited by another string and return all elements:
The return value contains these 9 elements:
<><ONE><><TWO><><><THREE><><>

2c) Split a string delimited by another string and return all non-empty elements:
The return value contains these 3 elements:
<ONE><TWO><THREE>

2d) Split a string delimited by another string and return 2 elements:
The return value contains these 2 elements:
<><ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]>

2e) Split a string delimited by another string and return 2 non-empty elements:
The return value contains these 2 elements:
<ONE><TWO[stop][stop][stop]THREE[stop][stop]>

*/

注解

分隔符字符串不包含在返回数组的元素中。

如果此实例不包含中的任何字符串 separator ,或者 count 参数为1,则返回的数组由包含此实例的单个元素组成。

如果 separator 参数为 null 或不包含任何字符,则假定空格字符为分隔符。 空白字符由 Unicode 标准定义, Char.IsWhiteSpace true 如果传递给它,则方法将返回。

若要 nullstring[] separator 参数传递,必须指示的类型, null 以消除其他一些重载(如)的调用 Split(Char[], Int32, StringSplitOptions) 。 下面的示例演示了几种明确识别此重载的方式。

string phrase = "The quick  brown fox";

_ = phrase.Split(default(string[]), 3, StringSplitOptions.RemoveEmptyEntries);

_ = phrase.Split((string[])null, 3, StringSplitOptions.RemoveEmptyEntries);

_ = phrase.Split(null as string[], 3, StringSplitOptions.RemoveEmptyEntries);

如果 count 参数为零,或者 options 参数为 RemoveEmptyEntries ,并且此实例的长度为零,则返回空数组。

的每个元素都 separator 定义一个由一个或多个字符组成的单独分隔符。 如果 options 参数为 None ,并且两个分隔符相邻,或在此实例的开头或结尾找到了分隔符,则对应的数组元素包含 Empty

如果 count 此实例中的子字符串多于个子字符串,则返回 count 值的第一个减1元素返回第一个减号子字符串 count ,并且在返回值的最后一个元素中返回此实例中剩余的字符。

如果 count 大于子字符串的数目,则将返回可用的子字符串,并且不会引发异常。

分隔符数组

如果中的任何元素 separator 包含多个字符,则整个子字符串被视为分隔符。 例如,如果中的一个元素 separator 为 "10",则尝试拆分字符串 "This10is10a10string"。 返回这四元素数组: {"This"、"is"、"a"、"string"。 }.

比较详细信息

Split方法提取此字符串中的子字符串,这些子字符串由参数中的一个或多个字符串分隔 separator ,并将这些子字符串作为数组的元素返回。

Split方法通过使用区分大小写的序号排序规则执行比较来查找分隔符。 有关 word、字符串和序号排序的详细信息,请参阅 System.Globalization.CompareOptions 枚举。

Split方法将忽略 separator 其值为 null 或空字符串 ( "" ) 的任何元素。

若要避免在中的字符串具有相同的字符时出现不明确 separator 的结果,该 Split 方法将从实例值的开头开始,并与中的第一个元素( separator 该元素等于实例中的分隔符)匹配。 实例中的子字符串的出现顺序优先于中元素的顺序 separator

例如,假设值为 "abcdef" 的实例。 如果中的第一个元素 separator 为 "ef",第二个元素为 "bcde",则拆分操作的结果为 "a" 和 "f"。 这是因为,在遇到子字符串 "f" 之前,遇到了实例 "bcde" 中的子字符串,并与中的元素匹配 separator

但是,如果的第一个元素 separator 为 "bcd",第二个元素为 "bc",则拆分操作的结果为 "a" 和 "ef"。 这是因为 "bcd" 是中的第一个分隔符 separator ,它与实例中的分隔符相匹配。 如果分隔符的顺序已颠倒,因此第一个元素为 "bc",第二个元素为 "bcd",则结果为 "a" 和 "def"。

性能注意事项

Split方法为返回的数组对象分配内存,并为 String 每个数组元素分配一个对象。 如果你的应用程序需要最佳性能,或者在你的应用程序中管理内存分配非常重要,请考虑使用 IndexOfIndexOfAny 方法,并根据需要使用 Compare 方法来查找字符串中的子字符串。

如果要在分隔符处拆分字符串,请使用 IndexOfIndexOfAny 方法来查找字符串中的分隔符。 如果要将字符串拆分为分隔符字符串,请使用 IndexOfIndexOfAny 方法查找分隔符字符串的第一个字符。 然后,使用 Compare 方法来确定第一个字符后面的字符是否等于分隔符字符串的剩余字符。

此外,如果使用相同的字符集拆分多个方法调用中的字符串 Split ,请考虑创建一个数组,并在每个方法调用中引用它。 这可以显著降低每个方法调用的额外开销。

调用方说明

在 .NET Framework 3.5 及更早版本中,如果向 Split(Char[]) 方法传递的 separatornull 或不包含任何字符,则该方法将使用一组略有不同的空白字符来拆分字符串,而不是使用 Trim(Char[]) 方法来剪裁字符串。 从 .NET Framework 4 开始,这两个方法都使用一组相同的 Unicode 空白字符。

适用于

Split(Char[], Int32, StringSplitOptions)

基于指定的分隔字符和(可选)选项将字符串拆分为最大数量的子字符串。

public:
 cli::array <System::String ^> ^ Split(cli::array <char> ^ separator, int count, StringSplitOptions options);
public string[] Split (char[] separator, int count, StringSplitOptions options);
public string[] Split (char[]? separator, int count, StringSplitOptions options);
[System.Runtime.InteropServices.ComVisible(false)]
public string[] Split (char[] separator, int count, StringSplitOptions options);
member this.Split : char[] * int * StringSplitOptions -> string[]
[<System.Runtime.InteropServices.ComVisible(false)>]
member this.Split : char[] * int * StringSplitOptions -> string[]
Public Function Split (separator As Char(), count As Integer, options As StringSplitOptions) As String()

参数

separator
Char[]

分隔此字符串中子字符串的字符数组、不包含分隔符的空数组或 null

count
Int32

要返回的子字符串的最大数量。

options
StringSplitOptions

枚举值的按位组合,指定是否剪裁子字符串并包括空子字符串。

返回

String[]

一个数组,该数组包含此字符串中的子字符串,这些子字符串由 separator 中的一个或多个字符分隔。 有关详细信息,请参阅“备注”部分。

属性

例外

count 为负数。

options 不是 StringSplitOptions 值之一。

示例

下面的示例使用 StringSplitOptions 枚举来包括或排除方法生成的子字符串 Split

// This example demonstrates the String.Split(Char[], Boolean) and 
//                               String.Split(Char[], Int32, Boolean) methods
using namespace System;
void Show( array<String^>^entries )
{
   Console::WriteLine( "The return value contains these {0} elements:", entries->Length );
   System::Collections::IEnumerator^ myEnum = entries->GetEnumerator();
   while ( myEnum->MoveNext() )
   {
      String^ entry = safe_cast<String^>(myEnum->Current);
      Console::Write( "<{0}>", entry );
   }

   Console::Write( "{0}{0}", Environment::NewLine );
}

int main()
{
   String^ s = ",one,,,two,,,,,three,,";
   array<Char>^sep = gcnew array<Char>{
      ','
   };
   array<String^>^result;
   
   //
   Console::WriteLine( "The original string is \"{0}\".", s );
   Console::WriteLine( "The separation character is '{0}'.", sep[ 0 ] );
   Console::WriteLine();
   
   //
   Console::WriteLine( "Split the string and return all elements:" );
   result = s->Split( sep, StringSplitOptions::None );
   Show( result );
   
   //
   Console::WriteLine( "Split the string and return all non-empty elements:" );
   result = s->Split( sep, StringSplitOptions::RemoveEmptyEntries );
   Show( result );
   
   //
   Console::WriteLine( "Split the string and return 2 elements:" );
   result = s->Split( sep, 2, StringSplitOptions::None );
   Show( result );
   
   //
   Console::WriteLine( "Split the string and return 2 non-empty elements:" );
   result = s->Split( sep, 2, StringSplitOptions::RemoveEmptyEntries );
   Show( result );
}

/*
This example produces the following results:

The original string is ",one,,,two,,,,,three,,".
The separation character is ','.

Split the string and return all elements:
The return value contains these 12 elements:
<><one><><><two><><><><><three><><>

Split the string and return all non-empty elements:
The return value contains these 3 elements:
<one><two><three>

Split the string and return 2 elements:
The return value contains these 2 elements:
<><one,,,two,,,,,three,,>

Split the string and return 2 non-empty elements:
The return value contains these 2 elements:
<one><,,two,,,,,three,,>

*/
// This example demonstrates the String.Split() methods that use
// the StringSplitOptions enumeration.
string s1 = ",ONE,,TWO,,,THREE,,";
string s2 = "[stop]" +
            "ONE[stop][stop]" +
            "TWO[stop][stop][stop]" +
            "THREE[stop][stop]";
char[] charSeparators = new char[] { ',' };
string[] stringSeparators = new string[] { "[stop]" };
string[] result;
// ------------------------------------------------------------------------------
// Split a string delimited by characters.
// ------------------------------------------------------------------------------
Console.WriteLine("1) Split a string delimited by characters:\n");

// Display the original string and delimiter characters.
Console.WriteLine($"1a) The original string is \"{s1}\".");
Console.WriteLine($"The delimiter character is '{charSeparators[0]}'.\n");

// Split a string delimited by characters and return all elements.
Console.WriteLine("1b) Split a string delimited by characters and " +
                  "return all elements:");
result = s1.Split(charSeparators, StringSplitOptions.None);
Show(result);

// Split a string delimited by characters and return all non-empty elements.
Console.WriteLine("1c) Split a string delimited by characters and " +
                  "return all non-empty elements:");
result = s1.Split(charSeparators, StringSplitOptions.RemoveEmptyEntries);
Show(result);

// Split the original string into the string and empty string before the
// delimiter and the remainder of the original string after the delimiter.
Console.WriteLine("1d) Split a string delimited by characters and " +
                  "return 2 elements:");
result = s1.Split(charSeparators, 2, StringSplitOptions.None);
Show(result);

// Split the original string into the string after the delimiter and the
// remainder of the original string after the delimiter.
Console.WriteLine("1e) Split a string delimited by characters and " +
                  "return 2 non-empty elements:");
result = s1.Split(charSeparators, 2, StringSplitOptions.RemoveEmptyEntries);
Show(result);

// ------------------------------------------------------------------------------
// Split a string delimited by another string.
// ------------------------------------------------------------------------------
Console.WriteLine("2) Split a string delimited by another string:\n");

// Display the original string and delimiter string.
Console.WriteLine($"2a) The original string is \"{s2}\".");
Console.WriteLine($"The delimiter string is \"{stringSeparators[0]}\".\n");

// Split a string delimited by another string and return all elements.
Console.WriteLine("2b) Split a string delimited by another string and " +
                  "return all elements:");
result = s2.Split(stringSeparators, StringSplitOptions.None);
Show(result);

// Split the original string at the delimiter and return all non-empty elements.
Console.WriteLine("2c) Split a string delimited by another string and " +
                  "return all non-empty elements:");
result = s2.Split(stringSeparators, StringSplitOptions.RemoveEmptyEntries);
Show(result);

// Split the original string into the empty string before the
// delimiter and the remainder of the original string after the delimiter.
Console.WriteLine("2d) Split a string delimited by another string and " +
                  "return 2 elements:");
result = s2.Split(stringSeparators, 2, StringSplitOptions.None);
Show(result);

// Split the original string into the string after the delimiter and the
// remainder of the original string after the delimiter.
Console.WriteLine("2e) Split a string delimited by another string and " +
                  "return 2 non-empty elements:");
result = s2.Split(stringSeparators, 2, StringSplitOptions.RemoveEmptyEntries);
Show(result);

// Display the array of separated strings using a local function
void Show(string[] entries)
{
    Console.WriteLine($"The return value contains these {entries.Length} elements:");
    foreach (string entry in entries)
    {
        Console.Write($"<{entry}>");
    }
    Console.Write("\n\n");
}

/*
This example produces the following results:

1) Split a string delimited by characters:

1a) The original string is ",ONE,,TWO,,,THREE,,".
The delimiter character is ','.

1b) Split a string delimited by characters and return all elements:
The return value contains these 9 elements:
<><ONE><><TWO><><><THREE><><>

1c) Split a string delimited by characters and return all non-empty elements:
The return value contains these 3 elements:
<ONE><TWO><THREE>

1d) Split a string delimited by characters and return 2 elements:
The return value contains these 2 elements:
<><ONE,,TWO,,,THREE,,>

1e) Split a string delimited by characters and return 2 non-empty elements:
The return value contains these 2 elements:
<ONE><TWO,,,THREE,,>

2) Split a string delimited by another string:

2a) The original string is "[stop]ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]".
The delimiter string is "[stop]".

2b) Split a string delimited by another string and return all elements:
The return value contains these 9 elements:
<><ONE><><TWO><><><THREE><><>

2c) Split a string delimited by another string and return all non-empty elements:
The return value contains these 3 elements:
<ONE><TWO><THREE>

2d) Split a string delimited by another string and return 2 elements:
The return value contains these 2 elements:
<><ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]>

2e) Split a string delimited by another string and return 2 non-empty elements:
The return value contains these 2 elements:
<ONE><TWO[stop][stop][stop]THREE[stop][stop]>

*/

注解

分隔符字符不包括在返回的数组的元素中。

如果此实例不包含 中的任何字符,或者 参数为 1,则返回的数组由包含此实例 separator count 的单个元素组成。

如果 separator 参数为 null 或不包含任何字符,则假定空白字符为分隔符。 空白字符由 Unicode 标准定义,如果传递给空格字符,则方法 Char.IsWhiteSpace true 返回 。

若要为 参数传递 ,必须指示 的类型,以将调用与一些其他重载(如 ) null char[] separator null 解除联系 Split(String[], Int32, StringSplitOptions) 。 下面的示例演示了明确标识此重载的多种方式。

string phrase = "The quick  brown fox";

_ = phrase.Split(default(char[]), 3, StringSplitOptions.RemoveEmptyEntries);

_ = phrase.Split((char[])null, 3, StringSplitOptions.RemoveEmptyEntries);

_ = phrase.Split(null as char[], 3, StringSplitOptions.RemoveEmptyEntries);

如果 count 参数为零,或 参数为 且此实例的长度为 options RemoveEmptyEntries 零,则返回空数组。

的每个 元素 separator 定义一个单独的分隔符字符。 如果 参数为 ,并且两个分隔符相邻,或者在此实例的开头或末尾找到分隔符,则 options None 相应的数组元素包含 Empty

如果 count 此实例中的子字符串多于个子字符串,则返回 count 值的第一个减1元素返回第一个减号子字符串 count ,并且在返回值的最后一个元素中返回此实例中剩余的字符。

如果 count 大于子字符串的数目,则将返回可用的子字符串,并且不会引发异常。

性能注意事项

Split方法为返回的数组对象分配内存,并为 String 每个数组元素分配一个对象。 如果你的应用程序需要最佳性能,或者在你的应用程序中管理内存分配非常重要,请考虑使用 IndexOfIndexOfAny 方法,并根据需要使用 Compare 方法来查找字符串中的子字符串。

如果要在分隔符处拆分字符串,请使用 IndexOfIndexOfAny 方法来查找字符串中的分隔符。 如果要将字符串拆分为分隔符字符串,请使用 IndexOfIndexOfAny 方法查找分隔符字符串的第一个字符。 然后,使用 Compare 方法来确定第一个字符后面的字符是否等于分隔符字符串的剩余字符。

此外,如果使用相同的字符集拆分多个方法调用中的字符串 Split ,请考虑创建一个数组,并在每个方法调用中引用它。 这可以显著降低每个方法调用的额外开销。

调用方说明

在 .NET Framework 3.5 及更早版本中,如果向 Split(Char[]) 方法传递的 separatornull 或不包含任何字符,则该方法将使用一组略有不同的空白字符来拆分字符串,而不是使用 Trim(Char[]) 方法来剪裁字符串。 从 .NET Framework 4 开始,这两个方法都使用一组相同的 Unicode 空白字符。

适用于

Split(String[], StringSplitOptions)

基于指定的分隔字符串和(可选)选项将字符串拆分为子字符串。

public:
 cli::array <System::String ^> ^ Split(cli::array <System::String ^> ^ separator, StringSplitOptions options);
public string[] Split (string[] separator, StringSplitOptions options);
public string[] Split (string[]? separator, StringSplitOptions options);
[System.Runtime.InteropServices.ComVisible(false)]
public string[] Split (string[] separator, StringSplitOptions options);
member this.Split : string[] * StringSplitOptions -> string[]
[<System.Runtime.InteropServices.ComVisible(false)>]
member this.Split : string[] * StringSplitOptions -> string[]
Public Function Split (separator As String(), options As StringSplitOptions) As String()

参数

separator
String[]

分隔此字符串中子字符串的字符串数组、不包含分隔符的空数组或 null

options
StringSplitOptions

枚举值的按位组合,指定是否剪裁子字符串并包括空子字符串。

返回

String[]

一个数组,其元素包含此字符串中的子字符串,这些子字符串由 separator 中的一个或多个字符串分隔。 有关详细信息,请参阅“备注”部分。

属性

例外

options 不是 StringSplitOptions 值之一。

示例

下面的示例演示了通过调用字符串的 方法(其参数等于 和 )返回的 String.Split(String[], StringSplitOptions) options 数组 StringSplitOptions.None 中的差异 StringSplitOptions.RemoveEmptyEntries

string source = "[stop]ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]";
string[] stringSeparators = new string[] { "[stop]" };
string[] result;

// Display the original string and delimiter string.
Console.WriteLine($"Splitting the string:\n   \"{source}\".");
Console.WriteLine();
Console.WriteLine($"Using the delimiter string:\n   \"{stringSeparators[0]}\"");
Console.WriteLine();

// Split a string delimited by another string and return all elements.
result = source.Split(stringSeparators, StringSplitOptions.None);
Console.WriteLine($"Result including all elements ({result.Length} elements):");
Console.Write("   ");
foreach (string s in result)
{
    Console.Write("'{0}' ", String.IsNullOrEmpty(s) ? "<>" : s);
}
Console.WriteLine();
Console.WriteLine();

// Split delimited by another string and return all non-empty elements.
result = source.Split(stringSeparators, StringSplitOptions.RemoveEmptyEntries);
Console.WriteLine($"Result including non-empty elements ({result.Length} elements):");
Console.Write("   ");
foreach (string s in result)
{
    Console.Write("'{0}' ", String.IsNullOrEmpty(s) ? "<>" : s);
}
Console.WriteLine();

// The example displays the following output:
//    Splitting the string:
//       "[stop]ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]".
//    
//    Using the delimiter string:
//       "[stop]"
//    
//    Result including all elements (9 elements):
//       '<>' 'ONE' '<>' 'TWO' '<>' '<>' 'THREE' '<>' '<>'
//    
//    Result including non-empty elements (3 elements):
//       'ONE' 'TWO' 'THREE'

下面的示例定义一个分隔符数组,其中包括标点和空白字符。 将此数组与 的值一起传递给 方法将返回 StringSplitOptions.RemoveEmptyEntries Split(String[], StringSplitOptions) 一个数组,该数组由字符串中的单个单词组成。

string[] separators = { ",", ".", "!", "?", ";", ":", " " };
string value = "The handsome, energetic, young dog was playing with his smaller, more lethargic litter mate.";
string[] words = value.Split(separators, StringSplitOptions.RemoveEmptyEntries);
foreach (var word in words)
    Console.WriteLine(word);

// The example displays the following output:
//       The
//       handsome
//       energetic
//       young
//       dog
//       was
//       playing
//       with
//       his
//       smaller
//       more
//       lethargic
//       litter
//       mate

请注意,调用 方法时参数 options 设置为 StringSplitOptions.RemoveEmptyEntries 。 这可以防止返回的数组包含表示标点符号和空白字符之间的空子字符串 String.Empty 匹配项的值。

注解

当字符串由一组已知的字符串分隔时,可以使用 方法将字符串 Split 分隔成子字符串。

分隔符字符串不包含在返回数组的元素中。 例如,如果数组包含字符串"--",并且当前字符串实例的值为 separator "aa--bb--cc",该方法将返回包含三个元素的数组:"aa"、"bb"和"cc"。

如果此实例不包含 中的任何字符串,则返回 separator 的数组由包含此实例的单个元素组成。

如果 options 参数为 RemoveEmptyEntries 且此实例的长度为零,则方法返回空数组。

的每个 separator 元素都定义了一个单独的分隔符,该分隔符由一个或多个字符组成。 如果 参数为 ,并且两个分隔符相邻,或者在此实例的开头或末尾找到分隔符,则相应的 options None 数组元素包含 String.Empty 。 例如,如果 包含两个元素 separator "-"和"",则字符串实例的值为 _ "- _ aa-",并且参数的值为 ,则 方法返回具有以下五个元素 _ options 的字符串 None 数组:

  1. String.Empty,表示索引 0 中"-"子字符串之前空字符串。

  2. String.Empty,表示索引 0 的"-"子字符串与索引 1 中的"_"子字符串之间的空字符串。

  3. "aa"。

  4. String.Empty,表示索引 4 中"-"子字符串后跟的空字符串。

  5. String.Empty,表示索引 5 中"_"子字符串后跟的空字符串。

分隔符数组

如果 中的任意元素 separator 包含多个字符,则整个子字符串被视为分隔符。 例如,如果 中的一个元素为 separator "10",则尝试拆分字符串"This10is10a10string"。 返回以下四元素数组:{ "This", "is", "a", "string"。 }.

如果 separator 参数为 null 或不包含非空字符串,则假定空白字符为分隔符。 空白字符由 Unicode 标准定义,如果传递给空格字符,则方法 Char.IsWhiteSpace true 返回 。

若要为 参数传递 ,必须指示 的类型,以将调用与一些其他重载(如 ) null string[] separator null 解除联系 Split(Char[], StringSplitOptions) 。 下面的示例演示了明确标识此重载的多种方式。

string phrase = "The quick  brown fox";

_ = phrase.Split(default(string[]), StringSplitOptions.RemoveEmptyEntries);

_ = phrase.Split((string[])null, StringSplitOptions.RemoveEmptyEntries);

_ = phrase.Split(null as string[], StringSplitOptions.RemoveEmptyEntries);

比较详细信息

方法提取此字符串中由 参数中的一个或多个字符串分隔的子字符串,并返回这些子 Split separator 字符串作为数组的元素。

Split方法通过使用区分大小写的序号排序规则执行比较来查找分隔符。 有关单词、字符串和序号排序详细信息,请参阅 System.Globalization.CompareOptions 枚举。

方法 Split 将忽略其值为 或空字符串为 separator null " (") 。

为了避免当 中的字符串具有公共字符时出现不明确的结果,操作从 实例值的开头到末尾继续,并匹配 中等于 实例中的分隔符的第一 separator Split separator 个元素。 实例中遇到子字符串的顺序优先于 中的元素顺序 separator

例如,考虑值为"abcdef"的实例。 如果 中的第一个元素为"ef",第二个元素为"bcde",则拆分操作的结果将是包含两个元素 separator ("a"和"f")的字符串数组。 这是因为在遇到子字符串"f"之前,遇到 实例中的子字符串"bcde",并匹配 separator 中的元素。

但是,如果 的第一个元素为"bcd",第二个元素为"bc",则拆分操作的结果是包含两个元素 separator ("a"和"ef")的字符串数组。 这是因为"bcd"是 中与 实例中的分隔符 separator 匹配的第一个分隔符。 如果分隔符的顺序相反,因此第一个元素为"bc",第二个元素为"bcd",则结果将是包含两个元素("a"和"def")的字符串数组。

性能注意事项

方法 Split 为返回的数组对象和每个 String 数组元素的 对象分配内存。 如果应用程序需要最佳性能,或者管理内存分配在应用程序中至关重要,请考虑使用 或 方法(可选)在字符串中 IndexOf IndexOfAny Compare 查找子字符串。

如果要在分隔符处拆分字符串,请使用 IndexOfIndexOfAny 方法在字符串中查找分隔符。 如果要在分隔符字符串处拆分字符串,请使用 或 方法查找分隔符 IndexOf IndexOfAny 字符串的第一个字符。 然后使用 方法确定第一个字符之后 Compare 的字符是否等于分隔符字符串的剩余字符。

此外,如果使用同一组字符在多个方法调用中拆分字符串,请考虑创建单个数组,并在每个方法调用 Split 中引用它。 这大大减少了每个方法调用的额外开销。

调用方说明

在 .NET Framework 3.5 及更早版本中,如果向方法传递了一个为 或不包含任何字符的 ,则该方法使用一组略有不同的空白字符来拆分字符串,而方法则使用来剪裁字符串。 Split(Char[]) separator null Trim(Char[]) 从 .NET Framework 4 开始,这两种方法都使用一组相同的 Unicode 空白字符。

适用于

Split(String, Int32, StringSplitOptions)

基于指定的分隔字符串和(可选)选项将字符串拆分为最大数量的子字符串。

public string[] Split (string? separator, int count, StringSplitOptions options = System.StringSplitOptions.None);
public string[] Split (string separator, int count, StringSplitOptions options = System.StringSplitOptions.None);
member this.Split : string * int * StringSplitOptions -> string[]
Public Function Split (separator As String, count As Integer, Optional options As StringSplitOptions = System.StringSplitOptions.None) As String()

参数

separator
String

一个字符串,用于分隔此实例中的子字符串。

count
Int32

数组中预期的最大元素数。

options
StringSplitOptions

枚举值的按位组合,用于指定是否剪裁子字符串并包含空子字符串。

返回

String[]

一个数组,该数组包含此实例中的至多 count 个子字符串,这些子字符串由 separator 分隔。

注解

如果该字符串已拆分 count 为1次,但尚未到达字符串的末尾,则返回的数组中的最后一个字符串将包含此实例的其余尾随子字符串(不变)。

适用于

Split(Char[], StringSplitOptions)

根据指定的分隔字符和选项将字符串拆分为子字符串。

public:
 cli::array <System::String ^> ^ Split(cli::array <char> ^ separator, StringSplitOptions options);
public string[] Split (char[] separator, StringSplitOptions options);
public string[] Split (char[]? separator, StringSplitOptions options);
[System.Runtime.InteropServices.ComVisible(false)]
public string[] Split (char[] separator, StringSplitOptions options);
member this.Split : char[] * StringSplitOptions -> string[]
[<System.Runtime.InteropServices.ComVisible(false)>]
member this.Split : char[] * StringSplitOptions -> string[]
Public Function Split (separator As Char(), options As StringSplitOptions) As String()

参数

separator
Char[]

分隔此字符串中子字符串的字符数组、不包含分隔符的空数组或 null

options
StringSplitOptions

枚举值的按位组合,用于指定是否剪裁子字符串并包含空子字符串。

返回

String[]

一个数组,其元素包含此字符串中的子字符串,这些子字符串由 separator 中的一个或多个字符分隔。 有关详细信息,请参阅“备注”部分。

属性

例外

options 不是 StringSplitOptions 值之一。

示例

下面的示例使用 StringSplitOptions 枚举来包括或排除 方法生成的子 Split 字符串。

// This example demonstrates the String.Split(Char[], Boolean) and 
//                               String.Split(Char[], Int32, Boolean) methods
using namespace System;
void Show( array<String^>^entries )
{
   Console::WriteLine( "The return value contains these {0} elements:", entries->Length );
   System::Collections::IEnumerator^ myEnum = entries->GetEnumerator();
   while ( myEnum->MoveNext() )
   {
      String^ entry = safe_cast<String^>(myEnum->Current);
      Console::Write( "<{0}>", entry );
   }

   Console::Write( "{0}{0}", Environment::NewLine );
}

int main()
{
   String^ s = ",one,,,two,,,,,three,,";
   array<Char>^sep = gcnew array<Char>{
      ','
   };
   array<String^>^result;
   
   //
   Console::WriteLine( "The original string is \"{0}\".", s );
   Console::WriteLine( "The separation character is '{0}'.", sep[ 0 ] );
   Console::WriteLine();
   
   //
   Console::WriteLine( "Split the string and return all elements:" );
   result = s->Split( sep, StringSplitOptions::None );
   Show( result );
   
   //
   Console::WriteLine( "Split the string and return all non-empty elements:" );
   result = s->Split( sep, StringSplitOptions::RemoveEmptyEntries );
   Show( result );
   
   //
   Console::WriteLine( "Split the string and return 2 elements:" );
   result = s->Split( sep, 2, StringSplitOptions::None );
   Show( result );
   
   //
   Console::WriteLine( "Split the string and return 2 non-empty elements:" );
   result = s->Split( sep, 2, StringSplitOptions::RemoveEmptyEntries );
   Show( result );
}

/*
This example produces the following results:

The original string is ",one,,,two,,,,,three,,".
The separation character is ','.

Split the string and return all elements:
The return value contains these 12 elements:
<><one><><><two><><><><><three><><>

Split the string and return all non-empty elements:
The return value contains these 3 elements:
<one><two><three>

Split the string and return 2 elements:
The return value contains these 2 elements:
<><one,,,two,,,,,three,,>

Split the string and return 2 non-empty elements:
The return value contains these 2 elements:
<one><,,two,,,,,three,,>

*/
// This example demonstrates the String.Split() methods that use
// the StringSplitOptions enumeration.
string s1 = ",ONE,,TWO,,,THREE,,";
string s2 = "[stop]" +
            "ONE[stop][stop]" +
            "TWO[stop][stop][stop]" +
            "THREE[stop][stop]";
char[] charSeparators = new char[] { ',' };
string[] stringSeparators = new string[] { "[stop]" };
string[] result;
// ------------------------------------------------------------------------------
// Split a string delimited by characters.
// ------------------------------------------------------------------------------
Console.WriteLine("1) Split a string delimited by characters:\n");

// Display the original string and delimiter characters.
Console.WriteLine($"1a) The original string is \"{s1}\".");
Console.WriteLine($"The delimiter character is '{charSeparators[0]}'.\n");

// Split a string delimited by characters and return all elements.
Console.WriteLine("1b) Split a string delimited by characters and " +
                  "return all elements:");
result = s1.Split(charSeparators, StringSplitOptions.None);
Show(result);

// Split a string delimited by characters and return all non-empty elements.
Console.WriteLine("1c) Split a string delimited by characters and " +
                  "return all non-empty elements:");
result = s1.Split(charSeparators, StringSplitOptions.RemoveEmptyEntries);
Show(result);

// Split the original string into the string and empty string before the
// delimiter and the remainder of the original string after the delimiter.
Console.WriteLine("1d) Split a string delimited by characters and " +
                  "return 2 elements:");
result = s1.Split(charSeparators, 2, StringSplitOptions.None);
Show(result);

// Split the original string into the string after the delimiter and the
// remainder of the original string after the delimiter.
Console.WriteLine("1e) Split a string delimited by characters and " +
                  "return 2 non-empty elements:");
result = s1.Split(charSeparators, 2, StringSplitOptions.RemoveEmptyEntries);
Show(result);

// ------------------------------------------------------------------------------
// Split a string delimited by another string.
// ------------------------------------------------------------------------------
Console.WriteLine("2) Split a string delimited by another string:\n");

// Display the original string and delimiter string.
Console.WriteLine($"2a) The original string is \"{s2}\".");
Console.WriteLine($"The delimiter string is \"{stringSeparators[0]}\".\n");

// Split a string delimited by another string and return all elements.
Console.WriteLine("2b) Split a string delimited by another string and " +
                  "return all elements:");
result = s2.Split(stringSeparators, StringSplitOptions.None);
Show(result);

// Split the original string at the delimiter and return all non-empty elements.
Console.WriteLine("2c) Split a string delimited by another string and " +
                  "return all non-empty elements:");
result = s2.Split(stringSeparators, StringSplitOptions.RemoveEmptyEntries);
Show(result);

// Split the original string into the empty string before the
// delimiter and the remainder of the original string after the delimiter.
Console.WriteLine("2d) Split a string delimited by another string and " +
                  "return 2 elements:");
result = s2.Split(stringSeparators, 2, StringSplitOptions.None);
Show(result);

// Split the original string into the string after the delimiter and the
// remainder of the original string after the delimiter.
Console.WriteLine("2e) Split a string delimited by another string and " +
                  "return 2 non-empty elements:");
result = s2.Split(stringSeparators, 2, StringSplitOptions.RemoveEmptyEntries);
Show(result);

// Display the array of separated strings using a local function
void Show(string[] entries)
{
    Console.WriteLine($"The return value contains these {entries.Length} elements:");
    foreach (string entry in entries)
    {
        Console.Write($"<{entry}>");
    }
    Console.Write("\n\n");
}

/*
This example produces the following results:

1) Split a string delimited by characters:

1a) The original string is ",ONE,,TWO,,,THREE,,".
The delimiter character is ','.

1b) Split a string delimited by characters and return all elements:
The return value contains these 9 elements:
<><ONE><><TWO><><><THREE><><>

1c) Split a string delimited by characters and return all non-empty elements:
The return value contains these 3 elements:
<ONE><TWO><THREE>

1d) Split a string delimited by characters and return 2 elements:
The return value contains these 2 elements:
<><ONE,,TWO,,,THREE,,>

1e) Split a string delimited by characters and return 2 non-empty elements:
The return value contains these 2 elements:
<ONE><TWO,,,THREE,,>

2) Split a string delimited by another string:

2a) The original string is "[stop]ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]".
The delimiter string is "[stop]".

2b) Split a string delimited by another string and return all elements:
The return value contains these 9 elements:
<><ONE><><TWO><><><THREE><><>

2c) Split a string delimited by another string and return all non-empty elements:
The return value contains these 3 elements:
<ONE><TWO><THREE>

2d) Split a string delimited by another string and return 2 elements:
The return value contains these 2 elements:
<><ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]>

2e) Split a string delimited by another string and return 2 non-empty elements:
The return value contains these 2 elements:
<ONE><TWO[stop][stop][stop]THREE[stop][stop]>

*/

注解

分隔符字符 (数组中的字符 separator) 不包含在返回数组的元素中。 例如,如果 separator 数组包含字符 "-",而当前字符串实例的值为 "aa-bb-cc",则该方法将返回包含三个元素的数组: "aa"、"bb" 和 "cc"。

如果此实例不包含中的任何字符 separator ,则返回的数组由包含此实例的单个元素组成。

如果 options 参数为 RemoveEmptyEntries ,并且此实例的长度为零,则该方法将返回一个空数组。

的每个元素都 separator 定义一个由单个字符组成的单独分隔符。 如果 options 参数为 None ,并且两个分隔符相邻,或在此实例的开头或结尾找到了分隔符,则对应的数组元素包含 String.Empty 。 例如,如果 separator 包含两个元素, '-' 并且 '_' 字符串实例的值为 "- _ aa- _ ",并且参数的值 optionsNone ,则该方法将返回一个字符串数组,其中包含以下五个元素:

  1. String.Empty,它表示位于索引0处的 "-" 字符之前的空字符串。

  2. String.Empty,它表示位于索引0处的 "-" 字符和索引1处 "_" 字符之间的空字符串。

  3. "aa"。

  4. String.Empty,它表示位于索引4处的 "-" 字符后面的空字符串。

  5. String.Empty,它表示位于索引5的 "_" 字符之后的空字符串。

分隔符数组

如果 separator 参数为 null 或不包含任何字符,则假定空格字符为分隔符。 空白字符由 Unicode 标准定义,如果传递给空格字符,则方法 Char.IsWhiteSpace true 返回 。

若要为 参数传递 ,必须指示 的类型,以将调用与一些其他重载(如 ) null char[] separator null 解除联系 Split(String[], StringSplitOptions) 。 下面的示例演示了明确标识此重载的多种方式。

string phrase = "The quick  brown fox";

_ = phrase.Split(default(char[]), StringSplitOptions.RemoveEmptyEntries);

_ = phrase.Split((char[])null, StringSplitOptions.RemoveEmptyEntries);

_ = phrase.Split(null as char[], StringSplitOptions.RemoveEmptyEntries);

比较详细信息

方法提取此字符串中由 参数中的一个或多个字符分隔的子字符串,并返回这些子 Split separator 字符串作为数组的元素。

Split方法通过使用区分大小写的序号排序规则执行比较来查找分隔符。 有关单词、字符串和序号排序详细信息,请参阅 System.Globalization.CompareOptions 枚举。

性能注意事项

方法 Split 为返回的数组对象和每个 String 数组元素的 对象分配内存。 如果应用程序需要最佳性能,或者管理内存分配在应用程序中至关重要,请考虑使用 或 方法(可选)在字符串中 IndexOf IndexOfAny Compare 查找子字符串。

如果要在分隔符处拆分字符串,请使用 IndexOfIndexOfAny 方法在字符串中查找分隔符。 如果要在分隔符字符串处拆分字符串,请使用 或 方法查找分隔符 IndexOf IndexOfAny 字符串的第一个字符。 然后使用 方法确定第一个字符之后 Compare 的字符是否等于分隔符字符串的剩余字符。

此外,如果使用同一组字符在多个方法调用中拆分字符串,请考虑创建单个数组,并在每个方法调用 Split 中引用它。 这大大减少了每个方法调用的额外开销。

调用方说明

在 .NET Framework 3.5 及更早版本中,如果向方法传递了一个为 或不包含任何字符的 ,则该方法使用一组略有不同的空白字符来拆分字符串,而方法则使用来剪裁字符串。 Split(Char[]) separator null Trim(Char[]) 从 .NET Framework 4 开始,这两种方法都使用一组相同的 Unicode 空白字符。

适用于

Split(Char[], Int32)

根据指定的分隔字符将一个字符串拆分成最大数量的子字符串。

public:
 cli::array <System::String ^> ^ Split(cli::array <char> ^ separator, int count);
public string[] Split (char[] separator, int count);
public string[] Split (char[]? separator, int count);
member this.Split : char[] * int -> string[]
Public Function Split (separator As Char(), count As Integer) As String()

参数

separator
Char[]

分隔此字符串中子字符串的字符数组、不包含分隔符的空数组或 null

count
Int32

要返回的子字符串的最大数量。

返回

String[]

一个数组,其元素包含此实例中的子字符串,这些子字符串由 separator 中的一个或多个字符分隔。 有关详细信息,请参阅“备注”部分。

例外

count 为负数。

示例

下面的示例演示如何 count 使用来限制返回的字符串的数目 Split

string name = "Alex Johnson III";

string[] subs = name.Split(null, 2);

string firstName = subs[0];
string lastName;
if (subs.Length > 1)
{
    lastName = subs[1];
}

// firstName = "Alex"
// lastName = "Johnson III"

注解

分隔符字符不包含在返回数组的元素中。

如果此实例不包含中的任何字符 separator ,则返回的数组由包含此实例的单个元素组成。 如果 count 为零,则返回空数组。

如果 separator 参数为 null 或不包含任何字符,则假定空格字符为分隔符。 空白字符由 Unicode 标准定义, Char.IsWhiteSpace true 如果传递给它,则方法将返回。

的每个元素 separator 定义单独的分隔符字符。 如果两个分隔符相邻,或在此实例的开头或结尾找到了分隔符,则对应的数组元素包含 Empty

如果 count 此实例中有多个子字符串,则返回 count - 1 值的第一个元素中会返回第一个子字符串 count - 1 ,并且返回值的最后一个元素中会返回此实例中的剩余字符。

如果 count 大于子字符串的数目,则将返回可用的子字符串,并且不会引发异常。

下表显示了一些示例。

语言 字符串值 Separator 返回数组
C# "42, 12, 19" new Char [] {",",""} {"42", "", "12", "", "19"}
Visual Basic "42, 12, 19" Char () = {"," c,"" c} ) {"42", "", "12", "", "19"}
C# "42. 12 ... 19." new Char [] {"."} {"42","","12","","19",""}
Visual Basic "42. 12 ... 19." Char () = {"."ansi-c {"42","","12","","19",""}
C# 香蕉 new Char [] {"."} {"香蕉"}
Visual Basic 香蕉 Char () = {"."ansi-c {"香蕉"}
C# "Darb\nSmarba" new Char [] {} {"Darb", "Smarba"}
Visual Basic "Darb" & vbLf & "Smarba" Char () = {} {"Darb", "Smarba"}
C# "Darb\nSmarba" Null {"Darb", "Smarba"}
Visual Basic "Darb" & vbLf & "Smarba" {"Darb", "Smarba"}

性能注意事项

Split方法为返回的数组对象分配内存,并为 String 每个数组元素分配一个对象。 如果你的应用程序需要最佳性能,或者在你的应用程序中管理内存分配非常重要,请考虑使用 IndexOfIndexOfAny 方法,并根据需要使用 Compare 方法来查找字符串中的子字符串。

如果要在分隔符处拆分字符串,请使用 IndexOfIndexOfAny 方法来查找字符串中的分隔符。 如果要将字符串拆分为分隔符字符串,请使用 IndexOfIndexOfAny 方法查找分隔符字符串的第一个字符。 然后,使用 Compare 方法来确定第一个字符后面的字符是否等于分隔符字符串的剩余字符。

此外,如果使用相同的字符集拆分多个方法调用中的字符串 Split ,请考虑创建一个数组,并在每个方法调用中引用它。 这可以显著降低每个方法调用的额外开销。

调用方说明

在 .NET Framework 3.5 及更早版本中,如果向 Split(Char[]) 方法传递的 separatornull 或不包含任何字符,则该方法将使用一组略有不同的空白字符来拆分字符串,而不是使用 Trim(Char[]) 方法来剪裁字符串。 从 .NET Framework 4 开始,这两个方法都使用一组相同的 Unicode 空白字符。

另请参阅

适用于

Split(Char, StringSplitOptions)

基于指定的分隔字符和(可选)选项将字符串拆分为子字符串。

public string[] Split (char separator, StringSplitOptions options = System.StringSplitOptions.None);
member this.Split : char * StringSplitOptions -> string[]
Public Function Split (separator As Char, Optional options As StringSplitOptions = System.StringSplitOptions.None) As String()

参数

separator
Char

一个字符,用于分隔此字符串中的子字符串。

options
StringSplitOptions

枚举值的按位组合,用于指定是否剪裁子字符串并包含空子字符串。

返回

String[]

一个数组,其元素包含此实例中的子字符串,这些子字符串由 separator 分隔。

适用于

Split(String, StringSplitOptions)

根据提供的字符串分隔符将字符串拆分为多个子字符串。

public string[] Split (string? separator, StringSplitOptions options = System.StringSplitOptions.None);
public string[] Split (string separator, StringSplitOptions options = System.StringSplitOptions.None);
member this.Split : string * StringSplitOptions -> string[]
Public Function Split (separator As String, Optional options As StringSplitOptions = System.StringSplitOptions.None) As String()

参数

separator
String

一个字符串,用于分隔此字符串中的子字符串。

options
StringSplitOptions

枚举值的按位组合,指定是否剪裁子字符串并包括空子字符串。

返回

String[]

一个数组,其元素包含此实例中的子字符串,这些子字符串由 separator 分隔。

适用于

Split(Char[])

根据指定的分隔字符将字符串拆分为子字符串。

public:
 cli::array <System::String ^> ^ Split(... cli::array <char> ^ separator);
public string[] Split (params char[] separator);
public string[] Split (params char[]? separator);
member this.Split : char[] -> string[]
Public Function Split (ParamArray separator As Char()) As String()

参数

separator
Char[]

分隔字符的数组、不包含分隔符的空数组或 null

返回

String[]

一个数组,其元素包含此实例中的子字符串,这些子字符串由 separator 中的一个或多个字符分隔。 有关详细信息,请参阅“备注”部分。

示例

下面的示例演示了如何通过将空格字符 ( ) 和制表符 (\t) 作为分隔符来从文本块提取各个单词。 要拆分的字符串同时包含这两个字符。

string s = "Today\tI'm going to school";
string[] subs = s.Split(' ', '\t');

foreach (var sub in subs)
{
    Console.WriteLine($"Substring: {sub}");
}

// This example produces the following output:
//
// Substring: Today
// Substring: I'm
// Substring: going
// Substring: to
// Substring: school

注解

当使用一组已知的字符分隔字符串时,可以使用 Split(Char[]) 方法将其分隔为子字符串。

分隔符字符不包含在返回数组的元素中。 例如,如果分隔符数组包含字符 "-",而当前字符串实例的值为 "aa-bb-cc",则该方法将返回包含三个元素的数组: "aa"、"bb" 和 "cc"。

如果此实例不包含中的任何字符 separator ,则返回的数组由包含此实例的单个元素组成。

的每个元素 separator 定义单独的分隔符字符。 如果两个分隔符相邻,或在此实例的开头或结尾找到了分隔符,则返回数组中的相应元素包含 Empty

下表显示了一些示例。

语言 字符串值 Separator 返回数组
C# "42, 12, 19" new Char [] {",",""} {"42", "", "12", "", "19"}
Visual Basic "42, 12, 19" Char () = {"," c,"" c} ) {"42", "", "12", "", "19"}
C# "42. 12 ... 19." new Char [] {"."} {"42","","12","","19",""}
Visual Basic "42. 12 ... 19." Char () = {"."ansi-c {"42","","12","","19",""}
C# 香蕉 new Char [] {"."} {"香蕉"}
Visual Basic 香蕉 Char () = {"."ansi-c {"香蕉"}
C# "Darb\nSmarba" new Char [] {} {"Darb", "Smarba"}
Visual Basic "Darb" & vbLf & "Smarba" Char () = {} {"Darb", "Smarba"}
C# "Darb\nSmarba" Null {"Darb", "Smarba"}
Visual Basic "Darb" & vbLf & "Smarba" {"Darb", "Smarba"}

分隔符数组

分隔符的每个元素都定义一个由单个字符组成的单独分隔符。

如果 separator 参数为 null 或不包含任何字符,则该方法将空白字符视为分隔符。 空白字符由 Unicode 标准定义, Char.IsWhiteSpace true 如果向其传递空白字符,该方法将返回。

字符串拆分 (Char [] ) 和编译器重载决策

尽管此重载的单个参数 String.Split 是字符数组,但你可以使用单个字符调用它,如下面的示例所示。

string value = "This is a short string.";
char delimiter = 's';
string[] substrings = value.Split(delimiter);
foreach (var substring in substrings)
    Console.WriteLine(substring);

// The example displays the following output:
//     Thi
//      i
//      a
//     hort
//     tring.

由于 separator 参数使用特性进行修饰 ParamArrayAttribute ,因此编译器会将单个字符解释为单元素字符数组。 这种情况并非 String.Split 包含参数的其他重载的情况 separator ; 必须以参数形式将字符数组显式传递给这些重载 separator

比较详细信息

Split(Char[])方法提取此字符串中的子字符串,这些子字符串由数组中的一个或多个字符分隔 separator ,并将这些子字符串作为数组的元素返回。

Split(Char[])方法通过使用区分大小写的序号排序规则执行比较来查找分隔符。 有关 word、字符串和序号排序的详细信息,请参阅 System.Globalization.CompareOptions 枚举。

性能注意事项

Split方法为返回的数组对象分配内存,并为 String 每个数组元素分配一个对象。 如果你的应用程序需要最佳性能,或者在你的应用程序中管理内存分配非常重要,请考虑使用 IndexOfIndexOfAny 方法。 你还可以选择使用 Compare 方法来查找字符串中的子字符串。

若要在分隔符处拆分字符串,请使用 IndexOfIndexOfAny 方法在字符串中查找分隔符。 若要将字符串拆分为分隔符字符串,请使用 IndexOfIndexOfAny 方法查找分隔符字符串的第一个字符。 然后,使用 Compare 方法来确定第一个字符后面的字符是否等于分隔符字符串的剩余字符。

此外,如果使用相同的字符集拆分多个方法调用中的字符串 Split ,请考虑创建一个数组,并在每个方法调用中引用它。 这可以显著降低每个方法调用的额外开销。

调用方说明

在 .NET Framework 3.5 及更早版本中,如果向 Split(Char[]) 方法传递的 separatornull 或不包含任何字符,则该方法将使用一组略有不同的空白字符来拆分字符串,而不是使用 Trim(Char[]) 方法来剪裁字符串。 从 .NET Framework 4 开始,这两个方法都使用一组相同的 Unicode 空白字符。

另请参阅

适用于