通过

Arrays.Sort 方法

  • 参考

定义

命名空间:
Java.Util
程序集:
Mono.Android.dll

重载

Sort(Object[], Int32, Int32, IComparator)

根据指定的比较器引发的顺序对指定对象数组的指定范围进行排序。
Sort(Byte[], Int32, Int32)

将数组的指定范围排序为升序。
Sort(Single[], Int32, Int32)

将数组的指定范围排序为升序。
Sort(Int64[], Int32, Int32)

将数组的指定范围排序为升序。
Sort(Int32[], Int32, Int32)

将数组的指定范围排序为升序。
Sort(Int16[], Int32, Int32)

将数组的指定范围排序为升序。
Sort(Double[], Int32, Int32)

将数组的指定范围排序为升序。
Sort(Char[], Int32, Int32)

将数组的指定范围排序为升序。
Sort(Object[], Int32, Int32)

根据其元素的“可比自然顺序”，将指定对象数组的指定范围排序为升序。
Sort(Single[])

将指定的数组排序为升序数字顺序。
Sort(Int64[])

将指定的数组排序为升序数字顺序。
Sort(Int32[])

将指定的数组排序为升序数字顺序。
Sort(Int16[])

将指定的数组排序为升序数字顺序。
Sort(Double[])

将指定的数组排序为升序数字顺序。
Sort(Char[])

将指定的数组排序为升序数字顺序。
Sort(Byte[])

将指定的数组排序为升序数字顺序。
Sort(Object[])

根据其元素的“可比自然顺序”，将指定的对象数组排序为升序。
Sort(Object[], IComparator)

根据指定的比较器引发的顺序对指定的对象数组进行排序。

Sort(Object[], Int32, Int32, IComparator)

根据指定的比较器引发的顺序对指定对象数组的指定范围进行排序。

[Android.Runtime.Register("sort", "([Ljava/lang/Object;IILjava/util/Comparator;)V", "")]
[Java.Interop.JavaTypeParameters(new System.String[] { "T" })]
public static void Sort (Java.Lang.Object[] a, int fromIndex, int toIndex, Java.Util.IComparator? c);
[<Android.Runtime.Register("sort", "([Ljava/lang/Object;IILjava/util/Comparator;)V", "")>]
[<Java.Interop.JavaTypeParameters(new System.String[] { "T" })>]
static member Sort : Java.Lang.Object[] * int * int * Java.Util.IComparator -> unit

参数

a
Object[]

要排序的数组

fromIndex
Int32

要排序的第一个元素（非独占）的索引

toIndex
Int32

要排序的最后一个元素（独占）的索引

c
IComparator

用于确定数组顺序的比较器。 一个 null 值指示应使用元素的可比较自然排序。

属性
RegisterAttribute JavaTypeParametersAttribute

注解

根据指定的比较器引发的顺序对指定对象数组的指定范围进行排序。 要排序的范围从索引 fromIndex（非独占）扩展到索引 toIndex（独占）。 （如果fromIndex==toIndex，要排序的范围为空。范围中的所有元素都必须由指定的比较器相互比较（也就是说，c.compare(e1, e2)不得为任何元素e1和e2范围引发）。ClassCastException

这种排序保证是 稳定的：由于排序的结果，不会对等元素重新排序。

实现说明：此实现是一种稳定的自适应迭代合并器，在部分排序输入数组时需要比 n lg（n） 比较少得多，同时在随机排序输入数组时提供传统合并器的性能。 如果输入数组几乎已排序，则实现需要大约 n 个比较。 临时存储要求因几乎排序的输入数组的小型常量而异，对于随机排序的输入数组，为 n/2 对象引用。

实现利用其输入数组中的升序和降序，并可以利用同一输入数组的不同部分的升序和降序。 它非常适合合并两个或多个已排序数组：只需连接数组并对生成的数组进行排序。

该实现改编自 Tim Peters 的 Python 列表排序（ TimSort）。 它在1993年1月第四届ACM-SIAM离散算法研讨会的《第四届 ACM-SIAM 研讨会》中使用了彼得·麦基尔罗伊的“乐观排序和信息理论复杂性”的技术。

适用于 . 的 java.util.Arrays.sort(T[], int, int, java.util.Comparator<? super T>)Java 文档

