# ArrayList.Sort Metoda

## Definicja

Sortuje elementy w ArrayList części lub .

## Przeciążenia

 Sort() Sortuje elementy w całości ArrayList. Sort(IComparer) Sortuje elementy w całości ArrayList przy użyciu określonego porównania. Sort(Int32, Int32, IComparer) Sortuje elementy w zakresie elementów ArrayList przy użyciu określonego porównania.

## Sort()

Sortuje elementy w całości ArrayList.

``````public:
virtual void Sort();``````
``public virtual void Sort ();``
``````abstract member Sort : unit -> unit
override this.Sort : unit -> unit``````
``Public Overridable Sub Sort ()``

#### Wyjątki

Element ArrayList jest tylko do odczytu.

W poniższym przykładzie kodu pokazano, jak sortować wartości w obiekcie ArrayList.

``````using namespace System;
using namespace System::Collections;
void PrintValues( IEnumerable^ myList );
int main()
{

// Creates and initializes a new ArrayList.
ArrayList^ myAL = gcnew ArrayList;

// Displays the values of the ArrayList.
Console::WriteLine( "The ArrayList initially contains the following values:" );
PrintValues( myAL );

// Sorts the values of the ArrayList.
myAL->Sort();

// Displays the values of the ArrayList.
Console::WriteLine( "After sorting:" );
PrintValues( myAL );
}

void PrintValues( IEnumerable^ myList )
{
IEnumerator^ myEnum = myList->GetEnumerator();
while ( myEnum->MoveNext() )
{
Object^ obj = safe_cast<Object^>(myEnum->Current);
Console::WriteLine( "   {0}", obj );
}

Console::WriteLine();
}

/*
This code produces the following output.

The ArrayList initially contains the following values:
The
quick
brown
fox
jumps
over
the
lazy
dog

After sorting:
brown
dog
fox
jumps
lazy
over
quick
the
The
*/
``````
``````using System;
using System.Collections;

public class SamplesArrayList1
{
public static void Main()
{
// Creates and initializes a new ArrayList.
ArrayList myAL = new ArrayList();

// Displays the values of the ArrayList.
Console.WriteLine("The ArrayList initially contains the following values:");
PrintValues(myAL);

// Sorts the values of the ArrayList.
myAL.Sort();

// Displays the values of the ArrayList.
Console.WriteLine("After sorting:");
PrintValues(myAL);
}

public static void PrintValues(IEnumerable myList)
{
foreach (Object obj in myList)
Console.WriteLine("   {0}", obj);
Console.WriteLine();
}
}

/*
This code produces the following output.

The ArrayList initially contains the following values:
The
quick
brown
fox
jumps
over
the
lazy
dog

After sorting:
brown
dog
fox
jumps
lazy
over
quick
the
The
*/
``````
``````Imports System.Collections

Public Class SamplesArrayList

Public Shared Sub Main()

' Creates and initializes a new ArrayList.
Dim myAL As New ArrayList()

' Displays the values of the ArrayList.
Console.WriteLine("The ArrayList initially contains the following values:")
PrintValues(myAL)

' Sorts the values of the ArrayList.
myAL.Sort()

' Displays the values of the ArrayList.
Console.WriteLine("After sorting:")
PrintValues(myAL)

End Sub

Public Shared Sub PrintValues(myList As IEnumerable)
Dim obj As [Object]
For Each obj In  myList
Console.WriteLine("   {0}", obj)
Next obj
Console.WriteLine()
End Sub

End Class

' This code produces the following output.
'
' The ArrayList initially contains the following values:
'    The
'    quick
'    brown
'    fox
'    jumps
'    over
'    the
'    lazy
'    dog
'
' After sorting:
'    brown
'    dog
'    fox
'    jumps
'    lazy
'    over
'    quick
'    the
'    The
``````

### Uwagi

Ta metoda używa Array.Sortmetody , która używa algorytmu QuickSort. Algorytm QuickSort jest sortowaniem porównania (nazywanym również niestabilnym sortowaniem), co oznacza, że operacja porównania "mniejsza niż lub równa" określa, które z dwóch elementów należy najpierw wykonać na ostatniej posortowanej liście. Jeśli jednak dwa elementy są równe, ich oryginalna kolejność może nie zostać zachowana. Natomiast stabilne sortowanie zachowuje kolejność elementów, które są równe. Aby przeprowadzić stabilny sortowanie, należy zaimplementować interfejs niestandardowy IComparer do użycia z innymi przeciążeniami tej metody.

