Arrays.Compare 方法

[Android.Runtime.Register("compare", "([BII[BII)I", "", ApiSince=33)]
public static int Compare(byte[] a, int aFromIndex, int aToIndex, byte[] b, int bFromIndex, int bToIndex);

[<Android.Runtime.Register("compare", "([BII[BII)I", "", ApiSince=33)>]
static member Compare : byte[] * int * int * byte[] * int * int -> int

参数

返回

0如果，在指定的范围上，第一个和第二个数组相等并包含相同顺序的相同元素;如果值小于0指定范围，则第一个数组的词法小于第二个数组;如果0值大于指定范围，则第一个数组的词法大于第二个数组

属性

RegisterAttribute

注解

比较两 byte 个数组的字典方式与指定的范围。

如果两个数组在指定范围中共享一个公共前缀，则字典比较是比较两个元素的结果，就好像在 Byte#compare(byte, byte)作为前缀长度的相应数组内的相对索引处进行比较。 否则，一个数组是另一个数组的正确前缀，字典比较是比较两个范围长度的结果。 （请参阅 #mismatch(byte[], int, int, byte[], int, int) 常见和适当的前缀的定义。

比较与#equals(byte[], int, int, byte[], int, int) equals数组和指定范围 [、 aToIndex] 和 [aFromIndexbFromIndex， bToIndex分别具有以下保留ab项的一致：