本页的某些部分是根据 Android 开放源代码项目创建和共享的工作进行的修改，并根据 Creative Commons 2.5 属性许可证中所述的术语使用。

适用于

Sort(Byte[], Int32, Int32)

将数组的指定范围排序为升序。

[Android.Runtime.Register("sort", "([BII)V", "")]
public static void Sort (byte[] a, int fromIndex, int toIndex);
[<Android.Runtime.Register("sort", "([BII)V", "")>]
static member Sort : byte[] * int * int -> unit

参数

a
Byte[]

要排序的数组

fromIndex
Int32

要排序的第一个元素的索引（含）

toIndex
Int32

要排序的最后一个元素的索引（独占）

属性
RegisterAttribute

例外

IllegalArgumentException

如果 start > end。

ArrayIndexOutOfBoundsException

if start 或 end > array.length.

注解

将数组的指定范围排序为升序。 要排序的范围从索引 fromIndex（非独占）扩展到索引 toIndex（独占）。 如果 fromIndex == toIndex为空，则要排序的范围为空。

适用于 . 的 java.util.Arrays.sort(byte[], int, int)Java 文档

本页的某些部分是根据 Android 开放源代码项目创建和共享的工作进行的修改，并根据 Creative Commons 2.5 属性许可证中所述的术语使用。

适用于

Sort(Single[], Int32, Int32)

将数组的指定范围排序为升序。

[Android.Runtime.Register("sort", "([FII)V", "")]
public static void Sort (float[] a, int fromIndex, int toIndex);
[<Android.Runtime.Register("sort", "([FII)V", "")>]
static member Sort : single[] * int * int -> unit

参数

a
Single[]

要排序的数组

fromIndex
Int32

要排序的第一个元素的索引（含）

toIndex
Int32

要排序的最后一个元素的索引（独占）

属性
RegisterAttribute

例外

IllegalArgumentException

如果 start > end。

ArrayIndexOutOfBoundsException

if start 或 end > array.length.

注解

将数组的指定范围排序为升序。 要排序的范围从索引 fromIndex（非独占）扩展到索引 toIndex（独占）。 如果 fromIndex == toIndex为空，则要排序的范围为空。

该 < 关系不为所有浮点值提供总顺序： -0.0f == 0.0f 是 true 值 Float.NaN 不小于、大于或等于任何值，甚至不等于任何值。 此方法使用该方法Float#compareTo施加的总顺序：-0.0f被视为小于值，Float.NaN被视为大于任何其他值0.0f，并且所有Float.NaN值被视为相等。

适用于 . 的 java.util.Arrays.sort(float[], int, int)Java 文档

本页的某些部分是根据 Android 开放源代码项目创建和共享的工作进行的修改，并根据 Creative Commons 2.5 属性许可证中所述的术语使用。

另请参阅

适用于

Sort(Int64[], Int32, Int32)

将数组的指定范围排序为升序。

[Android.Runtime.Register("sort", "([JII)V", "")]
public static void Sort (long[] a, int fromIndex, int toIndex);
[<Android.Runtime.Register("sort", "([JII)V", "")>]
static member Sort : int64[] * int * int -> unit

参数

a
Int64[]

要排序的数组

fromIndex
Int32

要排序的第一个元素的索引（含）

toIndex
Int32

要排序的最后一个元素的索引（独占）

属性
RegisterAttribute

例外

IllegalArgumentException

如果 start > end。

ArrayIndexOutOfBoundsException

if start 或 end > array.length.

注解

将数组的指定范围排序为升序。 要排序的范围从索引 fromIndex（非独占）扩展到索引 toIndex（独占）。 如果 fromIndex == toIndex为空，则要排序的范围为空。

适用于 . 的 java.util.Arrays.sort(long[], int, int)Java 文档

本页的某些部分是根据 Android 开放源代码项目创建和共享的工作进行的修改，并根据 Creative Commons 2.5 属性许可证中所述的术语使用。

适用于

Sort(Int32[], Int32, Int32)

将数组的指定范围排序为升序。

[Android.Runtime.Register("sort", "([III)V", "")]
public static void Sort (int[] a, int fromIndex, int toIndex);
[<Android.Runtime.Register("sort", "([III)V", "")>]
static member Sort : int[] * int * int -> unit

参数

a
Int32[]

要排序的数组

