SortedList 构造函数
定义
初始化 SortedList 类的新实例。Initializes a new instance of the SortedList class.
重载
| SortedList() |
初始化 SortedList 类的新实例,该实例为空、具有默认初始容量并根据 IComparable 接口(此接口由添加到 SortedList 对象中的每个键实现)进行排序。Initializes a new instance of the SortedList class that is empty, has the default initial capacity, and is sorted according to the IComparable interface implemented by each key added to the SortedList object. |
| SortedList(IComparer) |
初始化 SortedList 类的新实例,该实例为空、具有默认初始容量并根据指定的 IComparer 接口进行排序。Initializes a new instance of the SortedList class that is empty, has the default initial capacity, and is sorted according to the specified IComparer interface. |
| SortedList(IDictionary) |
初始化 SortedList 类的新实例,该实例包含从指定字典复制的元素、具有与所复制的元素数相同的初始容量并根据由每个键实现的 IComparable 接口排序。Initializes a new instance of the SortedList class that contains elements copied from the specified dictionary, has the same initial capacity as the number of elements copied, and is sorted according to the IComparable interface implemented by each key. |
| SortedList(Int32) |
初始化 SortedList 类的新实例,该实例为空、具有指定的初始容量并且根据 IComparable 接口(此接口由添加到 SortedList 对象的每个键实现)进行排序。Initializes a new instance of the SortedList class that is empty, has the specified initial capacity, and is sorted according to the IComparable interface implemented by each key added to the SortedList object. |
| SortedList(IComparer, Int32) |
初始化 SortedList 类的新实例,该实例为空、具有指定的初始容量并根据指定的 IComparer 接口排序。Initializes a new instance of the SortedList class that is empty, has the specified initial capacity, and is sorted according to the specified IComparer interface. |
| SortedList(IDictionary, IComparer) |
初始化 SortedList 类的新实例,该实例包含从指定字典复制的元素、具有与所复制的元素数相同的初始容量并根据指定的 IComparer 接口排序。Initializes a new instance of the SortedList class that contains elements copied from the specified dictionary, has the same initial capacity as the number of elements copied, and is sorted according to the specified IComparer interface. |
SortedList()
初始化 SortedList 类的新实例,该实例为空、具有默认初始容量并根据 IComparable 接口(此接口由添加到 SortedList 对象中的每个键实现)进行排序。Initializes a new instance of the SortedList class that is empty, has the default initial capacity, and is sorted according to the IComparable interface implemented by each key added to the SortedList object.
public:
SortedList();
public SortedList ();
Public Sub New ()
示例
下面的代码示例使用不同 SortedList 的构造函数创建集合,并演示集合行为中的差异。The following code example creates collections using different SortedList constructors and demonstrates the differences in the behavior of the collections.
// The following code example creates SortedList instances using different constructors
// and demonstrates the differences in the behavior of the SortedList instances.
using namespace System;
using namespace System::Collections;
using namespace System::Globalization;
void PrintKeysAndValues( SortedList^ myList )
{
Console::WriteLine( " -KEY- -VALUE-" );
for ( int i = 0; i < myList->Count; i++ )
{
Console::WriteLine( " {0,-6}: {1}", myList->GetKey( i ), myList->GetByIndex( i ) );
}
Console::WriteLine();
}
int main()
{
// Create a SortedList using the default comparer.
SortedList^ mySL1 = gcnew SortedList;
Console::WriteLine( "mySL1 (default):" );
mySL1->Add( "FIRST", "Hello" );
mySL1->Add( "SECOND", "World" );
mySL1->Add( "THIRD", "!" );
try { mySL1->Add( "first", "Ola!" ); }
catch ( ArgumentException^ e ) { Console::WriteLine( e ); }
PrintKeysAndValues( mySL1 );
// Create a SortedList using the specified case-insensitive comparer.
SortedList^ mySL2 = gcnew SortedList( gcnew CaseInsensitiveComparer );
Console::WriteLine( "mySL2 (case-insensitive comparer):" );
mySL2->Add( "FIRST", "Hello" );
mySL2->Add( "SECOND", "World" );
mySL2->Add( "THIRD", "!" );
try { mySL2->Add( "first", "Ola!" ); }
catch ( ArgumentException^ e ) { Console::WriteLine( e ); }
PrintKeysAndValues( mySL2 );
// Create a SortedList using the specified KeyComparer.
// The KeyComparer uses a case-insensitive hash code provider and a case-insensitive comparer,
// which are based on the Turkish culture (tr-TR), where "I" is not the uppercase version of "i".
CultureInfo^ myCul = gcnew CultureInfo( "tr-TR" );
SortedList^ mySL3 = gcnew SortedList( gcnew CaseInsensitiveComparer( myCul ) );
Console::WriteLine( "mySL3 (case-insensitive comparer, Turkish culture):" );
mySL3->Add( "FIRST", "Hello" );
mySL3->Add( "SECOND", "World" );
mySL3->Add( "THIRD", "!" );
try { mySL3->Add( "first", "Ola!" ); }
catch ( ArgumentException^ e ) { Console::WriteLine( e ); }
PrintKeysAndValues( mySL3 );
// Create a SortedList using the ComparisonType.InvariantCultureIgnoreCase value.
SortedList^ mySL4 = gcnew SortedList( StringComparer::InvariantCultureIgnoreCase );
Console::WriteLine( "mySL4 (InvariantCultureIgnoreCase):" );
mySL4->Add( "FIRST", "Hello" );
mySL4->Add( "SECOND", "World" );
mySL4->Add( "THIRD", "!" );
try { mySL4->Add( "first", "Ola!" ); }
catch ( ArgumentException^ e ) { Console::WriteLine( e ); }
PrintKeysAndValues( mySL4 );
Console::WriteLine("\n\nHit ENTER to return");
Console::ReadLine();
}
/*
This code produces the following output. Results vary depending on the system's culture settings.
mySL1 (default):
-KEY- -VALUE-
first : Ola!
FIRST : Hello
SECOND: World
THIRD : !
mySL2 (case-insensitive comparer):
System.ArgumentException: Item has already been added. Key in dictionary: 'FIRST' Key being added: 'first'
at System.Collections.SortedList.Add(Object key, Object value)
at SamplesSortedList.Main()
-KEY- -VALUE-
FIRST : Hello
SECOND: World
THIRD : !
mySL3 (case-insensitive comparer, Turkish culture):
-KEY- -VALUE-
FIRST : Hello
first : Ola!
SECOND: World
THIRD : !
mySL4 (InvariantCultureIgnoreCase):
System.ArgumentException: Item has already been added. Key in dictionary: 'FIRST' Key being added: 'first'
at System.Collections.SortedList.Add(Object key, Object value)
at SamplesSortedList.Main()
-KEY- -VALUE-
FIRST : Hello
SECOND: World
THIRD : !
*/
using System;
using System.Collections;
using System.Globalization;
public class SamplesSortedList
{
public static void Main()
{
// Create a SortedList using the default comparer.
SortedList mySL1 = new SortedList();
Console.WriteLine("mySL1 (default):");
mySL1.Add("FIRST", "Hello");
mySL1.Add("SECOND", "World");
mySL1.Add("THIRD", "!");
try
{
mySL1.Add("first", "Ola!");
}
catch (ArgumentException e)
{
Console.WriteLine(e);
}
PrintKeysAndValues(mySL1);
// Create a SortedList using the specified case-insensitive comparer.
SortedList mySL2 = new SortedList(new CaseInsensitiveComparer());
Console.WriteLine("mySL2 (case-insensitive comparer):");
mySL2.Add("FIRST", "Hello");
mySL2.Add("SECOND", "World");
mySL2.Add("THIRD", "!");
try
{
mySL2.Add("first", "Ola!");
}
catch (ArgumentException e)
{
Console.WriteLine(e);
}
PrintKeysAndValues(mySL2);
// Create a SortedList using the specified CaseInsensitiveComparer,
// which is based on the Turkish culture (tr-TR), where "I" is not
// the uppercase version of "i".
CultureInfo myCul = new CultureInfo("tr-TR");
SortedList mySL3 = new SortedList(new CaseInsensitiveComparer(myCul));
Console.WriteLine(
"mySL3 (case-insensitive comparer, Turkish culture):");
mySL3.Add("FIRST", "Hello");
mySL3.Add("SECOND", "World");
mySL3.Add("THIRD", "!");
try
{
mySL3.Add("first", "Ola!");
}
catch (ArgumentException e)
{
Console.WriteLine(e);
}
PrintKeysAndValues(mySL3);
// Create a SortedList using the
// StringComparer.InvariantCultureIgnoreCase value.
SortedList mySL4 = new SortedList(
StringComparer.InvariantCultureIgnoreCase);
Console.WriteLine("mySL4 (InvariantCultureIgnoreCase):");
mySL4.Add("FIRST", "Hello");
mySL4.Add("SECOND", "World");
mySL4.Add("THIRD", "!");
try
{
mySL4.Add("first", "Ola!");
}
catch (ArgumentException e)
{
Console.WriteLine(e);
}
PrintKeysAndValues(mySL4);
}
public static void PrintKeysAndValues(SortedList myList)
{
Console.WriteLine(" -KEY- -VALUE-");
for (int i = 0; i < myList.Count; i++)
{
Console.WriteLine(" {0,-6}: {1}",
myList.GetKey(i), myList.GetByIndex(i));
}
Console.WriteLine();
}
}
/*
This code produces the following output.
Results vary depending on the system's culture settings.
mySL1 (default):
-KEY- -VALUE-
first : Ola!
FIRST : Hello
SECOND: World
THIRD : !
mySL2 (case-insensitive comparer):
System.ArgumentException: Item has already been added. Key in dictionary: 'FIRST' Key being added: 'first'
at System.Collections.SortedList.Add(Object key, Object value)
at SamplesSortedList.Main()
-KEY- -VALUE-
FIRST : Hello
SECOND: World
THIRD : !
mySL3 (case-insensitive comparer, Turkish culture):
-KEY- -VALUE-
FIRST : Hello
first : Ola!
SECOND: World
THIRD : !
mySL4 (InvariantCultureIgnoreCase):
System.ArgumentException: Item has already been added. Key in dictionary: 'FIRST' Key being added: 'first'
at System.Collections.SortedList.Add(Object key, Object value)
at SamplesSortedList.Main()
-KEY- -VALUE-
FIRST : Hello
SECOND: World
THIRD : !
*/
Imports System.Collections
Imports System.Globalization
Public Class SamplesSortedList
Public Shared Sub Main()
' Create a SortedList using the default comparer.
Dim mySL1 As New SortedList()
Console.WriteLine("mySL1 (default):")
mySL1.Add("FIRST", "Hello")
mySL1.Add("SECOND", "World")
mySL1.Add("THIRD", "!")
Try
mySL1.Add("first", "Ola!")
Catch e As ArgumentException
Console.WriteLine(e)
End Try
PrintKeysAndValues(mySL1)
' Create a SortedList using the specified case-insensitive comparer.
Dim mySL2 As New SortedList(New CaseInsensitiveComparer())
Console.WriteLine("mySL2 (case-insensitive comparer):")
mySL2.Add("FIRST", "Hello")
mySL2.Add("SECOND", "World")
mySL2.Add("THIRD", "!")
Try
mySL2.Add("first", "Ola!")
Catch e As ArgumentException
Console.WriteLine(e)
End Try
PrintKeysAndValues(mySL2)
' Create a SortedList using the specified CaseInsensitiveComparer,
' which is based on the Turkish culture (tr-TR), where "I" is not
' the uppercase version of "i".
Dim myCul As New CultureInfo("tr-TR")
Dim mySL3 As New SortedList(New CaseInsensitiveComparer(myCul))
Console.WriteLine("mySL3 (case-insensitive comparer, Turkish culture):")
mySL3.Add("FIRST", "Hello")
mySL3.Add("SECOND", "World")
mySL3.Add("THIRD", "!")
Try
mySL3.Add("first", "Ola!")
Catch e As ArgumentException
Console.WriteLine(e)
End Try
PrintKeysAndValues(mySL3)
' Create a SortedList using the
' StringComparer.InvariantCultureIgnoreCase value.
Dim mySL4 As New SortedList( _
StringComparer.InvariantCultureIgnoreCase)
Console.WriteLine("mySL4 (InvariantCultureIgnoreCase):")
mySL4.Add("FIRST", "Hello")
mySL4.Add("SECOND", "World")
mySL4.Add("THIRD", "!")
Try
mySL4.Add("first", "Ola!")
Catch e As ArgumentException
Console.WriteLine(e)
End Try
PrintKeysAndValues(mySL4)
End Sub
Public Shared Sub PrintKeysAndValues(ByVal myList As SortedList)
Console.WriteLine(" -KEY- -VALUE-")
Dim i As Integer
For i = 0 To myList.Count - 1
Console.WriteLine(" {0,-6}: {1}", _
myList.GetKey(i), myList.GetByIndex(i))
Next i
Console.WriteLine()
End Sub
End Class
'This code produces the following output. Results vary depending on the system's culture settings.
'
'mySL1 (default):
' -KEY- -VALUE-
' first : Ola!
' FIRST : Hello
' SECOND: World
' THIRD : !
'
'mySL2 (case-insensitive comparer):
'System.ArgumentException: Item has already been added. Key in dictionary: 'FIRST' Key being added: 'first'' at System.Collections.SortedList.Add(Object key, Object value)
' at SamplesSortedList.Main()
' -KEY- -VALUE-
' FIRST : Hello
' SECOND: World
' THIRD : !
'
'mySL3 (case-insensitive comparer, Turkish culture):
' -KEY- -VALUE-
' FIRST : Hello
' first : Ola!
' SECOND: World
' THIRD : !
'
'mySL4 (InvariantCultureIgnoreCase):
'System.ArgumentException: Item has already been added. Key in dictionary: 'FIRST' Key being added: 'first'' at System.Collections.SortedList.Add(Object key, Object value)
' at SamplesSortedList.Main()
' -KEY- -VALUE-
' FIRST : Hello
' SECOND: World
' THIRD : !
注解
每个密钥都必须实现 IComparable 接口,以便能够与对象中的每个其他键进行比较 SortedList 。Each key must implement the IComparable interface to be capable of comparisons with every other key in the SortedList object. 元素根据 IComparable 添加到中的每个键的实现进行排序 SortedList 。The elements are sorted according to the IComparable implementation of each key added to the SortedList.
对象的容量 SortedList 是可容纳的元素数 SortedList 。The capacity of a SortedList object is the number of elements that the SortedList can hold. 当向添加元素时 SortedList ,将根据需要通过重新分配内部数组来自动增加容量。As elements are added to a SortedList, the capacity is automatically increased as required by reallocating the internal array.
如果集合的大小可为估算值,则指定初始容量就无需在向对象添加元素时执行多个大小调整操作 SortedList 。If the size of the collection can be estimated, specifying the initial capacity eliminates the need to perform a number of resizing operations while adding elements to the SortedList object.
此构造函数是一种 O(1) 操作。This constructor is an O(1) operation.
另请参阅
- IComparable
- Capacity
- 在集合中执行不区分区域性的字符串操作Performing Culture-Insensitive String Operations in Collections
适用于
SortedList(IComparer)
初始化 SortedList 类的新实例,该实例为空、具有默认初始容量并根据指定的 IComparer 接口进行排序。Initializes a new instance of the SortedList class that is empty, has the default initial capacity, and is sorted according to the specified IComparer interface.
public:
SortedList(System::Collections::IComparer ^ comparer);
public SortedList (System.Collections.IComparer comparer);
public SortedList (System.Collections.IComparer? comparer);
new System.Collections.SortedList : System.Collections.IComparer -> System.Collections.SortedList
Public Sub New (comparer As IComparer)
参数
- comparer
- IComparer
在对键进行比较时使用的 IComparer 实现。The IComparer implementation to use when comparing keys.
- 或 --or-
null,使用每一个键的 IComparable 实现。null to use the IComparable implementation of each key.
示例
下面的代码示例使用不同 SortedList 的构造函数创建集合,并演示集合行为中的差异。The following code example creates collections using different SortedList constructors and demonstrates the differences in the behavior of the collections.
// The following code example creates SortedList instances using different constructors
// and demonstrates the differences in the behavior of the SortedList instances.
using namespace System;
using namespace System::Collections;
using namespace System::Globalization;
void PrintKeysAndValues( SortedList^ myList )
{
Console::WriteLine( " -KEY- -VALUE-" );
for ( int i = 0; i < myList->Count; i++ )
{
Console::WriteLine( " {0,-6}: {1}", myList->GetKey( i ), myList->GetByIndex( i ) );
}
Console::WriteLine();
}
int main()
{
// Create a SortedList using the default comparer.
SortedList^ mySL1 = gcnew SortedList;
Console::WriteLine( "mySL1 (default):" );
mySL1->Add( "FIRST", "Hello" );
mySL1->Add( "SECOND", "World" );
mySL1->Add( "THIRD", "!" );
try { mySL1->Add( "first", "Ola!" ); }
catch ( ArgumentException^ e ) { Console::WriteLine( e ); }
PrintKeysAndValues( mySL1 );
// Create a SortedList using the specified case-insensitive comparer.
SortedList^ mySL2 = gcnew SortedList( gcnew CaseInsensitiveComparer );
Console::WriteLine( "mySL2 (case-insensitive comparer):" );
mySL2->Add( "FIRST", "Hello" );
mySL2->Add( "SECOND", "World" );
mySL2->Add( "THIRD", "!" );
try { mySL2->Add( "first", "Ola!" ); }
catch ( ArgumentException^ e ) { Console::WriteLine( e ); }
PrintKeysAndValues( mySL2 );
// Create a SortedList using the specified KeyComparer.
// The KeyComparer uses a case-insensitive hash code provider and a case-insensitive comparer,
// which are based on the Turkish culture (tr-TR), where "I" is not the uppercase version of "i".
CultureInfo^ myCul = gcnew CultureInfo( "tr-TR" );
SortedList^ mySL3 = gcnew SortedList( gcnew CaseInsensitiveComparer( myCul ) );
Console::WriteLine( "mySL3 (case-insensitive comparer, Turkish culture):" );
mySL3->Add( "FIRST", "Hello" );
mySL3->Add( "SECOND", "World" );
mySL3->Add( "THIRD", "!" );
try { mySL3->Add( "first", "Ola!" ); }
catch ( ArgumentException^ e ) { Console::WriteLine( e ); }
PrintKeysAndValues( mySL3 );
// Create a SortedList using the ComparisonType.InvariantCultureIgnoreCase value.
SortedList^ mySL4 = gcnew SortedList( StringComparer::InvariantCultureIgnoreCase );
Console::WriteLine( "mySL4 (InvariantCultureIgnoreCase):" );
mySL4->Add( "FIRST", "Hello" );
mySL4->Add( "SECOND", "World" );
mySL4->Add( "THIRD", "!" );
try { mySL4->Add( "first", "Ola!" ); }
catch ( ArgumentException^ e ) { Console::WriteLine( e ); }
PrintKeysAndValues( mySL4 );
Console::WriteLine("\n\nHit ENTER to return");
Console::ReadLine();
}
/*
This code produces the following output. Results vary depending on the system's culture settings.
mySL1 (default):
-KEY- -VALUE-
first : Ola!
FIRST : Hello
SECOND: World
THIRD : !
mySL2 (case-insensitive comparer):
System.ArgumentException: Item has already been added. Key in dictionary: 'FIRST' Key being added: 'first'
at System.Collections.SortedList.Add(Object key, Object value)
at SamplesSortedList.Main()
-KEY- -VALUE-
FIRST : Hello
SECOND: World
THIRD : !
mySL3 (case-insensitive comparer, Turkish culture):
-KEY- -VALUE-
FIRST : Hello
first : Ola!
SECOND: World
THIRD : !
mySL4 (InvariantCultureIgnoreCase):
System.ArgumentException: Item has already been added. Key in dictionary: 'FIRST' Key being added: 'first'
at System.Collections.SortedList.Add(Object key, Object value)
at SamplesSortedList.Main()
-KEY- -VALUE-
FIRST : Hello
SECOND: World
THIRD : !
*/
using System;
using System.Collections;
using System.Globalization;
public class SamplesSortedList
{
public static void Main()
{
// Create a SortedList using the default comparer.
SortedList mySL1 = new SortedList();
Console.WriteLine("mySL1 (default):");
mySL1.Add("FIRST", "Hello");
mySL1.Add("SECOND", "World");
mySL1.Add("THIRD", "!");
try
{
mySL1.Add("first", "Ola!");
}
catch (ArgumentException e)
{
Console.WriteLine(e);
}
PrintKeysAndValues(mySL1);
// Create a SortedList using the specified case-insensitive comparer.
SortedList mySL2 = new SortedList(new CaseInsensitiveComparer());
Console.WriteLine("mySL2 (case-insensitive comparer):");
mySL2.Add("FIRST", "Hello");
mySL2.Add("SECOND", "World");
mySL2.Add("THIRD", "!");
try
{
mySL2.Add("first", "Ola!");
}
catch (ArgumentException e)
{
Console.WriteLine(e);
}
PrintKeysAndValues(mySL2);
// Create a SortedList using the specified CaseInsensitiveComparer,
// which is based on the Turkish culture (tr-TR), where "I" is not
// the uppercase version of "i".
CultureInfo myCul = new CultureInfo("tr-TR");
SortedList mySL3 = new SortedList(new CaseInsensitiveComparer(myCul));
Console.WriteLine(
"mySL3 (case-insensitive comparer, Turkish culture):");
mySL3.Add("FIRST", "Hello");
mySL3.Add("SECOND", "World");
mySL3.Add("THIRD", "!");
try
{
mySL3.Add("first", "Ola!");
}
catch (ArgumentException e)
{
Console.WriteLine(e);
}
PrintKeysAndValues(mySL3);
// Create a SortedList using the
// StringComparer.InvariantCultureIgnoreCase value.
SortedList mySL4 = new SortedList(
StringComparer.InvariantCultureIgnoreCase);
Console.WriteLine("mySL4 (InvariantCultureIgnoreCase):");
mySL4.Add("FIRST", "Hello");
mySL4.Add("SECOND", "World");
mySL4.Add("THIRD", "!");
try
{
mySL4.Add("first", "Ola!");
}
catch (ArgumentException e)
{
Console.WriteLine(e);
}
PrintKeysAndValues(mySL4);
}
public static void PrintKeysAndValues(SortedList myList)
{
Console.WriteLine(" -KEY- -VALUE-");
for (int i = 0; i < myList.Count; i++)
{
Console.WriteLine(" {0,-6}: {1}",
myList.GetKey(i), myList.GetByIndex(i));
}
Console.WriteLine();
}
}
/*
This code produces the following output.
Results vary depending on the system's culture settings.
mySL1 (default):
-KEY- -VALUE-
first : Ola!
FIRST : Hello
SECOND: World
THIRD : !
mySL2 (case-insensitive comparer):
System.ArgumentException: Item has already been added. Key in dictionary: 'FIRST' Key being added: 'first'
at System.Collections.SortedList.Add(Object key, Object value)
at SamplesSortedList.Main()
-KEY- -VALUE-
FIRST : Hello
SECOND: World
THIRD : !
mySL3 (case-insensitive comparer, Turkish culture):
-KEY- -VALUE-
FIRST : Hello
first : Ola!
SECOND: World
THIRD : !
mySL4 (InvariantCultureIgnoreCase):
System.ArgumentException: Item has already been added. Key in dictionary: 'FIRST' Key being added: 'first'
at System.Collections.SortedList.Add(Object key, Object value)
at SamplesSortedList.Main()
-KEY- -VALUE-
FIRST : Hello
SECOND: World
THIRD : !
*/
Imports System.Collections
Imports System.Globalization
Public Class SamplesSortedList
Public Shared Sub Main()
' Create a SortedList using the default comparer.
Dim mySL1 As New SortedList()
Console.WriteLine("mySL1 (default):")
mySL1.Add("FIRST", "Hello")
mySL1.Add("SECOND", "World")
mySL1.Add("THIRD", "!")
Try
mySL1.Add("first", "Ola!")
Catch e As ArgumentException
Console.WriteLine(e)
End Try
PrintKeysAndValues(mySL1)
' Create a SortedList using the specified case-insensitive comparer.
Dim mySL2 As New SortedList(New CaseInsensitiveComparer())
Console.WriteLine("mySL2 (case-insensitive comparer):")
mySL2.Add("FIRST", "Hello")
mySL2.Add("SECOND", "World")
mySL2.Add("THIRD", "!")
Try
mySL2.Add("first", "Ola!")
Catch e As ArgumentException
Console.WriteLine(e)
End Try
PrintKeysAndValues(mySL2)
' Create a SortedList using the specified CaseInsensitiveComparer,
' which is based on the Turkish culture (tr-TR), where "I" is not
' the uppercase version of "i".
Dim myCul As New CultureInfo("tr-TR")
Dim mySL3 As New SortedList(New CaseInsensitiveComparer(myCul))
Console.WriteLine("mySL3 (case-insensitive comparer, Turkish culture):")
mySL3.Add("FIRST", "Hello")
mySL3.Add("SECOND", "World")
mySL3.Add("THIRD", "!")
Try
mySL3.Add("first", "Ola!")
Catch e As ArgumentException
Console.WriteLine(e)
End Try
PrintKeysAndValues(mySL3)
' Create a SortedList using the
' StringComparer.InvariantCultureIgnoreCase value.
Dim mySL4 As New SortedList( _
StringComparer.InvariantCultureIgnoreCase)
Console.WriteLine("mySL4 (InvariantCultureIgnoreCase):")
mySL4.Add("FIRST", "Hello")
mySL4.Add("SECOND", "World")
mySL4.Add("THIRD", "!")
Try
mySL4.Add("first", "Ola!")
Catch e As ArgumentException
Console.WriteLine(e)
End Try
PrintKeysAndValues(mySL4)
End Sub
Public Shared Sub PrintKeysAndValues(ByVal myList As SortedList)
Console.WriteLine(" -KEY- -VALUE-")
Dim i As Integer
For i = 0 To myList.Count - 1
Console.WriteLine(" {0,-6}: {1}", _
myList.GetKey(i), myList.GetByIndex(i))
Next i
Console.WriteLine()
End Sub
End Class
'This code produces the following output. Results vary depending on the system's culture settings.
'
'mySL1 (default):
' -KEY- -VALUE-
' first : Ola!
' FIRST : Hello
' SECOND: World
' THIRD : !
'
'mySL2 (case-insensitive comparer):
'System.ArgumentException: Item has already been added. Key in dictionary: 'FIRST' Key being added: 'first'' at System.Collections.SortedList.Add(Object key, Object value)
' at SamplesSortedList.Main()
' -KEY- -VALUE-
' FIRST : Hello
' SECOND: World
' THIRD : !
'
'mySL3 (case-insensitive comparer, Turkish culture):
' -KEY- -VALUE-
' FIRST : Hello
' first : Ola!
' SECOND: World
' THIRD : !
'
'mySL4 (InvariantCultureIgnoreCase):
'System.ArgumentException: Item has already been added. Key in dictionary: 'FIRST' Key being added: 'first'' at System.Collections.SortedList.Add(Object key, Object value)
' at SamplesSortedList.Main()
' -KEY- -VALUE-
' FIRST : Hello
' SECOND: World
' THIRD : !
注解
元素根据指定的实现进行排序 IComparer 。The elements are sorted according to the specified IComparer implementation. 如果 comparer 参数为 null ,则 IComparable 使用每个键的实现; 因此,每个键都必须实现 IComparable 接口,以便能够与对象中的每个其他键进行比较 SortedList 。If the comparer parameter is null, the IComparable implementation of each key is used; therefore, each key must implement the IComparable interface to be capable of comparisons with every other key in the SortedList object.
对象的容量 SortedList 是可容纳的元素数 SortedList 。The capacity of a SortedList object is the number of elements that the SortedList can hold. 当向添加元素时 SortedList ,将根据需要通过重新分配内部数组来自动增加容量。As elements are added to a SortedList, the capacity is automatically increased as required by reallocating the internal array.
如果集合的大小可为估算值,则指定初始容量就无需在向对象添加元素时执行多个大小调整操作 SortedList 。If the size of the collection can be estimated, specifying the initial capacity eliminates the need to perform a number of resizing operations while adding elements to the SortedList object.
此构造函数是一种 O(1) 操作。This constructor is an O(1) operation.
另请参阅
- IComparer
- IComparable
- Capacity
- 在集合中执行不区分区域性的字符串操作Performing Culture-Insensitive String Operations in Collections
适用于
SortedList(IDictionary)
初始化 SortedList 类的新实例,该实例包含从指定字典复制的元素、具有与所复制的元素数相同的初始容量并根据由每个键实现的 IComparable 接口排序。Initializes a new instance of the SortedList class that contains elements copied from the specified dictionary, has the same initial capacity as the number of elements copied, and is sorted according to the IComparable interface implemented by each key.
public:
SortedList(System::Collections::IDictionary ^ d);
public SortedList (System.Collections.IDictionary d);
new System.Collections.SortedList : System.Collections.IDictionary -> System.Collections.SortedList
Public Sub New (d As IDictionary)
参数
要复制到新 IDictionary 对象的 SortedList 实现。The IDictionary implementation to copy to a new SortedList object.
例外
d 为 null。d is null.
d 中的一个或多个元素未实现 IComparable 接口。One or more elements in d do not implement the IComparable interface.
示例
下面的代码示例使用不同 SortedList 的构造函数创建集合,并演示集合行为中的差异。The following code example creates collections using different SortedList constructors and demonstrates the differences in the behavior of the collections.
using namespace System;
using namespace System::Collections;
using namespace System::Globalization;
void PrintKeysAndValues( SortedList^ myList )
{
Console::WriteLine( " -KEY- -VALUE-" );
for ( int i = 0; i < myList->Count; i++ )
{
Console::WriteLine( " {0,-6}: {1}", myList->GetKey( i ), myList->GetByIndex( i ) );
}
Console::WriteLine();
}
int main()
{
// Create the dictionary.
Hashtable^ myHT = gcnew Hashtable;
myHT->Add( "FIRST", "Hello" );
myHT->Add( "SECOND", "World" );
myHT->Add( "THIRD", "!" );
// Create a SortedList using the default comparer.
SortedList^ mySL1 = gcnew SortedList( myHT );
Console::WriteLine( "mySL1 (default):" );
try
{
mySL1->Add( "first", "Ola!" );
}
catch ( ArgumentException^ e )
{
Console::WriteLine( e );
}
PrintKeysAndValues( mySL1 );
// Create a SortedList using the specified case-insensitive comparer.
SortedList^ mySL2 = gcnew SortedList( myHT,gcnew CaseInsensitiveComparer );
Console::WriteLine( "mySL2 (case-insensitive comparer):" );
try
{
mySL2->Add( "first", "Ola!" );
}
catch ( ArgumentException^ e )
{
Console::WriteLine( e );
}
PrintKeysAndValues( mySL2 );
// Create a SortedList using the specified CaseInsensitiveComparer,
// which is based on the Turkish culture (tr-TR), where "I" is not
// the uppercase version of "i".
CultureInfo^ myCul = gcnew CultureInfo( "tr-TR" );
SortedList^ mySL3 = gcnew SortedList( myHT, gcnew CaseInsensitiveComparer( myCul ) );
Console::WriteLine( "mySL3 (case-insensitive comparer, Turkish culture):" );
try
{
mySL3->Add( "first", "Ola!" );
}
catch ( ArgumentException^ e )
{
Console::WriteLine( e );
}
PrintKeysAndValues( mySL3 );
// Create a SortedList using the ComparisonType.InvariantCultureIgnoreCase value.
SortedList^ mySL4 = gcnew SortedList( myHT, StringComparer::InvariantCultureIgnoreCase );
Console::WriteLine( "mySL4 (InvariantCultureIgnoreCase):" );
try
{
mySL4->Add( "first", "Ola!" );
}
catch ( ArgumentException^ e )
{
Console::WriteLine( e );
}
PrintKeysAndValues( mySL4 );
}
/*
This code produces the following output. Results vary depending on the system's culture settings.
mySL1 (default):
-KEY- -VALUE-
first : Ola!
FIRST : Hello
SECOND: World
THIRD : !
mySL2 (case-insensitive comparer):
System.ArgumentException: Item has already been added. Key in dictionary: 'FIRST' Key being added: 'first'
at System.Collections.SortedList.Add(Object key, Object value)
at SamplesSortedList.Main()
-KEY- -VALUE-
FIRST : Hello
SECOND: World
THIRD : !
mySL3 (case-insensitive comparer, Turkish culture):
-KEY- -VALUE-
FIRST : Hello
first : Ola!
SECOND: World
THIRD : !
mySL4 (InvariantCultureIgnoreCase):
System.ArgumentException: Item has already been added. Key in dictionary: 'FIRST' Key being added: 'first'
at System.Collections.SortedList.Add(Object key, Object value)
at SamplesSortedList.Main()
-KEY- -VALUE-
FIRST : Hello
SECOND: World
THIRD : !
*/
using System;
using System.Collections;
using System.Globalization;
public class SamplesSortedList
{
public static void Main()
{
// Create the dictionary.
Hashtable myHT = new Hashtable();
myHT.Add("FIRST", "Hello");
myHT.Add("SECOND", "World");
myHT.Add("THIRD", "!");
// Create a SortedList using the default comparer.
SortedList mySL1 = new SortedList(myHT);
Console.WriteLine("mySL1 (default):");
try
{
mySL1.Add("first", "Ola!");
}
catch (ArgumentException e)
{
Console.WriteLine(e);
}
PrintKeysAndValues(mySL1);
// Create a SortedList using the specified case-insensitive comparer.
SortedList mySL2 = new SortedList(myHT, new CaseInsensitiveComparer());
Console.WriteLine("mySL2 (case-insensitive comparer):");
try
{
mySL2.Add("first", "Ola!");
}
catch (ArgumentException e)
{
Console.WriteLine(e);
}
PrintKeysAndValues(mySL2);
// Create a SortedList using the specified CaseInsensitiveComparer,
// which is based on the Turkish culture (tr-TR), where "I" is not
// the uppercase version of "i".
CultureInfo myCul = new CultureInfo("tr-TR");
SortedList mySL3 = new SortedList(myHT, new CaseInsensitiveComparer(myCul));
Console.WriteLine("mySL3 (case-insensitive comparer, Turkish culture):");
try
{
mySL3.Add("first", "Ola!");
}
catch (ArgumentException e)
{
Console.WriteLine(e);
}
PrintKeysAndValues(mySL3);
// Create a SortedList using the
// StringComparer.InvariantCultureIgnoreCase value.
SortedList mySL4 = new SortedList(
myHT, StringComparer.InvariantCultureIgnoreCase);
Console.WriteLine("mySL4 (InvariantCultureIgnoreCase):");
try
{
mySL4.Add("first", "Ola!");
}
catch (ArgumentException e)
{
Console.WriteLine(e);
}
PrintKeysAndValues(mySL4);
}
public static void PrintKeysAndValues(SortedList myList)
{
Console.WriteLine(" -KEY- -VALUE-");
for (int i = 0; i < myList.Count; i++)
{
Console.WriteLine(" {0,-6}: {1}",
myList.GetKey(i), myList.GetByIndex(i));
}
Console.WriteLine();
}
}
/*
This code produces the following output. Results vary depending on the system's culture settings.
mySL1 (default):
-KEY- -VALUE-
first : Ola!
FIRST : Hello
SECOND: World
THIRD : !
mySL2 (case-insensitive comparer):
System.ArgumentException: Item has already been added. Key in dictionary: 'FIRST' Key being added: 'first'
at System.Collections.SortedList.Add(Object key, Object value)
at SamplesSortedList.Main()
-KEY- -VALUE-
FIRST : Hello
SECOND: World
THIRD : !
mySL3 (case-insensitive comparer, Turkish culture):
-KEY- -VALUE-
FIRST : Hello
first : Ola!
SECOND: World
THIRD : !
mySL4 (InvariantCultureIgnoreCase):
System.ArgumentException: Item has already been added. Key in dictionary: 'FIRST' Key being added: 'first'
at System.Collections.SortedList.Add(Object key, Object value)
at SamplesSortedList.Main()
-KEY- -VALUE-
FIRST : Hello
SECOND: World
THIRD : !
*/
Imports System.Collections
Imports System.Globalization
Public Class SamplesSortedList
Public Shared Sub Main()
' Create the dictionary.
Dim myHT As New Hashtable()
myHT.Add("FIRST", "Hello")
myHT.Add("SECOND", "World")
myHT.Add("THIRD", "!")
' Create a SortedList using the default comparer.
Dim mySL1 As New SortedList(myHT)
Console.WriteLine("mySL1 (default):")
Try
mySL1.Add("first", "Ola!")
Catch e As ArgumentException
Console.WriteLine(e)
End Try
PrintKeysAndValues(mySL1)
' Create a SortedList using the specified case-insensitive comparer.
Dim mySL2 As New SortedList(myHT, New CaseInsensitiveComparer())
Console.WriteLine("mySL2 (case-insensitive comparer):")
Try
mySL2.Add("first", "Ola!")
Catch e As ArgumentException
Console.WriteLine(e)
End Try
PrintKeysAndValues(mySL2)
' Create a SortedList using the specified CaseInsensitiveComparer,
' which is based on the Turkish culture (tr-TR), where "I" is not
' the uppercase version of "i".
Dim myCul As New CultureInfo("tr-TR")
Dim mySL3 As New SortedList(myHT, New CaseInsensitiveComparer(myCul))
Console.WriteLine("mySL3 (case-insensitive comparer, Turkish culture):")
Try
mySL3.Add("first", "Ola!")
Catch e As ArgumentException
Console.WriteLine(e)
End Try
PrintKeysAndValues(mySL3)
' Create a SortedList using the
' StringComparer.InvariantCultureIgnoreCase value.
Dim mySL4 As New SortedList(myHT, StringComparer.InvariantCultureIgnoreCase)
Console.WriteLine("mySL4 (InvariantCultureIgnoreCase):")
Try
mySL4.Add("first", "Ola!")
Catch e As ArgumentException
Console.WriteLine(e)
End Try
PrintKeysAndValues(mySL4)
End Sub
Public Shared Sub PrintKeysAndValues(ByVal myList As SortedList)
Console.WriteLine(" -KEY- -VALUE-")
Dim i As Integer
For i = 0 To myList.Count - 1
Console.WriteLine(" {0,-6}: {1}", _
myList.GetKey(i), myList.GetByIndex(i))
Next i
Console.WriteLine()
End Sub
End Class
'This code produces the following output. Results vary depending on the system's culture settings.
'
'mySL1 (default):
' -KEY- -VALUE-
' first : Ola!
' FIRST : Hello
' SECOND: World
' THIRD : !
'
'mySL2 (case-insensitive comparer):
'System.ArgumentException: Item has already been added. Key in dictionary: 'FIRST' Key being added: 'first'' at System.Collections.SortedList.Add(Object key, Object value)
' at SamplesSortedList.Main()
' -KEY- -VALUE-
' FIRST : Hello
' SECOND: World
' THIRD : !
'
'mySL3 (case-insensitive comparer, Turkish culture):
' -KEY- -VALUE-
' FIRST : Hello
' first : Ola!
' SECOND: World
' THIRD : !
'
'mySL4 (InvariantCultureIgnoreCase):
'System.ArgumentException: Item has already been added. Key in dictionary: 'FIRST' Key being added: 'first'' at System.Collections.SortedList.Add(Object key, Object value)
' at SamplesSortedList.Main()
' -KEY- -VALUE-
' FIRST : Hello
' SECOND: World
' THIRD : !
注解
每个密钥都必须实现 IComparable 接口,以便能够与对象中的每个其他键进行比较 SortedList 。Each key must implement the IComparable interface to be capable of comparisons with every other key in the SortedList object. 元素根据 IComparable 添加到中的每个键的实现进行排序 SortedList 。The elements are sorted according to the IComparable implementation of each key added to the SortedList.
Hashtable对象是 IDictionary 可传递到此构造函数的实现的示例。A Hashtable object is an example of an IDictionary implementation that can be passed to this constructor. 新的 SortedList 对象包含存储在中的密钥和值的副本 Hashtable 。The new SortedList object contains a copy of the keys and values stored in the Hashtable.
对象的容量 SortedList 是可容纳的元素数 SortedList 。The capacity of a SortedList object is the number of elements that the SortedList can hold. 当向添加元素时 SortedList ,将根据需要通过重新分配内部数组来自动增加容量。As elements are added to a SortedList, the capacity is automatically increased as required by reallocating the internal array.
如果集合的大小可为估算值,则指定初始容量就无需在向对象添加元素时执行多个大小调整操作 SortedList 。If the size of the collection can be estimated, specifying the initial capacity eliminates the need to perform a number of resizing operations while adding elements to the SortedList object.
此构造函数是一个 O(n) 操作,其中 n 是中的元素数 d 。This constructor is an O(n) operation, where n is the number of elements in d.
另请参阅
- IDictionary
- IComparable
- Hashtable
- Capacity
- 在集合中执行不区分区域性的字符串操作Performing Culture-Insensitive String Operations in Collections
适用于
SortedList(Int32)
初始化 SortedList 类的新实例,该实例为空、具有指定的初始容量并且根据 IComparable 接口(此接口由添加到 SortedList 对象的每个键实现)进行排序。Initializes a new instance of the SortedList class that is empty, has the specified initial capacity, and is sorted according to the IComparable interface implemented by each key added to the SortedList object.
public:
SortedList(int initialCapacity);
public SortedList (int initialCapacity);
new System.Collections.SortedList : int -> System.Collections.SortedList
Public Sub New (initialCapacity As Integer)
参数
- initialCapacity
- Int32
SortedList 对象可包含的初始元素数。The initial number of elements that the SortedList object can contain.
例外
initialCapacity 小于零。initialCapacity is less than zero.
没有足够的可用内存来创建具有指定 initialCapacity 的 SortedList 对象。There is not enough available memory to create a SortedList object with the specified initialCapacity.
示例
下面的代码示例使用不同 SortedList 的构造函数创建集合,并演示集合行为中的差异。The following code example creates collections using different SortedList constructors and demonstrates the differences in the behavior of the collections.
// The following code example creates SortedList instances using different constructors
// and demonstrates the differences in the behavior of the SortedList instances.
using namespace System;
using namespace System::Collections;
using namespace System::Globalization;
void PrintKeysAndValues( SortedList^ myList )
{
Console::WriteLine( " Capacity is {0}.", myList->Capacity );
Console::WriteLine( " -KEY- -VALUE-" );
for ( int i = 0; i < myList->Count; i++ )
{
Console::WriteLine( " {0,-6}: {1}", myList->GetKey( i ), myList->GetByIndex( i ) );
}
Console::WriteLine();
}
int main()
{
// Create a SortedList using the default comparer.
SortedList^ mySL1 = gcnew SortedList( 3 );
Console::WriteLine( "mySL1 (default):" );
mySL1->Add( "FIRST", "Hello" );
mySL1->Add( "SECOND", "World" );
mySL1->Add( "THIRD", "!" );
try
{
mySL1->Add( "first", "Ola!" );
}
catch ( ArgumentException^ e )
{
Console::WriteLine( e );
}
PrintKeysAndValues( mySL1 );
// Create a SortedList using the specified case-insensitive comparer.
SortedList^ mySL2 = gcnew SortedList( gcnew CaseInsensitiveComparer,3 );
Console::WriteLine( "mySL2 (case-insensitive comparer):" );
mySL2->Add( "FIRST", "Hello" );
mySL2->Add( "SECOND", "World" );
mySL2->Add( "THIRD", "!" );
try
{
mySL2->Add( "first", "Ola!" );
}
catch ( ArgumentException^ e )
{
Console::WriteLine( e );
}
PrintKeysAndValues( mySL2 );
// Create a SortedList using the specified CaseInsensitiveComparer,
// which is based on the Turkish culture (tr-TR), where "I" is not
// the uppercase version of "i".
CultureInfo^ myCul = gcnew CultureInfo("tr-TR");
SortedList^ mySL3 = gcnew SortedList(gcnew CaseInsensitiveComparer(myCul), 3);
Console::WriteLine("mySL3 (case-insensitive comparer, Turkish culture):");
mySL3->Add("FIRST", "Hello");
mySL3->Add("SECOND", "World");
mySL3->Add("THIRD", "!");
try
{
mySL3->Add("first", "Ola!");
}
catch (ArgumentException^ e)
{
Console::WriteLine(e);
}
PrintKeysAndValues(mySL3);
// Create a SortedList using the
// StringComparer.InvariantCultureIgnoreCase value.
SortedList^ mySL4 = gcnew SortedList( StringComparer::InvariantCultureIgnoreCase, 3 );
Console::WriteLine( "mySL4 (InvariantCultureIgnoreCase):" );
mySL4->Add( "FIRST", "Hello" );
mySL4->Add( "SECOND", "World" );
mySL4->Add( "THIRD", "!" );
try
{
mySL4->Add( "first", "Ola!" );
}
catch ( ArgumentException^ e )
{
Console::WriteLine( e );
}
PrintKeysAndValues( mySL4 );
}
/*
This code produces the following output. Results vary depending on the system's culture settings.
mySL1 (default):
Capacity is 6.
-KEY- -VALUE-
first : Ola!
FIRST : Hello
SECOND: World
THIRD : !
mySL2 (case-insensitive comparer):
System.ArgumentException: Item has already been added. Key in dictionary: 'FIRST' Key being added: 'first'
at System.Collections.SortedList.Add(Object key, Object value)
at SamplesSortedList.Main()
Capacity is 3.
-KEY- -VALUE-
FIRST : Hello
SECOND: World
THIRD : !
mySL3 (case-insensitive comparer, Turkish culture):
Capacity is 6.
-KEY- -VALUE-
FIRST : Hello
first : Ola!
SECOND: World
THIRD : !
mySL4 (InvariantCultureIgnoreCase):
System.ArgumentException: Item has already been added. Key in dictionary: 'FIRST' Key being added: 'first'
at System.Collections.SortedList.Add(Object key, Object value)
at SamplesSortedList.Main()
Capacity is 3.
-KEY- -VALUE-
FIRST : Hello
SECOND: World
THIRD : !
*/
using System;
using System.Collections;
using System.Globalization;
public class SamplesSortedList
{
public static void Main()
{
// Create a SortedList using the default comparer.
SortedList mySL1 = new SortedList( 3 );
Console.WriteLine("mySL1 (default):");
mySL1.Add("FIRST", "Hello");
mySL1.Add("SECOND", "World");
mySL1.Add("THIRD", "!");
try
{
mySL1.Add("first", "Ola!");
}
catch (ArgumentException e)
{
Console.WriteLine(e);
}
PrintKeysAndValues(mySL1);
// Create a SortedList using the specified case-insensitive comparer.
SortedList mySL2 = new SortedList(new CaseInsensitiveComparer(), 3);
Console.WriteLine("mySL2 (case-insensitive comparer):");
mySL2.Add("FIRST", "Hello");
mySL2.Add("SECOND", "World");
mySL2.Add("THIRD", "!");
try
{
mySL2.Add("first", "Ola!");
}
catch (ArgumentException e)
{
Console.WriteLine(e);
}
PrintKeysAndValues(mySL2);
// Create a SortedList using the specified CaseInsensitiveComparer,
// which is based on the Turkish culture (tr-TR), where "I" is not
// the uppercase version of "i".
CultureInfo myCul = new CultureInfo("tr-TR");
SortedList mySL3 =
new SortedList(new CaseInsensitiveComparer(myCul), 3);
Console.WriteLine(
"mySL3 (case-insensitive comparer, Turkish culture):");
mySL3.Add("FIRST", "Hello");
mySL3.Add("SECOND", "World");
mySL3.Add("THIRD", "!");
try
{
mySL3.Add("first", "Ola!");
}
catch (ArgumentException e)
{
Console.WriteLine(e);
}
PrintKeysAndValues(mySL3);
// Create a SortedList using the
// StringComparer.InvariantCultureIgnoreCase value.
SortedList mySL4 = new SortedList(
StringComparer.InvariantCultureIgnoreCase, 3);
Console.WriteLine("mySL4 (InvariantCultureIgnoreCase):");
mySL4.Add("FIRST", "Hello");
mySL4.Add("SECOND", "World");
mySL4.Add("THIRD", "!");
try
{
mySL4.Add("first", "Ola!");
}
catch (ArgumentException e)
{
Console.WriteLine(e);
}
PrintKeysAndValues(mySL4);
}
public static void PrintKeysAndValues(SortedList myList)
{
Console.WriteLine(" -KEY- -VALUE-");
for (int i = 0; i < myList.Count; i++)
{
Console.WriteLine(" {0,-6}: {1}",
myList.GetKey(i), myList.GetByIndex(i));
}
Console.WriteLine();
}
}
/*
This code produces the following output.
Results vary depending on the system's culture settings.
mySL1 (default):
-KEY- -VALUE-
first : Ola!
FIRST : Hello
SECOND: World
THIRD : !
mySL2 (case-insensitive comparer):
System.ArgumentException: Item has already been added. Key in dictionary: 'FIRST' Key being added: 'first'
at System.Collections.SortedList.Add(Object key, Object value)
at SamplesSortedList.Main()
-KEY- -VALUE-
FIRST : Hello
SECOND: World
THIRD : !
mySL3 (case-insensitive comparer, Turkish culture):
-KEY- -VALUE-
FIRST : Hello
first : Ola!
SECOND: World
THIRD : !
mySL4 (InvariantCultureIgnoreCase):
System.ArgumentException: Item has already been added. Key in dictionary: 'FIRST' Key being added: 'first'
at System.Collections.SortedList.Add(Object key, Object value)
at SamplesSortedList.Main()
-KEY- -VALUE-
FIRST : Hello
SECOND: World
THIRD : !
*/
Imports System.Collections
Imports System.Globalization
Public Class SamplesSortedList
Public Shared Sub Main()
' Create a SortedList using the default comparer.
Dim mySL1 As New SortedList( 3 )
Console.WriteLine("mySL1 (default):")
mySL1.Add("FIRST", "Hello")
mySL1.Add("SECOND", "World")
mySL1.Add("THIRD", "!")
Try
mySL1.Add("first", "Ola!")
Catch e As ArgumentException
Console.WriteLine(e)
End Try
PrintKeysAndValues(mySL1)
' Create a SortedList using the specified case-insensitive comparer.
Dim mySL2 As New SortedList(New CaseInsensitiveComparer(), 3)
Console.WriteLine("mySL2 (case-insensitive comparer):")
mySL2.Add("FIRST", "Hello")
mySL2.Add("SECOND", "World")
mySL2.Add("THIRD", "!")
Try
mySL2.Add("first", "Ola!")
Catch e As ArgumentException
Console.WriteLine(e)
End Try
PrintKeysAndValues(mySL2)
' Create a SortedList using the specified CaseInsensitiveComparer,
' which is based on the Turkish culture (tr-TR), where "I" is not
' the uppercase version of "i".
Dim myCul As New CultureInfo("tr-TR")
Dim mySL3 As New SortedList(New CaseInsensitiveComparer(myCul), 3)
Console.WriteLine("mySL3 (case-insensitive comparer, Turkish culture):")
mySL3.Add("FIRST", "Hello")
mySL3.Add("SECOND", "World")
mySL3.Add("THIRD", "!")
Try
mySL3.Add("first", "Ola!")
Catch e As ArgumentException
Console.WriteLine(e)
End Try
PrintKeysAndValues(mySL3)
' Create a SortedList using the
' StringComparer.InvariantCultureIgnoreCase value.
Dim mySL4 As New SortedList( _
StringComparer.InvariantCultureIgnoreCase, 3)
Console.WriteLine("mySL4 (InvariantCultureIgnoreCase):")
mySL4.Add("FIRST", "Hello")
mySL4.Add("SECOND", "World")
mySL4.Add("THIRD", "!")
Try
mySL4.Add("first", "Ola!")
Catch e As ArgumentException
Console.WriteLine(e)
End Try
PrintKeysAndValues(mySL4)
End Sub
Public Shared Sub PrintKeysAndValues(ByVal myList As SortedList)
Console.WriteLine(" -KEY- -VALUE-")
Dim i As Integer
For i = 0 To myList.Count - 1
Console.WriteLine(" {0,-6}: {1}", _
myList.GetKey(i), myList.GetByIndex(i))
Next i
Console.WriteLine()
End Sub
End Class
'This code produces the following output. Results vary depending on the system's culture settings.
'
'mySL1 (default):
' -KEY- -VALUE-
' first : Ola!
' FIRST : Hello
' SECOND: World
' THIRD : !
'
'mySL2 (case-insensitive comparer):
'System.ArgumentException: Item has already been added. Key in dictionary: 'FIRST' Key being added: 'first'' at System.Collections.SortedList.Add(Object key, Object value)
' at SamplesSortedList.Main()
' -KEY- -VALUE-
' FIRST : Hello
' SECOND: World
' THIRD : !
'
'mySL3 (case-insensitive comparer, Turkish culture):
' -KEY- -VALUE-
' FIRST : Hello
' first : Ola!
' SECOND: World
' THIRD : !
'
'mySL4 (InvariantCultureIgnoreCase):
'System.ArgumentException: Item has already been added. Key in dictionary: 'FIRST' Key being added: 'first'' at System.Collections.SortedList.Add(Object key, Object value)
' at SamplesSortedList.Main()
' -KEY- -VALUE-
' FIRST : Hello
' SECOND: World
' THIRD : !
注解
每个密钥都必须实现 IComparable 接口,以便能够与对象中的每个其他键进行比较 SortedList 。Each key must implement the IComparable interface to be capable of comparisons with every other key in the SortedList object. 元素根据 IComparable 添加到中的每个键的实现进行排序 SortedList 。The elements are sorted according to the IComparable implementation of each key added to the SortedList.
对象的容量 SortedList 是可容纳的元素数 SortedList 。The capacity of a SortedList object is the number of elements that the SortedList can hold. 当向添加元素时 SortedList ,将根据需要通过重新分配内部数组来自动增加容量。As elements are added to a SortedList, the capacity is automatically increased as required by reallocating the internal array.
如果集合的大小可为估算值,则指定初始容量就无需在向对象添加元素时执行多个大小调整操作 SortedList 。If the size of the collection can be estimated, specifying the initial capacity eliminates the need to perform a number of resizing operations while adding elements to the SortedList object.
此构造函数是一个 O(n) 操作,其中 n 是 initialCapacity 。This constructor is an O(n) operation, where n is initialCapacity.
另请参阅
- IComparable
- Capacity
- 在集合中执行不区分区域性的字符串操作Performing Culture-Insensitive String Operations in Collections
适用于
SortedList(IComparer, Int32)
初始化 SortedList 类的新实例,该实例为空、具有指定的初始容量并根据指定的 IComparer 接口排序。Initializes a new instance of the SortedList class that is empty, has the specified initial capacity, and is sorted according to the specified IComparer interface.
public:
SortedList(System::Collections::IComparer ^ comparer, int capacity);
public SortedList (System.Collections.IComparer comparer, int capacity);
public SortedList (System.Collections.IComparer? comparer, int capacity);
new System.Collections.SortedList : System.Collections.IComparer * int -> System.Collections.SortedList
Public Sub New (comparer As IComparer, capacity As Integer)
参数
- comparer
- IComparer
在对键进行比较时使用的 IComparer 实现。The IComparer implementation to use when comparing keys.
- 或 --or-
null,使用每一个键的 IComparable 实现。null to use the IComparable implementation of each key.
- capacity
- Int32
SortedList 对象可包含的初始元素数。The initial number of elements that the SortedList object can contain.
例外
capacity 小于零。capacity is less than zero.
没有足够的可用内存来创建具有指定 capacity 的 SortedList 对象。There is not enough available memory to create a SortedList object with the specified capacity.
示例
下面的代码示例使用不同 SortedList 的构造函数创建集合,并演示集合行为中的差异。The following code example creates collections using different SortedList constructors and demonstrates the differences in the behavior of the collections.
// The following code example creates SortedList instances using different constructors
// and demonstrates the differences in the behavior of the SortedList instances.
using namespace System;
using namespace System::Collections;
using namespace System::Globalization;
void PrintKeysAndValues( SortedList^ myList )
{
Console::WriteLine( " Capacity is {0}.", myList->Capacity );
Console::WriteLine( " -KEY- -VALUE-" );
for ( int i = 0; i < myList->Count; i++ )
{
Console::WriteLine( " {0,-6}: {1}", myList->GetKey( i ), myList->GetByIndex( i ) );
}
Console::WriteLine();
}
int main()
{
// Create a SortedList using the default comparer.
SortedList^ mySL1 = gcnew SortedList( 3 );
Console::WriteLine( "mySL1 (default):" );
mySL1->Add( "FIRST", "Hello" );
mySL1->Add( "SECOND", "World" );
mySL1->Add( "THIRD", "!" );
try
{
mySL1->Add( "first", "Ola!" );
}
catch ( ArgumentException^ e )
{
Console::WriteLine( e );
}
PrintKeysAndValues( mySL1 );
// Create a SortedList using the specified case-insensitive comparer.
SortedList^ mySL2 = gcnew SortedList( gcnew CaseInsensitiveComparer,3 );
Console::WriteLine( "mySL2 (case-insensitive comparer):" );
mySL2->Add( "FIRST", "Hello" );
mySL2->Add( "SECOND", "World" );
mySL2->Add( "THIRD", "!" );
try
{
mySL2->Add( "first", "Ola!" );
}
catch ( ArgumentException^ e )
{
Console::WriteLine( e );
}
PrintKeysAndValues( mySL2 );
// Create a SortedList using the specified CaseInsensitiveComparer,
// which is based on the Turkish culture (tr-TR), where "I" is not
// the uppercase version of "i".
CultureInfo^ myCul = gcnew CultureInfo("tr-TR");
SortedList^ mySL3 = gcnew SortedList(gcnew CaseInsensitiveComparer(myCul), 3);
Console::WriteLine("mySL3 (case-insensitive comparer, Turkish culture):");
mySL3->Add("FIRST", "Hello");
mySL3->Add("SECOND", "World");
mySL3->Add("THIRD", "!");
try
{
mySL3->Add("first", "Ola!");
}
catch (ArgumentException^ e)
{
Console::WriteLine(e);
}
PrintKeysAndValues(mySL3);
// Create a SortedList using the
// StringComparer.InvariantCultureIgnoreCase value.
SortedList^ mySL4 = gcnew SortedList( StringComparer::InvariantCultureIgnoreCase, 3 );
Console::WriteLine( "mySL4 (InvariantCultureIgnoreCase):" );
mySL4->Add( "FIRST", "Hello" );
mySL4->Add( "SECOND", "World" );
mySL4->Add( "THIRD", "!" );
try
{
mySL4->Add( "first", "Ola!" );
}
catch ( ArgumentException^ e )
{
Console::WriteLine( e );
}
PrintKeysAndValues( mySL4 );
}
/*
This code produces the following output. Results vary depending on the system's culture settings.
mySL1 (default):
Capacity is 6.
-KEY- -VALUE-
first : Ola!
FIRST : Hello
SECOND: World
THIRD : !
mySL2 (case-insensitive comparer):
System.ArgumentException: Item has already been added. Key in dictionary: 'FIRST' Key being added: 'first'
at System.Collections.SortedList.Add(Object key, Object value)
at SamplesSortedList.Main()
Capacity is 3.
-KEY- -VALUE-
FIRST : Hello
SECOND: World
THIRD : !
mySL3 (case-insensitive comparer, Turkish culture):
Capacity is 6.
-KEY- -VALUE-
FIRST : Hello
first : Ola!
SECOND: World
THIRD : !
mySL4 (InvariantCultureIgnoreCase):
System.ArgumentException: Item has already been added. Key in dictionary: 'FIRST' Key being added: 'first'
at System.Collections.SortedList.Add(Object key, Object value)
at SamplesSortedList.Main()
Capacity is 3.
-KEY- -VALUE-
FIRST : Hello
SECOND: World
THIRD : !
*/
using System;
using System.Collections;
using System.Globalization;
public class SamplesSortedList
{
public static void Main()
{
// Create a SortedList using the default comparer.
SortedList mySL1 = new SortedList( 3 );
Console.WriteLine("mySL1 (default):");
mySL1.Add("FIRST", "Hello");
mySL1.Add("SECOND", "World");
mySL1.Add("THIRD", "!");
try
{
mySL1.Add("first", "Ola!");
}
catch (ArgumentException e)
{
Console.WriteLine(e);
}
PrintKeysAndValues(mySL1);
// Create a SortedList using the specified case-insensitive comparer.
SortedList mySL2 = new SortedList(new CaseInsensitiveComparer(), 3);
Console.WriteLine("mySL2 (case-insensitive comparer):");
mySL2.Add("FIRST", "Hello");
mySL2.Add("SECOND", "World");
mySL2.Add("THIRD", "!");
try
{
mySL2.Add("first", "Ola!");
}
catch (ArgumentException e)
{
Console.WriteLine(e);
}
PrintKeysAndValues(mySL2);
// Create a SortedList using the specified CaseInsensitiveComparer,
// which is based on the Turkish culture (tr-TR), where "I" is not
// the uppercase version of "i".
CultureInfo myCul = new CultureInfo("tr-TR");
SortedList mySL3 =
new SortedList(new CaseInsensitiveComparer(myCul), 3);
Console.WriteLine(
"mySL3 (case-insensitive comparer, Turkish culture):");
mySL3.Add("FIRST", "Hello");
mySL3.Add("SECOND", "World");
mySL3.Add("THIRD", "!");
try
{
mySL3.Add("first", "Ola!");
}
catch (ArgumentException e)
{
Console.WriteLine(e);
}
PrintKeysAndValues(mySL3);
// Create a SortedList using the
// StringComparer.InvariantCultureIgnoreCase value.
SortedList mySL4 = new SortedList(
StringComparer.InvariantCultureIgnoreCase, 3);
Console.WriteLine("mySL4 (InvariantCultureIgnoreCase):");
mySL4.Add("FIRST", "Hello");
mySL4.Add("SECOND", "World");
mySL4.Add("THIRD", "!");
try
{
mySL4.Add("first", "Ola!");
}
catch (ArgumentException e)
{
Console.WriteLine(e);
}
PrintKeysAndValues(mySL4);
}
public static void PrintKeysAndValues(SortedList myList)
{
Console.WriteLine(" -KEY- -VALUE-");
for (int i = 0; i < myList.Count; i++)
{
Console.WriteLine(" {0,-6}: {1}",
myList.GetKey(i), myList.GetByIndex(i));
}
Console.WriteLine();
}
}
/*
This code produces the following output.
Results vary depending on the system's culture settings.
mySL1 (default):
-KEY- -VALUE-
first : Ola!
FIRST : Hello
SECOND: World
THIRD : !
mySL2 (case-insensitive comparer):
System.ArgumentException: Item has already been added. Key in dictionary: 'FIRST' Key being added: 'first'
at System.Collections.SortedList.Add(Object key, Object value)
at SamplesSortedList.Main()
-KEY- -VALUE-
FIRST : Hello
SECOND: World
THIRD : !
mySL3 (case-insensitive comparer, Turkish culture):
-KEY- -VALUE-
FIRST : Hello
first : Ola!
SECOND: World
THIRD : !
mySL4 (InvariantCultureIgnoreCase):
System.ArgumentException: Item has already been added. Key in dictionary: 'FIRST' Key being added: 'first'
at System.Collections.SortedList.Add(Object key, Object value)
at SamplesSortedList.Main()
-KEY- -VALUE-
FIRST : Hello
SECOND: World
THIRD : !
*/
Imports System.Collections
Imports System.Globalization
Public Class SamplesSortedList
Public Shared Sub Main()
' Create a SortedList using the default comparer.
Dim mySL1 As New SortedList( 3 )
Console.WriteLine("mySL1 (default):")
mySL1.Add("FIRST", "Hello")
mySL1.Add("SECOND", "World")
mySL1.Add("THIRD", "!")
Try
mySL1.Add("first", "Ola!")
Catch e As ArgumentException
Console.WriteLine(e)
End Try
PrintKeysAndValues(mySL1)
' Create a SortedList using the specified case-insensitive comparer.
Dim mySL2 As New SortedList(New CaseInsensitiveComparer(), 3)
Console.WriteLine("mySL2 (case-insensitive comparer):")
mySL2.Add("FIRST", "Hello")
mySL2.Add("SECOND", "World")
mySL2.Add("THIRD", "!")
Try
mySL2.Add("first", "Ola!")
Catch e As ArgumentException
Console.WriteLine(e)
End Try
PrintKeysAndValues(mySL2)
' Create a SortedList using the specified CaseInsensitiveComparer,
' which is based on the Turkish culture (tr-TR), where "I" is not
' the uppercase version of "i".
Dim myCul As New CultureInfo("tr-TR")
Dim mySL3 As New SortedList(New CaseInsensitiveComparer(myCul), 3)
Console.WriteLine("mySL3 (case-insensitive comparer, Turkish culture):")
mySL3.Add("FIRST", "Hello")
mySL3.Add("SECOND", "World")
mySL3.Add("THIRD", "!")
Try
mySL3.Add("first", "Ola!")
Catch e As ArgumentException
Console.WriteLine(e)
End Try
PrintKeysAndValues(mySL3)
' Create a SortedList using the
' StringComparer.InvariantCultureIgnoreCase value.
Dim mySL4 As New SortedList( _
StringComparer.InvariantCultureIgnoreCase, 3)
Console.WriteLine("mySL4 (InvariantCultureIgnoreCase):")
mySL4.Add("FIRST", "Hello")
mySL4.Add("SECOND", "World")
mySL4.Add("THIRD", "!")
Try
mySL4.Add("first", "Ola!")
Catch e As ArgumentException
Console.WriteLine(e)
End Try
PrintKeysAndValues(mySL4)
End Sub
Public Shared Sub PrintKeysAndValues(ByVal myList As SortedList)
Console.WriteLine(" -KEY- -VALUE-")
Dim i As Integer
For i = 0 To myList.Count - 1
Console.WriteLine(" {0,-6}: {1}", _
myList.GetKey(i), myList.GetByIndex(i))
Next i
Console.WriteLine()
End Sub
End Class
'This code produces the following output. Results vary depending on the system's culture settings.
'
'mySL1 (default):
' -KEY- -VALUE-
' first : Ola!
' FIRST : Hello
' SECOND: World
' THIRD : !
'
'mySL2 (case-insensitive comparer):
'System.ArgumentException: Item has already been added. Key in dictionary: 'FIRST' Key being added: 'first'' at System.Collections.SortedList.Add(Object key, Object value)
' at SamplesSortedList.Main()
' -KEY- -VALUE-
' FIRST : Hello
' SECOND: World
' THIRD : !
'
'mySL3 (case-insensitive comparer, Turkish culture):
' -KEY- -VALUE-
' FIRST : Hello
' first : Ola!
' SECOND: World
' THIRD : !
'
'mySL4 (InvariantCultureIgnoreCase):
'System.ArgumentException: Item has already been added. Key in dictionary: 'FIRST' Key being added: 'first'' at System.Collections.SortedList.Add(Object key, Object value)
' at SamplesSortedList.Main()
' -KEY- -VALUE-
' FIRST : Hello
' SECOND: World
' THIRD : !
注解
元素根据指定的实现进行排序 IComparer 。The elements are sorted according to the specified IComparer implementation. 如果 comparer 参数为 null ,则 IComparable 使用每个键的实现; 因此,每个键都必须实现 IComparable 接口,以便能够与对象中的每个其他键进行比较 SortedList 。If the comparer parameter is null, the IComparable implementation of each key is used; therefore, each key must implement the IComparable interface to be capable of comparisons with every other key in the SortedList object.
对象的容量 SortedList 是可容纳的元素数 SortedList 。The capacity of a SortedList object is the number of elements that the SortedList can hold. 当向添加元素时 SortedList ,将根据需要通过重新分配内部数组来自动增加容量。As elements are added to a SortedList, the capacity is automatically increased as required by reallocating the internal array.
如果集合的大小可为估算值,则指定初始容量就无需在向对象添加元素时执行多个大小调整操作 SortedList 。If the size of the collection can be estimated, specifying the initial capacity eliminates the need to perform a number of resizing operations while adding elements to the SortedList object.
此构造函数是一个 O(n) 操作,其中 n 是 capacity 。This constructor is an O(n) operation, where n is capacity.
另请参阅
- IComparer
- IComparable
- Capacity
- 在集合中执行不区分区域性的字符串操作Performing Culture-Insensitive String Operations in Collections
适用于
SortedList(IDictionary, IComparer)
初始化 SortedList 类的新实例,该实例包含从指定字典复制的元素、具有与所复制的元素数相同的初始容量并根据指定的 IComparer 接口排序。Initializes a new instance of the SortedList class that contains elements copied from the specified dictionary, has the same initial capacity as the number of elements copied, and is sorted according to the specified IComparer interface.
public:
SortedList(System::Collections::IDictionary ^ d, System::Collections::IComparer ^ comparer);
public SortedList (System.Collections.IDictionary d, System.Collections.IComparer comparer);
public SortedList (System.Collections.IDictionary d, System.Collections.IComparer? comparer);
new System.Collections.SortedList : System.Collections.IDictionary * System.Collections.IComparer -> System.Collections.SortedList
Public Sub New (d As IDictionary, comparer As IComparer)
参数
要复制到新 IDictionary 对象的 SortedList 实现。The IDictionary implementation to copy to a new SortedList object.
- comparer
- IComparer
在对键进行比较时使用的 IComparer 实现。The IComparer implementation to use when comparing keys.
- 或 --or-
null,使用每一个键的 IComparable 实现。null to use the IComparable implementation of each key.
例外
d 为 null。d is null.
comparer 为 null,且 d 中的一个或多个元素未实现 IComparable 接口。comparer is null, and one or more elements in d do not implement the IComparable interface.
示例
下面的代码示例使用不同 SortedList 的构造函数创建集合,并演示集合行为中的差异。The following code example creates collections using different SortedList constructors and demonstrates the differences in the behavior of the collections.
using namespace System;
using namespace System::Collections;
using namespace System::Globalization;
void PrintKeysAndValues( SortedList^ myList )
{
Console::WriteLine( " -KEY- -VALUE-" );
for ( int i = 0; i < myList->Count; i++ )
{
Console::WriteLine( " {0,-6}: {1}", myList->GetKey( i ), myList->GetByIndex( i ) );
}
Console::WriteLine();
}
int main()
{
// Create the dictionary.
Hashtable^ myHT = gcnew Hashtable;
myHT->Add( "FIRST", "Hello" );
myHT->Add( "SECOND", "World" );
myHT->Add( "THIRD", "!" );
// Create a SortedList using the default comparer.
SortedList^ mySL1 = gcnew SortedList( myHT );
Console::WriteLine( "mySL1 (default):" );
try
{
mySL1->Add( "first", "Ola!" );
}
catch ( ArgumentException^ e )
{
Console::WriteLine( e );
}
PrintKeysAndValues( mySL1 );
// Create a SortedList using the specified case-insensitive comparer.
SortedList^ mySL2 = gcnew SortedList( myHT,gcnew CaseInsensitiveComparer );
Console::WriteLine( "mySL2 (case-insensitive comparer):" );
try
{
mySL2->Add( "first", "Ola!" );
}
catch ( ArgumentException^ e )
{
Console::WriteLine( e );
}
PrintKeysAndValues( mySL2 );
// Create a SortedList using the specified CaseInsensitiveComparer,
// which is based on the Turkish culture (tr-TR), where "I" is not
// the uppercase version of "i".
CultureInfo^ myCul = gcnew CultureInfo( "tr-TR" );
SortedList^ mySL3 = gcnew SortedList( myHT, gcnew CaseInsensitiveComparer( myCul ) );
Console::WriteLine( "mySL3 (case-insensitive comparer, Turkish culture):" );
try
{
mySL3->Add( "first", "Ola!" );
}
catch ( ArgumentException^ e )
{
Console::WriteLine( e );
}
PrintKeysAndValues( mySL3 );
// Create a SortedList using the ComparisonType.InvariantCultureIgnoreCase value.
SortedList^ mySL4 = gcnew SortedList( myHT, StringComparer::InvariantCultureIgnoreCase );
Console::WriteLine( "mySL4 (InvariantCultureIgnoreCase):" );
try
{
mySL4->Add( "first", "Ola!" );
}
catch ( ArgumentException^ e )
{
Console::WriteLine( e );
}
PrintKeysAndValues( mySL4 );
}
/*
This code produces the following output. Results vary depending on the system's culture settings.
mySL1 (default):
-KEY- -VALUE-
first : Ola!
FIRST : Hello
SECOND: World
THIRD : !
mySL2 (case-insensitive comparer):
System.ArgumentException: Item has already been added. Key in dictionary: 'FIRST' Key being added: 'first'
at System.Collections.SortedList.Add(Object key, Object value)
at SamplesSortedList.Main()
-KEY- -VALUE-
FIRST : Hello
SECOND: World
THIRD : !
mySL3 (case-insensitive comparer, Turkish culture):
-KEY- -VALUE-
FIRST : Hello
first : Ola!
SECOND: World
THIRD : !
mySL4 (InvariantCultureIgnoreCase):
System.ArgumentException: Item has already been added. Key in dictionary: 'FIRST' Key being added: 'first'
at System.Collections.SortedList.Add(Object key, Object value)
at SamplesSortedList.Main()
-KEY- -VALUE-
FIRST : Hello
SECOND: World
THIRD : !
*/
using System;
using System.Collections;
using System.Globalization;
public class SamplesSortedList
{
public static void Main()
{
// Create the dictionary.
Hashtable myHT = new Hashtable();
myHT.Add("FIRST", "Hello");
myHT.Add("SECOND", "World");
myHT.Add("THIRD", "!");
// Create a SortedList using the default comparer.
SortedList mySL1 = new SortedList(myHT);
Console.WriteLine("mySL1 (default):");
try
{
mySL1.Add("first", "Ola!");
}
catch (ArgumentException e)
{
Console.WriteLine(e);
}
PrintKeysAndValues(mySL1);
// Create a SortedList using the specified case-insensitive comparer.
SortedList mySL2 = new SortedList(myHT, new CaseInsensitiveComparer());
Console.WriteLine("mySL2 (case-insensitive comparer):");
try
{
mySL2.Add("first", "Ola!");
}
catch (ArgumentException e)
{
Console.WriteLine(e);
}
PrintKeysAndValues(mySL2);
// Create a SortedList using the specified CaseInsensitiveComparer,
// which is based on the Turkish culture (tr-TR), where "I" is not
// the uppercase version of "i".
CultureInfo myCul = new CultureInfo("tr-TR");
SortedList mySL3 = new SortedList(myHT, new CaseInsensitiveComparer(myCul));
Console.WriteLine("mySL3 (case-insensitive comparer, Turkish culture):");
try
{
mySL3.Add("first", "Ola!");
}
catch (ArgumentException e)
{
Console.WriteLine(e);
}
PrintKeysAndValues(mySL3);
// Create a SortedList using the
// StringComparer.InvariantCultureIgnoreCase value.
SortedList mySL4 = new SortedList(
myHT, StringComparer.InvariantCultureIgnoreCase);
Console.WriteLine("mySL4 (InvariantCultureIgnoreCase):");
try
{
mySL4.Add("first", "Ola!");
}
catch (ArgumentException e)
{
Console.WriteLine(e);
}
PrintKeysAndValues(mySL4);
}
public static void PrintKeysAndValues(SortedList myList)
{
Console.WriteLine(" -KEY- -VALUE-");
for (int i = 0; i < myList.Count; i++)
{
Console.WriteLine(" {0,-6}: {1}",
myList.GetKey(i), myList.GetByIndex(i));
}
Console.WriteLine();
}
}
/*
This code produces the following output. Results vary depending on the system's culture settings.
mySL1 (default):
-KEY- -VALUE-
first : Ola!
FIRST : Hello
SECOND: World
THIRD : !
mySL2 (case-insensitive comparer):
System.ArgumentException: Item has already been added. Key in dictionary: 'FIRST' Key being added: 'first'
at System.Collections.SortedList.Add(Object key, Object value)
at SamplesSortedList.Main()
-KEY- -VALUE-
FIRST : Hello
SECOND: World
THIRD : !
mySL3 (case-insensitive comparer, Turkish culture):
-KEY- -VALUE-
FIRST : Hello
first : Ola!
SECOND: World
THIRD : !
mySL4 (InvariantCultureIgnoreCase):
System.ArgumentException: Item has already been added. Key in dictionary: 'FIRST' Key being added: 'first'
at System.Collections.SortedList.Add(Object key, Object value)
at SamplesSortedList.Main()
-KEY- -VALUE-
FIRST : Hello
SECOND: World
THIRD : !
*/
Imports System.Collections
Imports System.Globalization
Public Class SamplesSortedList
Public Shared Sub Main()
' Create the dictionary.
Dim myHT As New Hashtable()
myHT.Add("FIRST", "Hello")
myHT.Add("SECOND", "World")
myHT.Add("THIRD", "!")
' Create a SortedList using the default comparer.
Dim mySL1 As New SortedList(myHT)
Console.WriteLine("mySL1 (default):")
Try
mySL1.Add("first", "Ola!")
Catch e As ArgumentException
Console.WriteLine(e)
End Try
PrintKeysAndValues(mySL1)
' Create a SortedList using the specified case-insensitive comparer.
Dim mySL2 As New SortedList(myHT, New CaseInsensitiveComparer())
Console.WriteLine("mySL2 (case-insensitive comparer):")
Try
mySL2.Add("first", "Ola!")
Catch e As ArgumentException
Console.WriteLine(e)
End Try
PrintKeysAndValues(mySL2)
' Create a SortedList using the specified CaseInsensitiveComparer,
' which is based on the Turkish culture (tr-TR), where "I" is not
' the uppercase version of "i".
Dim myCul As New CultureInfo("tr-TR")
Dim mySL3 As New SortedList(myHT, New CaseInsensitiveComparer(myCul))
Console.WriteLine("mySL3 (case-insensitive comparer, Turkish culture):")
Try
mySL3.Add("first", "Ola!")
Catch e As ArgumentException
Console.WriteLine(e)
End Try
PrintKeysAndValues(mySL3)
' Create a SortedList using the
' StringComparer.InvariantCultureIgnoreCase value.
Dim mySL4 As New SortedList(myHT, StringComparer.InvariantCultureIgnoreCase)
Console.WriteLine("mySL4 (InvariantCultureIgnoreCase):")
Try
mySL4.Add("first", "Ola!")
Catch e As ArgumentException
Console.WriteLine(e)
End Try
PrintKeysAndValues(mySL4)
End Sub
Public Shared Sub PrintKeysAndValues(ByVal myList As SortedList)
Console.WriteLine(" -KEY- -VALUE-")
Dim i As Integer
For i = 0 To myList.Count - 1
Console.WriteLine(" {0,-6}: {1}", _
myList.GetKey(i), myList.GetByIndex(i))
Next i
Console.WriteLine()
End Sub
End Class
'This code produces the following output. Results vary depending on the system's culture settings.
'
'mySL1 (default):
' -KEY- -VALUE-
' first : Ola!
' FIRST : Hello
' SECOND: World
' THIRD : !
'
'mySL2 (case-insensitive comparer):
'System.ArgumentException: Item has already been added. Key in dictionary: 'FIRST' Key being added: 'first'' at System.Collections.SortedList.Add(Object key, Object value)
' at SamplesSortedList.Main()
' -KEY- -VALUE-
' FIRST : Hello
' SECOND: World
' THIRD : !
'
'mySL3 (case-insensitive comparer, Turkish culture):
' -KEY- -VALUE-
' FIRST : Hello
' first : Ola!
' SECOND: World
' THIRD : !
'
'mySL4 (InvariantCultureIgnoreCase):
'System.ArgumentException: Item has already been added. Key in dictionary: 'FIRST' Key being added: 'first'' at System.Collections.SortedList.Add(Object key, Object value)
' at SamplesSortedList.Main()
' -KEY- -VALUE-
' FIRST : Hello
' SECOND: World
' THIRD : !
注解
元素根据指定的实现进行排序 IComparer 。The elements are sorted according to the specified IComparer implementation. 如果 comparer 参数为 null ,则 IComparable 使用每个键的实现; 因此,每个键都必须实现 IComparable 接口,以便能够与对象中的每个其他键进行比较 SortedList 。If the comparer parameter is null, the IComparable implementation of each key is used; therefore, each key must implement the IComparable interface to be capable of comparisons with every other key in the SortedList object.
Hashtable对象是 IDictionary 可传递到此构造函数的实现的示例。A Hashtable object is an example of an IDictionary implementation that can be passed to this constructor. 新的 SortedList 对象包含存储在中的密钥和值的副本 Hashtable 。The new SortedList object contains a copy of the keys and values stored in the Hashtable.
对象的容量 SortedList 是可容纳的元素数 SortedList 。The capacity of a SortedList object is the number of elements that the SortedList can hold. 当向添加元素时 SortedList ,将根据需要通过重新分配内部数组来自动增加容量。As elements are added to a SortedList, the capacity is automatically increased as required by reallocating the internal array.
如果集合的大小可为估算值,则指定初始容量就无需在向对象添加元素时执行多个大小调整操作 SortedList 。If the size of the collection can be estimated, specifying the initial capacity eliminates the need to perform a number of resizing operations while adding elements to the SortedList object.
此构造函数是一个 O(n) 操作,其中 n 是中的元素数 d 。This constructor is an O(n) operation, where n is the number of elements in d.
另请参阅
- IDictionary
- IComparer
- IComparable
- Hashtable
- Capacity
- 在集合中执行不区分区域性的字符串操作Performing Culture-Insensitive String Operations in Collections