{@code
                Arrays.equals(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) ==
                    (Arrays.compare(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == 0)
            }

已在 9 中添加。

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

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

[Android.Runtime.Register("compare", "([CII[CII)I", "", ApiSince=33)]
public static int Compare(char[] a, int aFromIndex, int aToIndex, char[] b, int bFromIndex, int bToIndex);

[<Android.Runtime.Register("compare", "([CII[CII)I", "", ApiSince=33)>]
static member Compare : char[] * int * int * char[] * int * int -> int

参数

返回

0如果，在指定的范围上，第一个和第二个数组相等并包含相同顺序的相同元素;如果值小于0指定范围，则第一个数组的词法小于第二个数组;如果0值大于指定范围，则第一个数组的词法大于第二个数组

属性

RegisterAttribute

注解

比较两 char 个数组的字典方式与指定的范围。

如果两个数组在指定范围中共享一个公共前缀，则字典比较是比较两个元素的结果，就好像在 Character#compare(char, char)作为前缀长度的相应数组内的相对索引处进行比较。 否则，一个数组是另一个数组的正确前缀，字典比较是比较两个范围长度的结果。 （请参阅 #mismatch(char[], int, int, char[], int, int) 常见和适当的前缀的定义。

比较与#equals(char[], int, int, char[], int, int) equals数组和指定范围 [、 aToIndex] 和 [aFromIndexbFromIndex， bToIndex分别具有以下保留ab项的一致：

{@code
                Arrays.equals(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) ==
                    (Arrays.compare(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == 0)
            }

已在 9 中添加。

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

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

[Android.Runtime.Register("compare", "([DII[DII)I", "", ApiSince=33)]
public static int Compare(double[] a, int aFromIndex, int aToIndex, double[] b, int bFromIndex, int bToIndex);

[<Android.Runtime.Register("compare", "([DII[DII)I", "", ApiSince=33)>]
static member Compare : double[] * int * int * double[] * int * int -> int

参数

返回

0如果，在指定的范围上，第一个和第二个数组相等并包含相同顺序的相同元素;如果值小于0指定范围，则第一个数组的词法小于第二个数组;如果0值大于指定范围，则第一个数组的词法大于第二个数组

属性

RegisterAttribute

注解

比较两 double 个数组的字典方式与指定的范围。

如果两个数组在指定范围中共享一个公共前缀，则字典比较是比较两个元素的结果，就好像在 Double#compare(double, double)作为前缀长度的相应数组内的相对索引处进行比较。 否则，一个数组是另一个数组的正确前缀，字典比较是比较两个范围长度的结果。 （请参阅 #mismatch(double[], int, int, double[], int, int) 常见和适当的前缀的定义。

比较与#equals(double[], int, int, double[], int, int) equals数组和指定范围 [、 aToIndex] 和 [aFromIndexbFromIndex， bToIndex分别具有以下保留ab项的一致：

{@code
                Arrays.equals(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) ==
                    (Arrays.compare(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == 0)
            }

已在 9 中添加。

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

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

[Android.Runtime.Register("compare", "([SII[SII)I", "", ApiSince=33)]
public static int Compare(short[] a, int aFromIndex, int aToIndex, short[] b, int bFromIndex, int bToIndex);

[<Android.Runtime.Register("compare", "([SII[SII)I", "", ApiSince=33)>]
static member Compare : int16[] * int * int * int16[] * int * int -> int

参数

返回

0如果，在指定的范围上，第一个和第二个数组相等并包含相同顺序的相同元素;如果值小于0指定范围，则第一个数组的词法小于第二个数组;如果0值大于指定范围，则第一个数组的词法大于第二个数组

属性

RegisterAttribute

注解

比较两 short 个数组的字典方式与指定的范围。

如果两个数组在指定范围中共享一个公共前缀，则字典比较是比较两个元素的结果，就好像在 Short#compare(short, short)作为前缀长度的相应数组内的相对索引处进行比较。 否则，一个数组是另一个数组的正确前缀，字典比较是比较两个范围长度的结果。 （请参阅 #mismatch(short[], int, int, short[], int, int) 常见和适当的前缀的定义。

比较与#equals(short[], int, int, short[], int, int) equals数组和指定范围 [、 aToIndex] 和 [aFromIndexbFromIndex， bToIndex分别具有以下保留ab项的一致：

{@code
                Arrays.equals(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) ==
                    (Arrays.compare(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == 0)
            }

已在 9 中添加。

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

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

[Android.Runtime.Register("compare", "([Ljava/lang/Object;II[Ljava/lang/Object;IILjava/util/Comparator;)I", "", ApiSince=33)]
[Java.Interop.JavaTypeParameters(new System.String[] { "T" })]
public static int Compare(Java.Lang.Object[] a, int aFromIndex, int aToIndex, Java.Lang.Object[] b, int bFromIndex, int bToIndex, Java.Util.IComparator cmp);

[<Android.Runtime.Register("compare", "([Ljava/lang/Object;II[Ljava/lang/Object;IILjava/util/Comparator;)I", "", ApiSince=33)>]
[<Java.Interop.JavaTypeParameters(new System.String[] { "T" })>]
static member Compare : Java.Lang.Object[] * int * int * Java.Lang.Object[] * int * int * Java.Util.IComparator -> int

参数

返回

0如果，在指定的范围上，第一个和第二个数组相等并包含相同顺序的相同元素;如果值小于0指定范围，则第一个数组的词法小于第二个数组;如果0值大于指定范围，则第一个数组的词法大于第二个数组

属性

RegisterAttribute JavaTypeParametersAttribute

注解

比较两 Object 个数组的字典方式与指定的范围。

如果两个数组在指定范围内共享一个通用前缀，则字典比较是与指定比较器两个元素在作为前缀长度的相应数组中的相对索引处进行比较的结果。 否则，一个数组是另一个数组的正确前缀，字典比较是比较两个范围长度的结果。 （请参阅 #mismatch(Object[], int, int, Object[], int, int) 常见和适当的前缀的定义。

已在 9 中添加。

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

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

[Android.Runtime.Register("compare", "([JII[JII)I", "", ApiSince=33)]
public static int Compare(long[] a, int aFromIndex, int aToIndex, long[] b, int bFromIndex, int bToIndex);

[<Android.Runtime.Register("compare", "([JII[JII)I", "", ApiSince=33)>]
static member Compare : int64[] * int * int * int64[] * int * int -> int

参数

返回

0如果，在指定的范围上，第一个和第二个数组相等并包含相同顺序的相同元素;如果值小于0指定范围，则第一个数组的词法小于第二个数组;如果0值大于指定范围，则第一个数组的词法大于第二个数组

属性

RegisterAttribute

注解

比较两 long 个数组的字典方式与指定的范围。

如果两个数组在指定范围中共享一个公共前缀，则字典比较是比较两个元素的结果，就好像在 Long#compare(long, long)作为前缀长度的相应数组内的相对索引处进行比较。 否则，一个数组是另一个数组的正确前缀，字典比较是比较两个范围长度的结果。 （请参阅 #mismatch(long[], int, int, long[], int, int) 常见和适当的前缀的定义。

比较与#equals(long[], int, int, long[], int, int) equals数组和指定范围 [、 aToIndex] 和 [aFromIndexbFromIndex， bToIndex分别具有以下保留ab项的一致：

{@code
                Arrays.equals(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) ==
                    (Arrays.compare(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == 0)
            }

已在 9 中添加。

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

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

[Android.Runtime.Register("compare", "([FII[FII)I", "", ApiSince=33)]
public static int Compare(float[] a, int aFromIndex, int aToIndex, float[] b, int bFromIndex, int bToIndex);

[<Android.Runtime.Register("compare", "([FII[FII)I", "", ApiSince=33)>]
static member Compare : single[] * int * int * single[] * int * int -> int

参数

返回

0如果，在指定的范围上，第一个和第二个数组相等并包含相同顺序的相同元素;如果值小于0指定范围，则第一个数组的词法小于第二个数组;如果0值大于指定范围，则第一个数组的词法大于第二个数组

属性

RegisterAttribute

注解

比较两 float 个数组的字典方式与指定的范围。

如果两个数组在指定范围中共享一个公共前缀，则字典比较是比较两个元素的结果，就好像在 Float#compare(float, float)作为前缀长度的相应数组内的相对索引处进行比较。 否则，一个数组是另一个数组的正确前缀，字典比较是比较两个范围长度的结果。 （请参阅 #mismatch(float[], int, int, float[], int, int) 常见和适当的前缀的定义。

比较与#equals(float[], int, int, float[], int, int) equals数组和指定范围 [、 aToIndex] 和 [aFromIndexbFromIndex， bToIndex分别具有以下保留ab项的一致：

{@code
                Arrays.equals(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) ==
                    (Arrays.compare(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == 0)
            }

已在 9 中添加。

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

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

[Android.Runtime.Register("compare", "([ZII[ZII)I", "", ApiSince=33)]
public static int Compare(bool[] a, int aFromIndex, int aToIndex, bool[] b, int bFromIndex, int bToIndex);

[<Android.Runtime.Register("compare", "([ZII[ZII)I", "", ApiSince=33)>]
static member Compare : bool[] * int * int * bool[] * int * int -> int

参数

返回

0如果，在指定的范围上，第一个和第二个数组相等并包含相同顺序的相同元素;如果值小于0指定范围，则第一个数组的词法小于第二个数组;如果0值大于指定范围，则第一个数组的词法大于第二个数组

属性

RegisterAttribute

注解

比较两 boolean 个数组的字典方式与指定的范围。

如果两个数组在指定范围中共享一个公共前缀，则字典比较是比较两个元素的结果，就好像在 Boolean#compare(boolean, boolean)作为前缀长度的相应数组内的相对索引处进行比较。 否则，一个数组是另一个数组的正确前缀，字典比较是比较两个范围长度的结果。 （请参阅 #mismatch(boolean[], int, int, boolean[], int, int) 常见和适当的前缀的定义。

比较与#equals(boolean[], int, int, boolean[], int, int) equals数组和指定范围 [、 aToIndex] 和 [aFromIndexbFromIndex， bToIndex分别具有以下保留ab项的一致：

{@code
                Arrays.equals(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) ==
                    (Arrays.compare(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == 0)
            }

已在 9 中添加。

Java文档java.util.Arrays.compare(.*boolean[], .*int, .*int, .*boolean[], .*int, .*int)。

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

[Android.Runtime.Register("compare", "([III[III)I", "", ApiSince=33)]
public static int Compare(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex);

[<Android.Runtime.Register("compare", "([III[III)I", "", ApiSince=33)>]
static member Compare : int[] * int * int * int[] * int * int -> int

参数

返回

0如果，在指定的范围上，第一个和第二个数组相等并包含相同顺序的相同元素;如果值小于0指定范围，则第一个数组的词法小于第二个数组;如果0值大于指定范围，则第一个数组的词法大于第二个数组

属性

RegisterAttribute

注解

比较两 int 个数组的字典方式与指定的范围。

如果两个数组在指定范围中共享一个公共前缀，则字典比较是比较两个元素的结果，就好像在 Integer#compare(int, int)作为前缀长度的相应数组内的相对索引处进行比较。 否则，一个数组是另一个数组的正确前缀，字典比较是比较两个范围长度的结果。 （请参阅 #mismatch(int[], int, int, int[], int, int) 常见和适当的前缀的定义。

比较与#equals(int[], int, int, int[], int, int) equals数组和指定范围 [、 aToIndex] 和 [aFromIndexbFromIndex， bToIndex分别具有以下保留ab项的一致：

{@code
                Arrays.equals(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) ==
                    (Arrays.compare(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == 0)
            }

已在 9 中添加。

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

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

[Android.Runtime.Register("compare", "([Ljava/lang/Comparable;II[Ljava/lang/Comparable;II)I", "", ApiSince=33)]
[Java.Interop.JavaTypeParameters(new System.String[] { "T extends java.lang.Comparable<? super T>" })]
public static int Compare(Java.Lang.Object[] a, int aFromIndex, int aToIndex, Java.Lang.Object[] b, int bFromIndex, int bToIndex);

[<Android.Runtime.Register("compare", "([Ljava/lang/Comparable;II[Ljava/lang/Comparable;II)I", "", ApiSince=33)>]
[<Java.Interop.JavaTypeParameters(new System.String[] { "T extends java.lang.Comparable<? super T>" })>]
static member Compare : Java.Lang.Object[] * int * int * Java.Lang.Object[] * int * int -> int

参数

返回

0如果，在指定的范围上，第一个和第二个数组相等并包含相同顺序的相同元素;如果值小于0指定范围，则第一个数组的词法小于第二个数组;如果0值大于指定范围，则第一个数组的词法大于第二个数组

属性

RegisterAttribute JavaTypeParametersAttribute

注解

比较两 Object 个数组的字典方式与指定的范围。

如果两个数组在指定范围内共享一个通用前缀，则字典比较是比较位于相应数组中作为前缀长度的相对索引i处的两个元素的结果T，如下所示：

{@code
                Comparator.nullsFirst(Comparator.<T>naturalOrder()).
                    compare(a[aFromIndex + i, b[bFromIndex + i])
            }

否则，一个数组是另一个数组的正确前缀，字典比较是比较两个范围长度的结果。 （请参阅 #mismatch(Object[], int, int, Object[], int, int) 常见和适当的前缀的定义。

比较与#equals(Object[], int, int, Object[], int, int) equals数组和指定范围 [、 atoIndex] 和 [aFromIndexbFromIndex， btoIndex分别具有以下保留ab项的一致：

{@code
                Arrays.equals(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) ==
                    (Arrays.compare(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == 0)
            }

已在 9 中添加。

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

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

[Android.Runtime.Register("compare", "([I[I)I", "", ApiSince=33)]
public static int Compare(int[]? a, int[]? b);

[<Android.Runtime.Register("compare", "([I[I)I", "", ApiSince=33)>]
static member Compare : int[] * int[] -> int

参数

返回

如果第一个和第二个数组相等并包含相同元素，则为值 0 ; 0 小于第一个数组的词法小于第二个数组;如果第一 0 个数组的词法大于第二个数组，则该值大于第二个数组

属性

RegisterAttribute

注解

比较两 int 个数组的字典。

如果两个数组共享一个通用前缀，则字典比较是比较两个元素的结果，就好像在 Integer#compare(int, int)作为前缀长度的相应数组中的索引处比较一样。 否则，一个数组是另一个数组的正确前缀，字典比较是比较两个数组长度的结果。 （请参阅 #mismatch(int[], int[]) 常见和适当的前缀的定义。

null数组引用在字典上被视为小于非null数组引用。 两 null 个数组引用被视为相等。

比较与 #equals(int[], int[]) equals数组的以下保留 a 更具体地一致，并且 b：

{@code
                Arrays.equals(a, b) == (Arrays.compare(a, b) == 0)
            }

已在 9 中添加。

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

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

[Android.Runtime.Register("compare", "([F[F)I", "", ApiSince=33)]
public static int Compare(float[]? a, float[]? b);

[<Android.Runtime.Register("compare", "([F[F)I", "", ApiSince=33)>]
static member Compare : single[] * single[] -> int

参数

返回

如果第一个和第二个数组相等并包含相同元素，则为值 0 ; 0 小于第一个数组的词法小于第二个数组;如果第一 0 个数组的词法大于第二个数组，则该值大于第二个数组

属性

RegisterAttribute

注解

比较两 float 个数组的字典。

如果两个数组共享一个通用前缀，则字典比较是比较两个元素的结果，就好像在 Float#compare(float, float)作为前缀长度的相应数组中的索引处比较一样。 否则，一个数组是另一个数组的正确前缀，字典比较是比较两个数组长度的结果。 （请参阅 #mismatch(float[], float[]) 常见和适当的前缀的定义。

null数组引用在字典上被视为小于非null数组引用。 两 null 个数组引用被视为相等。

比较与 #equals(float[], float[]) equals数组的以下保留 a 更具体地一致，并且 b：

{@code
                Arrays.equals(a, b) == (Arrays.compare(a, b) == 0)
            }

已在 9 中添加。

Java文档java.util.Arrays.compare(.*float[], .*float[])。

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

[Android.Runtime.Register("compare", "([J[J)I", "", ApiSince=33)]
public static int Compare(long[]? a, long[]? b);

[<Android.Runtime.Register("compare", "([J[J)I", "", ApiSince=33)>]
static member Compare : int64[] * int64[] -> int

参数

返回

如果第一个和第二个数组相等并包含相同元素，则为值 0 ; 0 小于第一个数组的词法小于第二个数组;如果第一 0 个数组的词法大于第二个数组，则该值大于第二个数组

属性

RegisterAttribute

注解

比较两 long 个数组的字典。

如果两个数组共享一个通用前缀，则字典比较是比较两个元素的结果，就好像在 Long#compare(long, long)作为前缀长度的相应数组中的索引处比较一样。 否则，一个数组是另一个数组的正确前缀，字典比较是比较两个数组长度的结果。 （请参阅 #mismatch(long[], long[]) 常见和适当的前缀的定义。

null数组引用在字典上被视为小于非null数组引用。 两 null 个数组引用被视为相等。

比较与 #equals(long[], long[]) equals数组的以下保留 a 更具体地一致，并且 b：

{@code
                Arrays.equals(a, b) == (Arrays.compare(a, b) == 0)
            }

已在 9 中添加。

Java文档java.util.Arrays.compare(.*long[], .*long[])。

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

[Android.Runtime.Register("compare", "([S[S)I", "", ApiSince=33)]
public static int Compare(short[]? a, short[]? b);

[<Android.Runtime.Register("compare", "([S[S)I", "", ApiSince=33)>]
static member Compare : int16[] * int16[] -> int

参数

返回

如果第一个和第二个数组相等并包含相同元素，则为值 0 ; 0 小于第一个数组的词法小于第二个数组;如果第一 0 个数组的词法大于第二个数组，则该值大于第二个数组

属性

RegisterAttribute

注解

比较两 short 个数组的字典。

如果两个数组共享一个通用前缀，则字典比较是比较两个元素的结果，就好像在 Short#compare(short, short)作为前缀长度的相应数组中的索引处比较一样。 否则，一个数组是另一个数组的正确前缀，字典比较是比较两个数组长度的结果。 （请参阅 #mismatch(short[], short[]) 常见和适当的前缀的定义。

null数组引用在字典上被视为小于非null数组引用。 两 null 个数组引用被视为相等。

比较与 #equals(short[], short[]) equals数组的以下保留 a 更具体地一致，并且 b：

{@code
                Arrays.equals(a, b) == (Arrays.compare(a, b) == 0)
            }

已在 9 中添加。

Java文档java.util.Arrays.compare(.*short[], .*short[])。

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

[Android.Runtime.Register("compare", "([D[D)I", "", ApiSince=33)]
public static int Compare(double[]? a, double[]? b);

[<Android.Runtime.Register("compare", "([D[D)I", "", ApiSince=33)>]
static member Compare : double[] * double[] -> int

参数

返回

如果第一个和第二个数组相等并包含相同元素，则为值 0 ; 0 小于第一个数组的词法小于第二个数组;如果第一 0 个数组的词法大于第二个数组，则该值大于第二个数组

属性

RegisterAttribute

注解

比较两 double 个数组的字典。

如果两个数组共享一个通用前缀，则字典比较是比较两个元素的结果，就好像在 Double#compare(double, double)作为前缀长度的相应数组中的索引处比较一样。 否则，一个数组是另一个数组的正确前缀，字典比较是比较两个数组长度的结果。 （请参阅 #mismatch(double[], double[]) 常见和适当的前缀的定义。

null数组引用在字典上被视为小于非null数组引用。 两 null 个数组引用被视为相等。

比较与 #equals(double[], double[]) equals数组的以下保留 a 更具体地一致，并且 b：

{@code
                Arrays.equals(a, b) == (Arrays.compare(a, b) == 0)
            }

已在 9 中添加。

Java文档java.util.Arrays.compare(.*double[], .*double[])。

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

[Android.Runtime.Register("compare", "([C[C)I", "", ApiSince=33)]
public static int Compare(char[]? a, char[]? b);

[<Android.Runtime.Register("compare", "([C[C)I", "", ApiSince=33)>]
static member Compare : char[] * char[] -> int

参数

返回

如果第一个和第二个数组相等并包含相同元素，则为值 0 ; 0 小于第一个数组的词法小于第二个数组;如果第一 0 个数组的词法大于第二个数组，则该值大于第二个数组

属性

RegisterAttribute

注解

比较两 char 个数组的字典。

如果两个数组共享一个通用前缀，则字典比较是比较两个元素的结果，就好像在 Character#compare(char, char)作为前缀长度的相应数组中的索引处比较一样。 否则，一个数组是另一个数组的正确前缀，字典比较是比较两个数组长度的结果。 （请参阅 #mismatch(char[], char[]) 常见和适当的前缀的定义。

null数组引用在字典上被视为小于非null数组引用。 两 null 个数组引用被视为相等。

比较与 #equals(char[], char[]) equals数组的以下保留 a 更具体地一致，并且 b：

{@code
                Arrays.equals(a, b) == (Arrays.compare(a, b) == 0)
            }

已在 9 中添加。

Java文档java.util.Arrays.compare(.*char[], .*char[])。

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

[Android.Runtime.Register("compare", "([B[B)I", "", ApiSince=33)]
public static int Compare(byte[]? a, byte[]? b);

[<Android.Runtime.Register("compare", "([B[B)I", "", ApiSince=33)>]
static member Compare : byte[] * byte[] -> int

参数

返回

如果第一个和第二个数组相等并包含相同元素，则为值 0 ; 0 小于第一个数组的词法小于第二个数组;如果第一 0 个数组的词法大于第二个数组，则该值大于第二个数组

属性

RegisterAttribute

注解

比较两 byte 个数组的字典。

如果两个数组共享一个通用前缀，则字典比较是比较两个元素的结果，就好像在 Byte#compare(byte, byte)作为前缀长度的相应数组中的索引处比较一样。 否则，一个数组是另一个数组的正确前缀，字典比较是比较两个数组长度的结果。 （请参阅 #mismatch(byte[], byte[]) 常见和适当的前缀的定义。

null数组引用在字典上被视为小于非null数组引用。 两 null 个数组引用被视为相等。

比较与 #equals(byte[], byte[]) equals数组的以下保留 a 更具体地一致，并且 b：

{@code
                Arrays.equals(a, b) == (Arrays.compare(a, b) == 0)
            }

已在 9 中添加。

Java文档java.util.Arrays.compare(.*byte[], .*byte[])。

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

[Android.Runtime.Register("compare", "([Z[Z)I", "", ApiSince=33)]
public static int Compare(bool[]? a, bool[]? b);

[<Android.Runtime.Register("compare", "([Z[Z)I", "", ApiSince=33)>]
static member Compare : bool[] * bool[] -> int

参数

返回

如果第一个和第二个数组相等并包含相同元素，则为值 0 ; 0 小于第一个数组的词法小于第二个数组;如果第一 0 个数组的词法大于第二个数组，则该值大于第二个数组

属性

RegisterAttribute

注解

比较两 boolean 个数组的字典。

如果两个数组共享一个通用前缀，则字典比较是比较两个元素的结果，就好像在 Boolean#compare(boolean, boolean)作为前缀长度的相应数组中的索引处比较一样。 否则，一个数组是另一个数组的正确前缀，字典比较是比较两个数组长度的结果。 （请参阅 #mismatch(boolean[], boolean[]) 常见和适当的前缀的定义。

null数组引用在字典上被视为小于非null数组引用。 两 null 个数组引用被视为相等。

比较与 #equals(boolean[], boolean[]) equals数组的以下保留 a 更具体地一致，并且 b：

{@code
                Arrays.equals(a, b) == (Arrays.compare(a, b) == 0)
            }

已在 9 中添加。

Java文档java.util.Arrays.compare(.*boolean[], .*boolean[])。

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

[Android.Runtime.Register("compare", "([Ljava/lang/Comparable;[Ljava/lang/Comparable;)I", "", ApiSince=33)]
[Java.Interop.JavaTypeParameters(new System.String[] { "T extends java.lang.Comparable<? super T>" })]
public static int Compare(Java.Lang.Object[]? a, Java.Lang.Object[]? b);

[<Android.Runtime.Register("compare", "([Ljava/lang/Comparable;[Ljava/lang/Comparable;)I", "", ApiSince=33)>]
[<Java.Interop.JavaTypeParameters(new System.String[] { "T extends java.lang.Comparable<? super T>" })>]
static member Compare : Java.Lang.Object[] * Java.Lang.Object[] -> int

参数

返回

如果第一个和第二个数组相等并包含相同元素，则为值 0 ; 0 小于第一个数组的词法小于第二个数组;如果第一 0 个数组的词法大于第二个数组，则该值大于第二个数组

属性

RegisterAttribute JavaTypeParametersAttribute

注解

比较两个 Object 数组，在可比较的元素中，按字典方式。

如果两个数组共享一个通用前缀，则字典比较是比较位于相应数组中作为前缀长度的索引i处的两个元素的结果T，如下所示：

{@code
                Comparator.nullsFirst(Comparator.<T>naturalOrder()).
                    compare(a[i], b[i])
            }

否则，一个数组是另一个数组的正确前缀，字典比较是比较两个数组长度的结果。 （请参阅 #mismatch(Object[], Object[]) 常见和适当的前缀的定义。

null数组引用在字典上被视为小于非null数组引用。 两 null 个数组引用被视为相等。 null数组元素在字典上被视为小于非null数组元素。 两 null 个数组元素被视为相等。

比较与 #equals(Object[], Object[]) equals数组的以下保留 a 更具体地一致，并且 b：

{@code
                Arrays.equals(a, b) == (Arrays.compare(a, b) == 0)
            }

已在 9 中添加。

Java文档java.util.Arrays.compare(T[], T[])。

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

[Android.Runtime.Register("compare", "([Ljava/lang/Object;[Ljava/lang/Object;Ljava/util/Comparator;)I", "", ApiSince=33)]
[Java.Interop.JavaTypeParameters(new System.String[] { "T" })]
public static int Compare(Java.Lang.Object[]? a, Java.Lang.Object[]? b, Java.Util.IComparator cmp);

[<Android.Runtime.Register("compare", "([Ljava/lang/Object;[Ljava/lang/Object;Ljava/util/Comparator;)I", "", ApiSince=33)>]
[<Java.Interop.JavaTypeParameters(new System.String[] { "T" })>]
static member Compare : Java.Lang.Object[] * Java.Lang.Object[] * Java.Util.IComparator -> int

参数

返回

如果第一个和第二个数组相等并包含相同元素，则为值 0 ; 0 小于第一个数组的词法小于第二个数组;如果第一 0 个数组的词法大于第二个数组，则该值大于第二个数组

属性

RegisterAttribute JavaTypeParametersAttribute

注解

使用指定的比较器以字典方式比较两 Object 个数组。

如果两个数组共享一个通用前缀，则字典比较是与指定比较器两个元素在作为前缀长度的相应数组内的索引处进行比较的结果。 否则，一个数组是另一个数组的正确前缀，字典比较是比较两个数组长度的结果。 （请参阅 #mismatch(Object[], Object[]) 常见和适当的前缀的定义。

null数组引用在字典上被视为小于非null数组引用。 两 null 个数组引用被视为相等。

已在 9 中添加。

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

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