fromIndex
Int32

要排序的第一个元素的索引（含）

toIndex
Int32

要排序的最后一个元素的索引（独占）

属性
RegisterAttribute

例外

IllegalArgumentException

如果 start > end。

ArrayIndexOutOfBoundsException

if start 或 end > array.length.

注解

将数组的指定范围排序为升序。 要排序的范围从索引 fromIndex（非独占）扩展到索引 toIndex（独占）。 如果 fromIndex == toIndex为空，则要排序的范围为空。

适用于 . 的 java.util.Arrays.sort(int[], int, int)Java 文档

本页的某些部分是根据 Android 开放源代码项目创建和共享的工作进行的修改，并根据 Creative Commons 2.5 属性许可证中所述的术语使用。

适用于

Sort(Int16[], Int32, Int32)

将数组的指定范围排序为升序。

[Android.Runtime.Register("sort", "([SII)V", "")]
public static void Sort (short[] a, int fromIndex, int toIndex);
[<Android.Runtime.Register("sort", "([SII)V", "")>]
static member Sort : int16[] * int * int -> unit

参数

a
Int16[]

要排序的数组

fromIndex
Int32

要排序的第一个元素的索引（含）

toIndex
Int32

要排序的最后一个元素的索引（独占）

属性
RegisterAttribute

例外

IllegalArgumentException

如果 start > end。

ArrayIndexOutOfBoundsException

if start 或 end > array.length.

注解

将数组的指定范围排序为升序。 要排序的范围从索引 fromIndex（非独占）扩展到索引 toIndex（独占）。 如果 fromIndex == toIndex为空，则要排序的范围为空。

适用于 . 的 java.util.Arrays.sort(short[], int, int)Java 文档

本页的某些部分是根据 Android 开放源代码项目创建和共享的工作进行的修改，并根据 Creative Commons 2.5 属性许可证中所述的术语使用。

适用于

Sort(Double[], Int32, Int32)

将数组的指定范围排序为升序。

[Android.Runtime.Register("sort", "([DII)V", "")]
public static void Sort (double[] a, int fromIndex, int toIndex);
[<Android.Runtime.Register("sort", "([DII)V", "")>]
static member Sort : double[] * int * int -> unit

参数

a
Double[]

要排序的数组

fromIndex
Int32

要排序的第一个元素的索引（含）

toIndex
Int32

要排序的最后一个元素的索引（独占）

属性
RegisterAttribute

例外

IllegalArgumentException

如果 start > end。

ArrayIndexOutOfBoundsException

if start 或 end > array.length.

注解

将数组的指定范围排序为升序。 要排序的范围从索引 fromIndex（非独占）扩展到索引 toIndex（独占）。 如果 fromIndex == toIndex为空，则要排序的范围为空。

关系 < 不对所有双精度值提供总顺序： -0.0d == 0.0d 是 true 值 Double.NaN 不小于、大于或等于任何值，甚至不等于任何值。 此方法使用该方法Double#compareTo施加的总顺序：-0.0d被视为小于值，Double.NaN被视为大于任何其他值0.0d，并且所有Double.NaN值被视为相等。

适用于 . 的 java.util.Arrays.sort(double[], int, int)Java 文档

本页的某些部分是根据 Android 开放源代码项目创建和共享的工作进行的修改，并根据 Creative Commons 2.5 属性许可证中所述的术语使用。

另请参阅

适用于

Sort(Char[], Int32, Int32)

将数组的指定范围排序为升序。

[Android.Runtime.Register("sort", "([CII)V", "")]
public static void Sort (char[] a, int fromIndex, int toIndex);
[<Android.Runtime.Register("sort", "([CII)V", "")>]
static member Sort : char[] * int * int -> unit

参数

a
Char[]

要排序的数组

fromIndex
Int32

要排序的第一个元素的索引（含）

toIndex
Int32

要排序的最后一个元素的索引（独占）

属性
RegisterAttribute

例外

IllegalArgumentException

如果 start > end。

ArrayIndexOutOfBoundsException

if start 或 end > array.length.

注解

将数组的指定范围排序为升序。 要排序的范围从索引 fromIndex（非独占）扩展到索引 toIndex（独占）。 如果 fromIndex == toIndex为空，则要排序的范围为空。