Średnio ta metoda jest operacją `O(n log n)` , gdzie `n` jest Count; w najgorszym przypadku jest `O(n^2)` to operacja.

## Sort(IComparer)

Sortuje elementy w całości ArrayList przy użyciu określonego porównania.

``````public:
virtual void Sort(System::Collections::IComparer ^ comparer);``````
``public virtual void Sort (System.Collections.IComparer comparer);``
``public virtual void Sort (System.Collections.IComparer? comparer);``
``````abstract member Sort : System.Collections.IComparer -> unit
override this.Sort : System.Collections.IComparer -> unit``````
``Public Overridable Sub Sort (comparer As IComparer)``

#### Parametry

comparer
IComparer

Implementacja IComparer do użycia podczas porównywania elementów.

-lub-

Odwołanie o wartości null (`Nothing` w Visual Basic) do korzystania z IComparable implementacji każdego elementu.

#### Wyjątki

Element ArrayList jest tylko do odczytu.

Wystąpił błąd podczas porównywania dwóch elementów.

`null` jest przekazywany dla `comparer`elementu , a elementy na liście nie implementują IComparableelementu .

W poniższym przykładzie kodu pokazano, jak sortować wartości przy użyciu domyślnego ArrayList porównania i niestandardowego porównywacza, który odwraca kolejność sortowania.

``````using namespace System;
using namespace System::Collections;
void PrintIndexAndValues( IEnumerable^ myList );
ref class myReverserClass: public IComparer
{
private:

// Calls CaseInsensitiveComparer.Compare with the parameters reversed.
virtual int Compare( Object^ x, Object^ y ) sealed = IComparer::Compare
{
return ((gcnew CaseInsensitiveComparer)->Compare( y, x ));
}

};

int main()
{

// Creates and initializes a new ArrayList.
ArrayList^ myAL = gcnew ArrayList;

// Displays the values of the ArrayList.
Console::WriteLine( "The ArrayList initially contains the following values:" );
PrintIndexAndValues( myAL );

// Sorts the values of the ArrayList using the default comparer.
myAL->Sort();
Console::WriteLine( "After sorting with the default comparer:" );
PrintIndexAndValues( myAL );

// Sorts the values of the ArrayList using the reverse case-insensitive comparer.
IComparer^ myComparer = gcnew myReverserClass;
myAL->Sort( myComparer );
Console::WriteLine( "After sorting with the reverse case-insensitive comparer:" );
PrintIndexAndValues( myAL );
}

void PrintIndexAndValues( IEnumerable^ myList )
{
int i = 0;
IEnumerator^ myEnum = myList->GetEnumerator();
while ( myEnum->MoveNext() )
{
Object^ obj = safe_cast<Object^>(myEnum->Current);
Console::WriteLine( "\t[{0}]:\t{1}", i++, obj );
}

Console::WriteLine();
}

/*
This code produces the following output.
The ArrayList initially contains the following values:
[0]:    The
[1]:    quick
[2]:    brown
[3]:    fox
[4]:    jumps
[5]:    over
[6]:    the
[7]:    lazy
[8]:    dog

After sorting with the default comparer:
[0]:    brown
[1]:    dog
[2]:    fox
[3]:    jumps
[4]:    lazy
[5]:    over
[6]:    quick
[7]:    the
[8]:    The

After sorting with the reverse case-insensitive comparer:
[0]:    the
[1]:    The
[2]:    quick
[3]:    over
[4]:    lazy
[5]:    jumps
[6]:    fox
[7]:    dog
[8]:    brown
*/
``````
``````using System;
using System.Collections;

public class SamplesArrayList2
{
public class myReverserClass : IComparer
{
// Calls CaseInsensitiveComparer.Compare with the parameters reversed.
int IComparer.Compare(Object x, Object y)
{
return ((new CaseInsensitiveComparer()).Compare(y, x));
}
}

public static void Main()
{
// Creates and initializes a new ArrayList.
ArrayList myAL = new ArrayList();

// Displays the values of the ArrayList.
Console.WriteLine("The ArrayList initially contains the following values:");
PrintIndexAndValues(myAL);

// Sorts the values of the ArrayList using the default comparer.
myAL.Sort();
Console.WriteLine("After sorting with the default comparer:");
PrintIndexAndValues(myAL);

// Sorts the values of the ArrayList using the reverse case-insensitive comparer.
IComparer myComparer = new myReverserClass();
myAL.Sort(myComparer);
Console.WriteLine("After sorting with the reverse case-insensitive comparer:");
PrintIndexAndValues(myAL);
}

public static void PrintIndexAndValues(IEnumerable myList)
{
int i = 0;
foreach (Object obj in myList)
Console.WriteLine("\t[{0}]:\t{1}", i++, obj);
Console.WriteLine();
}
}

