语言

Arrays.Sort 方法

定义

重载

名称 说明
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 值指示应使用元素的可比较自然排序。

特性

注解

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

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

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

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

该实现改编自蒂姆·彼得斯的Python列表排序(TimSort)。 它使用彼得·麦基尔罗伊的“乐观排序和信息理论复杂性”的技术,在1993年1月4日第四次离散算法研讨会 ACM-SIAM 研讨会上。

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

本页的某些部分是根据 创建和共享的工作进行的修改,并根据 许可证中所述的条款使用。

适用于

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

要排序的最后一个元素的索引(独占)

特性

例外

如果 start > end。

if start 或 end > array.length.

注解

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

Java文档java.util.Arrays.sort(byte[], int, int)。

本页的某些部分是根据 创建和共享的工作进行的修改,并根据 许可证中所述的条款使用。

适用于

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

要排序的最后一个元素的索引(独占)

特性

例外

如果 start > end。

if start 或 end > array.length.

注解

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

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

Java文档java.util.Arrays.sort(float[], int, int)。

本页的某些部分是根据 创建和共享的工作进行的修改,并根据 许可证中所述的条款使用。

另请参阅

适用于

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

要排序的最后一个元素的索引(独占)

特性

例外

如果 start > end。

if start 或 end > array.length.

注解

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

Java文档java.util.Arrays.sort(long[], int, int)。

本页的某些部分是根据 创建和共享的工作进行的修改,并根据 许可证中所述的条款使用。

适用于

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

要排序的最后一个元素的索引(独占)

特性

例外

如果 start > end。

if start 或 end > array.length.

注解

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

Java文档java.util.Arrays.sort(int[], int, int)。

本页的某些部分是根据 创建和共享的工作进行的修改,并根据 许可证中所述的条款使用。

适用于

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

要排序的最后一个元素的索引(独占)

特性

例外

如果 start > end。

if start 或 end > array.length.

注解

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

Java文档java.util.Arrays.sort(short[], int, int)。

本页的某些部分是根据 创建和共享的工作进行的修改,并根据 许可证中所述的条款使用。

适用于

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

要排序的最后一个元素的索引(独占)

特性

例外

如果 start > end。

if start 或 end > array.length.

注解

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

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

Java文档java.util.Arrays.sort(double[], int, int)。

本页的某些部分是根据 创建和共享的工作进行的修改,并根据 许可证中所述的条款使用。

另请参阅

适用于

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

要排序的最后一个元素的索引(独占)

特性

例外

如果 start > end。

if start 或 end > array.length.

注解

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

Java文档java.util.Arrays.sort(char[], int, int)。

本页的某些部分是根据 创建和共享的工作进行的修改,并根据 许可证中所述的条款使用。

适用于

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

要排序的最后一个元素(独占)的索引

特性

例外

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

如果 start > end。

if start 或 end > array.length.

注解

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

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

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

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

该实现改编自蒂姆·彼得斯的Python列表排序(TimSort)。 它使用彼得·麦基尔罗伊的“乐观排序和信息理论复杂性”的技术,在1993年1月4日第四次离散算法研讨会 ACM-SIAM 研讨会上。

Java文档java.util.Arrays.sort(java.lang.Object[], int, int)。

本页的某些部分是根据 创建和共享的工作进行的修改,并根据 许可证中所述的条款使用。

适用于

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[]

要排序的数组

特性

注解

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

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

Java文档java.util.Arrays.sort(float[])。

本页的某些部分是根据 创建和共享的工作进行的修改,并根据 许可证中所述的条款使用。

另请参阅

  • <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[]

要排序的数组

特性

注解

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

Java文档java.util.Arrays.sort(long[])。

本页的某些部分是根据 创建和共享的工作进行的修改,并根据 许可证中所述的条款使用。

适用于

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[]

要排序的数组

特性

注解

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

Java文档java.util.Arrays.sort(int[])。

本页的某些部分是根据 创建和共享的工作进行的修改,并根据 许可证中所述的条款使用。

适用于

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[]

要排序的数组

特性

注解

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

Java文档java.util.Arrays.sort(short[])。

本页的某些部分是根据 创建和共享的工作进行的修改,并根据 许可证中所述的条款使用。

适用于

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[]

要排序的数组

特性

注解

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

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

Java文档java.util.Arrays.sort(double[])。

本页的某些部分是根据 创建和共享的工作进行的修改,并根据 许可证中所述的条款使用。

另请参阅

  • <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[]

要排序的数组

特性

注解

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

Java文档java.util.Arrays.sort(char[])。

本页的某些部分是根据 创建和共享的工作进行的修改,并根据 许可证中所述的条款使用。

适用于

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[]

要排序的数组

特性

注解

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

Java文档java.util.Arrays.sort(byte[])。

本页的某些部分是根据 创建和共享的工作进行的修改,并根据 许可证中所述的条款使用。

适用于

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[]

要排序的数组

特性

例外

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

注解

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

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

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

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

该实现改编自蒂姆·彼得斯的Python列表排序(TimSort)。 它使用彼得·麦基尔罗伊的“乐观排序和信息理论复杂性”的技术,在1993年1月4日第四次离散算法研讨会 ACM-SIAM 研讨会上。

Java文档java.util.Arrays.sort(java.lang.Object[])。

本页的某些部分是根据 创建和共享的工作进行的修改,并根据 许可证中所述的条款使用。

适用于

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 值指示应使用元素的可比较自然排序。

特性

注解

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

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

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

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

该实现改编自蒂姆·彼得斯的Python列表排序(TimSort)。 它使用彼得·麦基尔罗伊的“乐观排序和信息理论复杂性”的技术,在1993年1月4日第四次离散算法研讨会 ACM-SIAM 研讨会上。

Java文档java.util.Arrays.sort(T[], java.util.Comparator<? super T>)。

本页的某些部分是根据 创建和共享的工作进行的修改,并根据 许可证中所述的条款使用。

适用于