适用于 . 的 java.util.Arrays.sort(char[], int, int)Java 文档

本页的某些部分是根据 Android 开放源代码项目创建和共享的工作进行的修改，并根据 Creative Commons 2.5 属性许可证中所述的术语使用。

适用于

Sort(Object[], Int32, Int32)

根据其元素的“可比自然顺序”，将指定对象数组的指定范围排序为升序。

[Android.Runtime.Register("sort", "([Ljava/lang/Object;II)V", "")]
public static void Sort (Java.Lang.Object[] a, int fromIndex, int toIndex);
[<Android.Runtime.Register("sort", "([Ljava/lang/Object;II)V", "")>]
static member Sort : Java.Lang.Object[] * int * int -> unit

参数

a
Object[]

要排序的数组

fromIndex
Int32

要排序的第一个元素（非独占）的索引

toIndex
Int32

要排序的最后一个元素（独占）的索引

属性
RegisterAttribute

例外

ClassCastException

如果任何元素未实现 Comparable，或者为任意一对元素引发，则为 compareTo 。

IllegalArgumentException

如果 start > end。

ArrayIndexOutOfBoundsException

if start 或 end > array.length.

注解

根据其元素的“可比自然顺序”，将指定对象数组的指定范围排序为升序。 要排序的范围从索引 fromIndex（非独占）扩展到索引 toIndex（独占）。 （如果 fromIndex==toIndex，要排序的范围为空。此范围中的所有元素都必须实现 Comparable 接口。 此外，此范围中的所有元素都必须相互比较（也就是说，e1.compareTo(e2)不得为任何元素e1和e2数组引发）。ClassCastException

这种排序保证是 稳定的：由于排序的结果，不会对等元素重新排序。

实现说明：此实现是一种稳定的自适应迭代合并器，在部分排序输入数组时需要比 n lg（n） 比较少得多，同时在随机排序输入数组时提供传统合并器的性能。 如果输入数组几乎已排序，则实现需要大约 n 个比较。 临时存储要求因几乎排序的输入数组的小型常量而异，对于随机排序的输入数组，为 n/2 对象引用。

实现利用其输入数组中的升序和降序，并可以利用同一输入数组的不同部分的升序和降序。 它非常适合合并两个或多个已排序数组：只需连接数组并对生成的数组进行排序。

该实现改编自 Tim Peters 的 Python 列表排序（ TimSort）。 它在1993年1月第四届ACM-SIAM离散算法研讨会的《第四届 ACM-SIAM 研讨会》中使用了彼得·麦基尔罗伊的“乐观排序和信息理论复杂性”的技术。

适用于 . 的 java.util.Arrays.sort(java.lang.Object[], int, int)Java 文档

本页的某些部分是根据 Android 开放源代码项目创建和共享的工作进行的修改，并根据 Creative Commons 2.5 属性许可证中所述的术语使用。

适用于

Sort(Single[])

将指定的数组排序为升序数字顺序。

[Android.Runtime.Register("sort", "([F)V", "")]
public static void Sort (float[] a);
[<Android.Runtime.Register("sort", "([F)V", "")>]
static member Sort : single[] -> unit

参数

a
Single[]

要排序的数组

属性
RegisterAttribute

注解

将指定的数组排序为升序数字顺序。

该 < 关系不为所有浮点值提供总顺序： -0.0f == 0.0f 是 true 值 Float.NaN 不小于、大于或等于任何值，甚至不等于任何值。 此方法使用该方法Float#compareTo施加的总顺序：-0.0f被视为小于值，Float.NaN被视为大于任何其他值0.0f，并且所有Float.NaN值被视为相等。

适用于 . 的 java.util.Arrays.sort(float[])Java 文档

本页的某些部分是根据 Android 开放源代码项目创建和共享的工作进行的修改，并根据 Creative Commons 2.5 属性许可证中所述的术语使用。

另请参阅

  • <xref:Java.Util.Arrays.Sort(System.Single%5b%5d%2c+System.Int32%2c+System.Int32)>

适用于

Sort(Int64[])

将指定的数组排序为升序数字顺序。

[Android.Runtime.Register("sort", "([J)V", "")]
public static void Sort (long[] a);
[<Android.Runtime.Register("sort", "([J)V", "")>]
static member Sort : int64[] -> unit

参数