/*
This code produces the following output.
The ArrayList initially contains the following values:
[0]:    The
[1]:    quick
[2]:    brown
[3]:    fox
[4]:    jumps
[5]:    over
[6]:    the
[7]:    lazy
[8]:    dog

After sorting with the default comparer:
[0]:    brown
[1]:    dog
[2]:    fox
[3]:    jumps
[4]:    lazy
[5]:    over
[6]:    quick
[7]:    the
[8]:    The

After sorting with the reverse case-insensitive comparer:
[0]:    the
[1]:    The
[2]:    quick
[3]:    over
[4]:    lazy
[5]:    jumps
[6]:    fox
[7]:    dog
[8]:    brown
*/
``````
``````Imports System.Collections

Public Class SamplesArrayList

Public Class myReverserClass
Implements IComparer

' Calls CaseInsensitiveComparer.Compare with the parameters reversed.
Public Function Compare( ByVal x As Object, ByVal y As Object) As Integer _
Implements IComparer.Compare
Return New CaseInsensitiveComparer().Compare(y, x)
End Function 'IComparer.Compare

End Class

Public Shared Sub Main()

' Creates and initializes a new ArrayList.
Dim myAL As New ArrayList()

' Displays the values of the ArrayList.
Console.WriteLine("The ArrayList initially contains the following values:")
PrintIndexAndValues(myAL)

' Sorts the values of the ArrayList using the default comparer.
myAL.Sort()
Console.WriteLine("After sorting with the default comparer:")
PrintIndexAndValues(myAL)

' Sorts the values of the ArrayList using the reverse case-insensitive comparer.
Dim myComparer = New myReverserClass()
myAL.Sort(myComparer)
Console.WriteLine("After sorting with the reverse case-insensitive comparer:")
PrintIndexAndValues(myAL)

End Sub

Public Shared Sub PrintIndexAndValues(myList As IEnumerable)
Dim i As Integer = 0
Dim obj As [Object]
For Each obj In  myList
Console.WriteLine(vbTab + "[{0}]:" + vbTab + "{1}", i, obj)
i = i + 1
Next obj
Console.WriteLine()
End Sub

End Class

'This code produces the following output.
'The ArrayList initially contains the following values:
'        [0]:    The
'        [1]:    quick
'        [2]:    brown
'        [3]:    fox
'        [4]:    jumps
'        [5]:    over
'        [6]:    the
'        [7]:    lazy
'        [8]:    dog
'
'After sorting with the default comparer:
'        [0]:    brown
'        [1]:    dog
'        [2]:    fox
'        [3]:    jumps
'        [4]:    lazy
'        [5]:    over
'        [6]:    quick
'        [7]:    the
'        [8]:    The
'
'After sorting with the reverse case-insensitive comparer:
'        [0]:    the
'        [1]:    The
'        [2]:    quick
'        [3]:    over
'        [4]:    lazy
'        [5]:    jumps
'        [6]:    fox
'        [7]:    dog
'        [8]:    brown
``````

### Uwagi

Sort Użyj metody , aby posortować listę obiektów za pomocą niestandardowego modułu IComparer porównującego, który implementuje interfejs. W przypadku przekazania `null` dla `comparer`metody ta metoda używa IComparable implementacji każdego elementu. W takim przypadku należy upewnić się, że obiekty zawarte na liście implementują IComparer interfejs lub wystąpi wyjątek.

Ponadto użycie implementacji IComparable oznacza, że lista wykonuje sortowanie porównania (nazywane również niestabilnym sortowaniem); oznacza to, że jeśli dwa elementy są równe, ich kolejność może nie zostać zachowana. Natomiast stabilne sortowanie zachowuje kolejność elementów, które są równe. Aby przeprowadzić stabilny sortowanie, należy zaimplementować interfejs niestandardowy IComparer .

Średnio ta metoda jest operacją `O(n log n)` , gdzie `n` jest Count; w najgorszym przypadku jest `O(n^2)` to operacja.

## Sort(Int32, Int32, IComparer)

Sortuje elementy w zakresie elementów ArrayList przy użyciu określonego porównania.