a
Int64[]

要排序的数组

属性
RegisterAttribute

注解

将指定的数组排序为升序数字顺序。

适用于 . 的 java.util.Arrays.sort(long[])Java 文档

本页的某些部分是根据 Android 开放源代码项目创建和共享的工作进行的修改，并根据 Creative Commons 2.5 属性许可证中所述的术语使用。

适用于

Sort(Int32[])

将指定的数组排序为升序数字顺序。

[Android.Runtime.Register("sort", "([I)V", "")]
public static void Sort (int[] a);
[<Android.Runtime.Register("sort", "([I)V", "")>]
static member Sort : int[] -> unit

参数

a
Int32[]

要排序的数组

属性
RegisterAttribute

注解

将指定的数组排序为升序数字顺序。

适用于 . 的 java.util.Arrays.sort(int[])Java 文档

本页的某些部分是根据 Android 开放源代码项目创建和共享的工作进行的修改，并根据 Creative Commons 2.5 属性许可证中所述的术语使用。

适用于

Sort(Int16[])

将指定的数组排序为升序数字顺序。

[Android.Runtime.Register("sort", "([S)V", "")]
public static void Sort (short[] a);
[<Android.Runtime.Register("sort", "([S)V", "")>]
static member Sort : int16[] -> unit

参数

a
Int16[]

要排序的数组

属性
RegisterAttribute

注解

将指定的数组排序为升序数字顺序。

适用于 . 的 java.util.Arrays.sort(short[])Java 文档

本页的某些部分是根据 Android 开放源代码项目创建和共享的工作进行的修改，并根据 Creative Commons 2.5 属性许可证中所述的术语使用。

适用于

Sort(Double[])

将指定的数组排序为升序数字顺序。

[Android.Runtime.Register("sort", "([D)V", "")]
public static void Sort (double[] a);
[<Android.Runtime.Register("sort", "([D)V", "")>]
static member Sort : double[] -> unit

参数

a
Double[]

要排序的数组

属性
RegisterAttribute

注解

将指定的数组排序为升序数字顺序。

关系 < 不对所有双精度值提供总顺序： -0.0d == 0.0d 是 true 值 Double.NaN 不小于、大于或等于任何值，甚至不等于任何值。 此方法使用该方法Double#compareTo施加的总顺序：-0.0d被视为小于值，Double.NaN被视为大于任何其他值0.0d，并且所有Double.NaN值被视为相等。

适用于 . 的 java.util.Arrays.sort(double[])Java 文档

本页的某些部分是根据 Android 开放源代码项目创建和共享的工作进行的修改，并根据 Creative Commons 2.5 属性许可证中所述的术语使用。

另请参阅

  • <xref:Java.Util.Arrays.Sort(System.Double%5b%5d%2c+System.Int32%2c+System.Int32)>

适用于

Sort(Char[])

将指定的数组排序为升序数字顺序。

[Android.Runtime.Register("sort", "([C)V", "")]
public static void Sort (char[] a);
[<Android.Runtime.Register("sort", "([C)V", "")>]
static member Sort : char[] -> unit

参数

a
Char[]

要排序的数组

属性
RegisterAttribute

注解

将指定的数组排序为升序数字顺序。

适用于 . 的 java.util.Arrays.sort(char[])Java 文档

本页的某些部分是根据 Android 开放源代码项目创建和共享的工作进行的修改，并根据 Creative Commons 2.5 属性许可证中所述的术语使用。

适用于

Sort(Byte[])

将指定的数组排序为升序数字顺序。

[Android.Runtime.Register("sort", "([B)V", "")]
public static void Sort (byte[] a);
[<Android.Runtime.Register("sort", "([B)V", "")>]
static member Sort : byte[] -> unit

参数

a
Byte[]

要排序的数组

属性
RegisterAttribute

注解

将指定的数组排序为升序数字顺序。

适用于 . 的 java.util.Arrays.sort(byte[])Java 文档

本页的某些部分是根据 Android 开放源代码项目创建和共享的工作进行的修改，并根据 Creative Commons 2.5 属性许可证中所述的术语使用。

适用于

Sort(Object[])

根据其元素的“可比自然顺序”，将指定的对象数组排序为升序。

[Android.Runtime.Register("sort", "([Ljava/lang/Object;)V", "")]
public static void Sort (Java.Lang.Object[] a);
[<Android.Runtime.Register("sort", "([Ljava/lang/Object;)V", "")>]
static member Sort : Java.Lang.Object[] -> unit

参数

a
Object[]

要排序的数组

属性
RegisterAttribute

例外

ClassCastException

如果任何元素未实现 Comparable，或者为任意一对元素引发，则为 compareTo 。

注解

根据其元素的“可比自然顺序”，将指定的对象数组排序为升序。 数组中的所有元素都必须实现 Comparable 接口。 此外，数组中的所有元素必须相互比较（也就是说，e1.compareTo(e2)不得为任何元素e1和e2数组引发）。ClassCastException

这种排序保证是 稳定的：由于排序的结果，不会对等元素重新排序。

实现说明：此实现是一种稳定的自适应迭代合并器，在部分排序输入数组时需要比 n lg（n） 比较少得多，同时在随机排序输入数组时提供传统合并器的性能。 如果输入数组几乎已排序，则实现需要大约 n 个比较。 临时存储要求因几乎排序的输入数组的小型常量而异，对于随机排序的输入数组，为 n/2 对象引用。

实现利用其输入数组中的升序和降序，并可以利用同一输入数组的不同部分的升序和降序。 它非常适合合并两个或多个已排序数组：只需连接数组并对生成的数组进行排序。

该实现改编自 Tim Peters 的 Python 列表排序（ TimSort）。 它在1993年1月第四届ACM-SIAM离散算法研讨会的《第四届 ACM-SIAM 研讨会》中使用了彼得·麦基尔罗伊的“乐观排序和信息理论复杂性”的技术。

适用于 . 的 java.util.Arrays.sort(java.lang.Object[])Java 文档

本页的某些部分是根据 Android 开放源代码项目创建和共享的工作进行的修改，并根据 Creative Commons 2.5 属性许可证中所述的术语使用。

适用于

Sort(Object[], IComparator)

根据指定的比较器引发的顺序对指定的对象数组进行排序。

[Android.Runtime.Register("sort", "([Ljava/lang/Object;Ljava/util/Comparator;)V", "")]
[Java.Interop.JavaTypeParameters(new System.String[] { "T" })]
public static void Sort (Java.Lang.Object[] a, Java.Util.IComparator? c);
[<Android.Runtime.Register("sort", "([Ljava/lang/Object;Ljava/util/Comparator;)V", "")>]
[<Java.Interop.JavaTypeParameters(new System.String[] { "T" })>]
static member Sort : Java.Lang.Object[] * Java.Util.IComparator -> unit

参数

a
Object[]

要排序的数组

c
IComparator

用于确定数组顺序的比较器。 一个 null 值指示应使用元素的可比较自然排序。

属性
RegisterAttribute JavaTypeParametersAttribute

注解

根据指定的比较器引发的顺序对指定的对象数组进行排序。 数组中的所有元素都必须由指定的比较器相互比较（也就是说，c.compare(e1, e2)不得为任何元素e1和e2数组引发）。ClassCastException

这种排序保证是 稳定的：由于排序的结果，不会对等元素重新排序。

实现说明：此实现是一种稳定的自适应迭代合并器，在部分排序输入数组时需要比 n lg（n） 比较少得多，同时在随机排序输入数组时提供传统合并器的性能。 如果输入数组几乎已排序，则实现需要大约 n 个比较。 临时存储要求因几乎排序的输入数组的小型常量而异，对于随机排序的输入数组，为 n/2 对象引用。

实现利用其输入数组中的升序和降序，并可以利用同一输入数组的不同部分的升序和降序。 它非常适合合并两个或多个已排序数组：只需连接数组并对生成的数组进行排序。

该实现改编自 Tim Peters 的 Python 列表排序（ TimSort）。 它在1993年1月第四届ACM-SIAM离散算法研讨会的《第四届 ACM-SIAM 研讨会》中使用了彼得·麦基尔罗伊的“乐观排序和信息理论复杂性”的技术。

适用于 . 的 java.util.Arrays.sort(T[], java.util.Comparator<? super T>)Java 文档

本页的某些部分是根据 Android 开放源代码项目创建和共享的工作进行的修改，并根据 Creative Commons 2.5 属性许可证中所述的术语使用。

适用于