``````public:
virtual void Sort(int index, int count, System::Collections::IComparer ^ comparer);``````
``public virtual void Sort (int index, int count, System.Collections.IComparer comparer);``
``public virtual void Sort (int index, int count, System.Collections.IComparer? comparer);``
``````abstract member Sort : int * int * System.Collections.IComparer -> unit
override this.Sort : int * int * System.Collections.IComparer -> unit``````
``Public Overridable Sub Sort (index As Integer, count As Integer, comparer As IComparer)``

#### Parametry

index
Int32

Zerowy indeks początkowy zakresu do sortowania.

count
Int32

Długość zakresu do sortowania.

comparer
IComparer

Implementacja IComparer do użycia podczas porównywania elementów.

-lub-

Odwołanie o wartości null (`Nothing` w Visual Basic) do korzystania z IComparable implementacji każdego elementu.

#### Wyjątki

Parametr `index` ma wartość niższą niż zero.

-lub-

Parametr `count` ma wartość niższą niż zero.

`index` i `count` nie określają prawidłowego zakresu w elemecie ArrayList.

Element ArrayList jest tylko do odczytu.

Wystąpił błąd podczas porównywania dwóch elementów.

W poniższym przykładzie kodu pokazano, jak sortować wartości w zakresie elementów przy ArrayList użyciu domyślnego porównywacza i niestandardowego porównywacza, który odwraca kolejność sortowania.

``````using namespace System;
using namespace System::Collections;
void PrintIndexAndValues( IEnumerable^ myList );
ref class myReverserClass: public IComparer
{
private:

// Calls CaseInsensitiveComparer.Compare with the parameters reversed.
virtual int Compare( Object^ x, Object^ y ) = IComparer::Compare
{
return ((gcnew CaseInsensitiveComparer)->Compare( y, x ));
}

};

int main()
{

// Creates and initializes a new ArrayList.
ArrayList^ myAL = gcnew ArrayList;

// Displays the values of the ArrayList.
Console::WriteLine( "The ArrayList initially contains the following values:" );
PrintIndexAndValues( myAL );

// Sorts the values of the ArrayList using the default comparer.
myAL->Sort( 1, 3, nullptr );
Console::WriteLine( "After sorting from index 1 to index 3 with the default comparer:" );
PrintIndexAndValues( myAL );

// Sorts the values of the ArrayList using the reverse case-insensitive comparer.
IComparer^ myComparer = gcnew myReverserClass;
myAL->Sort( 1, 3, myComparer );
Console::WriteLine( "After sorting from index 1 to index 3 with the reverse case-insensitive comparer:" );
PrintIndexAndValues( myAL );
}

void PrintIndexAndValues( IEnumerable^ myList )
{
int i = 0;
IEnumerator^ myEnum = myList->GetEnumerator();
while ( myEnum->MoveNext() )
{
Object^ obj = safe_cast<Object^>(myEnum->Current);
Console::WriteLine( "\t[{0}]:\t{1}", i++, obj );
}

Console::WriteLine();
}

/*
This code produces the following output.
The ArrayList initially contains the following values:
[0]:    The
[1]:    QUICK
[2]:    BROWN
[3]:    FOX
[4]:    jumps
[5]:    over
[6]:    the
[7]:    lazy
[8]:    dog

After sorting from index 1 to index 3 with the default comparer:
[0]:    The
[1]:    BROWN
[2]:    FOX
[3]:    QUICK
[4]:    jumps
[5]:    over
[6]:    the
[7]:    lazy
[8]:    dog

After sorting from index 1 to index 3 with the reverse case-insensitive comparer:
[0]:    The
[1]:    QUICK
[2]:    FOX
[3]:    BROWN
[4]:    jumps
[5]:    over
[6]:    the
[7]:    lazy
[8]:    dog
*/
``````
``````using System;
using System.Collections;

public class SamplesArrayList3
{
public class myReverserClass : IComparer
{
// Calls CaseInsensitiveComparer.Compare with the parameters reversed.
int IComparer.Compare(Object x, Object y)
{
return ((new CaseInsensitiveComparer()).Compare(y, x));
}
}

public static void Main()
{
// Creates and initializes a new ArrayList.
ArrayList myAL = new ArrayList();

// Displays the values of the ArrayList.
Console.WriteLine("The ArrayList initially contains the following values:");
PrintIndexAndValues(myAL);

// Sorts the values of the ArrayList using the default comparer.
myAL.Sort(1, 3, null);
Console.WriteLine("After sorting from index 1 to index 3 with the default comparer:");
PrintIndexAndValues(myAL);

// Sorts the values of the ArrayList using the reverse case-insensitive comparer.
IComparer myComparer = new myReverserClass();
myAL.Sort(1, 3, myComparer);
Console.WriteLine("After sorting from index 1 to index 3 with the reverse case-insensitive comparer:");
PrintIndexAndValues(myAL);
}

public static void PrintIndexAndValues(IEnumerable myList)
{
int i = 0;
foreach (Object obj in myList)
Console.WriteLine("\t[{0}]:\t{1}", i++, obj);
Console.WriteLine();
}
}

/*
This code produces the following output.
The ArrayList initially contains the following values:
[0]:    The
[1]:    QUICK
[2]:    BROWN
[3]:    FOX
[4]:    jumps
[5]:    over
[6]:    the
[7]:    lazy
[8]:    dog

After sorting from index 1 to index 3 with the default comparer:
[0]:    The
[1]:    BROWN
[2]:    FOX
[3]:    QUICK
[4]:    jumps
[5]:    over
[6]:    the
[7]:    lazy
[8]:    dog

After sorting from index 1 to index 3 with the reverse case-insensitive comparer:
[0]:    The
[1]:    QUICK
[2]:    FOX
[3]:    BROWN
[4]:    jumps
[5]:    over
[6]:    the
[7]:    lazy
[8]:    dog
*/
``````
``````Imports System.Collections

Public Class SamplesArrayList

Public Class myReverserClass
Implements IComparer

' Calls CaseInsensitiveComparer.Compare with the parameters reversed.
Public Function Compare( ByVal x As Object, ByVal y As Object) As Integer _
Implements IComparer.Compare
Return New CaseInsensitiveComparer().Compare(y, x)
End Function 'IComparer.Compare

End Class

Public Shared Sub Main()

' Creates and initializes a new ArrayList.
Dim myAL As New ArrayList()

' Displays the values of the ArrayList.
Console.WriteLine("The ArrayList initially contains the following values:")
PrintIndexAndValues(myAL)

' Sorts the values of the ArrayList using the default comparer.
myAL.Sort(1, 3, Nothing)
Console.WriteLine("After sorting from index 1 to index 3 with the default comparer:")
PrintIndexAndValues(myAL)

' Sorts the values of the ArrayList using the reverse case-insensitive comparer.
Dim myComparer = New myReverserClass()
myAL.Sort(1, 3, myComparer)
Console.WriteLine("After sorting from index 1 to index 3 with the reverse case-insensitive comparer:")
PrintIndexAndValues(myAL)

End Sub

Public Shared Sub PrintIndexAndValues(myList As IEnumerable)
Dim i As Integer = 0
Dim obj As [Object]
For Each obj In  myList
Console.WriteLine(vbTab + "[{0}]:" + vbTab + "{1}", i, obj)
i = i + 1
Next obj
Console.WriteLine()
End Sub

End Class

'This code produces the following output.
'The ArrayList initially contains the following values:
'        [0]:    The
'        [1]:    QUICK
'        [2]:    BROWN
'        [3]:    FOX
'        [4]:    jumps
'        [5]:    over
'        [6]:    the
'        [7]:    lazy
'        [8]:    dog
'
'After sorting from index 1 to index 3 with the default comparer:
'        [0]:    The
'        [1]:    BROWN
'        [2]:    FOX
'        [3]:    QUICK
'        [4]:    jumps
'        [5]:    over
'        [6]:    the
'        [7]:    lazy
'        [8]:    dog
'
'After sorting from index 1 to index 3 with the reverse case-insensitive comparer:
'        [0]:    The
'        [1]:    QUICK
'        [2]:    FOX
'        [3]:    BROWN
'        [4]:    jumps
'        [5]:    over
'        [6]:    the
'        [7]:    lazy
'        [8]:    dog
``````

### Uwagi

Jeśli `comparer` jest ustawiona `null`na wartość , ta metoda wykonuje sortowanie porównania (nazywane również niestabilnym sortowaniem); oznacza to, że jeśli dwa elementy są równe, ich kolejność może nie zostać zachowana. Natomiast stabilne sortowanie zachowuje kolejność elementów, które są równe. Aby przeprowadzić stabilny sortowanie, należy zaimplementować interfejs niestandardowy IComparer .

Średnio ta metoda jest operacją `O(n log n)` , gdzie `n` jest `count`; w najgorszym przypadku jest `O(n^2)` to operacja.