語言

Arrays.Compare 方法

定義

命名空間:
Java.Util
組件:
Mono.Android.dll

多載

名稱 Description
Compare(Byte[], Int32, Int32, Byte[], Int32, Int32)

在指定範圍內以字典序方式比較兩個 byte 陣列。
Compare(Char[], Int32, Int32, Char[], Int32, Int32)

在指定範圍內以字典序方式比較兩個 char 陣列。
Compare(Double[], Int32, Int32, Double[], Int32, Int32)

在指定範圍內以字典序方式比較兩個 double 陣列。
Compare(Int16[], Int32, Int32, Int16[], Int32, Int32)

在指定範圍內以字典序方式比較兩個 short 陣列。
Compare(Object[], Int32, Int32, Object[], Int32, Int32, IComparator)

在指定範圍內以字典序方式比較兩個 Object 陣列。
Compare(Int64[], Int32, Int32, Int64[], Int32, Int32)

在指定範圍內以字典序方式比較兩個 long 陣列。
Compare(Single[], Int32, Int32, Single[], Int32, Int32)

在指定範圍內以字典序方式比較兩個 float 陣列。
Compare(Boolean[], Int32, Int32, Boolean[], Int32, Int32)

在指定範圍內以字典序方式比較兩個 boolean 陣列。
Compare(Int32[], Int32, Int32, Int32[], Int32, Int32)

在指定範圍內以字典序方式比較兩個 int 陣列。
Compare(Object[], Int32, Int32, Object[], Int32, Int32)

在指定範圍內以字典序方式比較兩個 Object 陣列。
Compare(Int32[], Int32[])

以字典序方式比較兩個 int 陣列。
Compare(Single[], Single[])

以字典序方式比較兩個 float 陣列。
Compare(Int64[], Int64[])

以字典序方式比較兩個 long 陣列。
Compare(Int16[], Int16[])

以字典序方式比較兩個 short 陣列。
Compare(Double[], Double[])

以字典序方式比較兩個 double 陣列。
Compare(Char[], Char[])

以字典序方式比較兩個 char 陣列。
Compare(Byte[], Byte[])

以字典序方式比較兩個 byte 陣列。
Compare(Boolean[], Boolean[])

以字典序方式比較兩個 boolean 陣列。
Compare(Object[], Object[])

在可比元素內，以字典序方式比較兩個 Object 陣列。
Compare(Object[], Object[], IComparator)

使用指定的比較器字典序比較兩個 Object 陣列。

Compare(Byte[], Int32, Int32, Byte[], Int32, Int32)

在指定範圍內以字典序方式比較兩個 byte 陣列。

[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

參數

a
Byte[]

第一個比較的陣列

aFromIndex
Int32

第一個要比較陣列中第一個元素的索引（包含索引）

aToIndex
Int32

第一個要比較的陣列中最後一個元素的索引（排他）

b
Byte[]

第二個比較陣列

bFromIndex
Int32

第二個要比較陣列中第一個元素的索引（包含索引）

bToIndex
Int32

第二個要比較陣列中最後一個元素的索引（排他）

傳回

Int32

0若在指定範圍內，第一與第二個陣列相等且包含相同元素且順序相同;若在指定範圍內，第一個陣列字典序上小於第二個陣列，則為小0於;若在指定範圍內，第一個陣列在字典序上大於第二個陣列，則為大0於

屬性
RegisterAttribute

備註

在指定範圍內以字典序方式比較兩個 byte 陣列。

如果兩個陣列在指定範圍內共享一個前綴，則字典序比較是透過比較兩個元素，例如在 Byte#compare(byte, byte)各自陣列內的相對索引（即前綴長度）上比較。 否則，一個陣列是另一個陣列的適當前綴，字典序比較則是比較兩個範圍長度的結果。 （關於共同且真前綴的定義，請參見 #mismatch(byte[], int, int, byte[], int, int) 。）

比較與 一致 #equals(byte[], int, int, byte[], int, int) equals，更具體地說，對於陣列 a 和 b ，且分別指定範圍為 [aFromIndex， aToIndex） 和 [bFromIndex， bToIndex）

{@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)。

本頁部分內容為基於 Open Source Project 所創建與分享的作品，並依授權條款所描述的使用進行修改。

適用於

Compare(Char[], Int32, Int32, Char[], Int32, Int32)

在指定範圍內以字典序方式比較兩個 char 陣列。

[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

參數

a
Char[]

第一個比較的陣列

aFromIndex
Int32

第一個要比較陣列中第一個元素的索引（包含索引）

aToIndex
Int32

第一個要比較的陣列中最後一個元素的索引（排他）

b
Char[]

第二個比較陣列

bFromIndex
Int32

第二個要比較陣列中第一個元素的索引（包含索引）

bToIndex
Int32

第二個要比較陣列中最後一個元素的索引（排他）

傳回

Int32

0若在指定範圍內，第一與第二個陣列相等且包含相同元素且順序相同;若在指定範圍內，第一個陣列字典序上小於第二個陣列，則為小0於;若在指定範圍內，第一個陣列在字典序上大於第二個陣列，則為大0於

屬性
RegisterAttribute

備註

在指定範圍內以字典序方式比較兩個 char 陣列。

如果兩個陣列在指定範圍內共享一個前綴，則字典序比較是透過比較兩個元素，例如在 Character#compare(char, char)各自陣列內的相對索引（即前綴長度）上比較。 否則，一個陣列是另一個陣列的適當前綴，字典序比較則是比較兩個範圍長度的結果。 （關於共同且真前綴的定義，請參見 #mismatch(char[], int, int, char[], int, int) 。）

比較與 一致 #equals(char[], int, int, char[], int, int) equals，更具體地說，對於陣列 a 和 b ，且分別指定範圍為 [aFromIndex， aToIndex） 和 [bFromIndex， bToIndex）

{@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)。

本頁部分內容為基於 Open Source Project 所創建與分享的作品，並依授權條款所描述的使用進行修改。

適用於

Compare(Double[], Int32, Int32, Double[], Int32, Int32)

在指定範圍內以字典序方式比較兩個 double 陣列。

[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

參數

a
Double[]

第一個比較的陣列

aFromIndex
Int32

第一個要比較陣列中第一個元素的索引（包含索引）

aToIndex
Int32

第一個要比較的陣列中最後一個元素的索引（排他）

b
Double[]

第二個比較陣列

bFromIndex
Int32

第二個要比較陣列中第一個元素的索引（包含索引）

bToIndex
Int32

第二個要比較陣列中最後一個元素的索引（排他）

傳回

Int32

0若在指定範圍內，第一與第二個陣列相等且包含相同元素且順序相同;若在指定範圍內，第一個陣列字典序上小於第二個陣列，則為小0於;若在指定範圍內，第一個陣列在字典序上大於第二個陣列，則為大0於

屬性
RegisterAttribute

備註

在指定範圍內以字典序方式比較兩個 double 陣列。

如果兩個陣列在指定範圍內共享一個前綴，則字典序比較是透過比較兩個元素，例如在 Double#compare(double, double)各自陣列內的相對索引（即前綴長度）上比較。 否則，一個陣列是另一個陣列的適當前綴，字典序比較則是比較兩個範圍長度的結果。 （關於共同且真前綴的定義，請參見 #mismatch(double[], int, int, double[], int, int) 。）

比較與 一致 #equals(double[], int, int, double[], int, int) equals，更具體地說，對於陣列 a 和 b ，且分別指定範圍為 [aFromIndex， aToIndex） 和 [bFromIndex， bToIndex）

{@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)。

本頁部分內容為基於 Open Source Project 所創建與分享的作品，並依授權條款所描述的使用進行修改。

適用於

Compare(Int16[], Int32, Int32, Int16[], Int32, Int32)

在指定範圍內以字典序方式比較兩個 short 陣列。

[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

參數

a
Int16[]

第一個比較的陣列

aFromIndex
Int32

第一個要比較陣列中第一個元素的索引（包含索引）

aToIndex
Int32

第一個要比較的陣列中最後一個元素的索引（排他）

b
Int16[]

第二個比較陣列

bFromIndex
Int32

第二個要比較陣列中第一個元素的索引（包含索引）

bToIndex
Int32

第二個要比較陣列中最後一個元素的索引（排他）

傳回

Int32

0若在指定範圍內，第一與第二個陣列相等且包含相同元素且順序相同;若在指定範圍內，第一個陣列字典序上小於第二個陣列，則為小0於;若在指定範圍內，第一個陣列在字典序上大於第二個陣列，則為大0於

屬性
RegisterAttribute

備註

在指定範圍內以字典序方式比較兩個 short 陣列。

如果兩個陣列在指定範圍內共享一個前綴，則字典序比較是透過比較兩個元素，例如在 Short#compare(short, short)各自陣列內的相對索引（即前綴長度）上比較。 否則，一個陣列是另一個陣列的適當前綴，字典序比較則是比較兩個範圍長度的結果。 （關於共同且真前綴的定義，請參見 #mismatch(short[], int, int, short[], int, int) 。）

比較與 一致 #equals(short[], int, int, short[], int, int) equals，更具體地說，對於陣列 a 和 b ，且分別指定範圍為 [aFromIndex， aToIndex） 和 [bFromIndex， bToIndex）

{@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)。

本頁部分內容為基於 Open Source Project 所創建與分享的作品，並依授權條款所描述的使用進行修改。

適用於

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

在指定範圍內以字典序方式比較兩個 Object 陣列。

[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

參數

a
Object[]

第一個比較的陣列

aFromIndex
Int32

第一個要比較陣列中第一個元素的索引（包含索引）

aToIndex
Int32

第一個要比較的陣列中最後一個元素的索引（排他）

b
Object[]

第二個比較陣列

bFromIndex
Int32

第二個要比較陣列中第一個元素的索引（包含索引）

bToIndex
Int32

第二個要比較陣列中最後一個元素的索引（排他）

cmp
IComparator

比較器用來比較陣列元素

傳回

Int32

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>)。

本頁部分內容為基於 Open Source Project 所創建與分享的作品，並依授權條款所描述的使用進行修改。

適用於

Compare(Int64[], Int32, Int32, Int64[], Int32, Int32)

在指定範圍內以字典序方式比較兩個 long 陣列。

[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

參數

a
Int64[]

第一個比較的陣列

aFromIndex
Int32

第一個要比較陣列中第一個元素的索引（包含索引）

aToIndex
Int32

第一個要比較的陣列中最後一個元素的索引（排他）

b
Int64[]

第二個比較陣列

bFromIndex
Int32

第二個要比較陣列中第一個元素的索引（包含索引）

bToIndex
Int32

第二個要比較陣列中最後一個元素的索引（排他）

傳回

Int32

0若在指定範圍內，第一與第二個陣列相等且包含相同元素且順序相同;若在指定範圍內，第一個陣列字典序上小於第二個陣列，則為小0於;若在指定範圍內，第一個陣列在字典序上大於第二個陣列，則為大0於

屬性
RegisterAttribute

備註

在指定範圍內以字典序方式比較兩個 long 陣列。

如果兩個陣列在指定範圍內共享一個前綴，則字典序比較是透過比較兩個元素，例如在 Long#compare(long, long)各自陣列內的相對索引（即前綴長度）上比較。 否則，一個陣列是另一個陣列的適當前綴，字典序比較則是比較兩個範圍長度的結果。 （關於共同且真前綴的定義，請參見 #mismatch(long[], int, int, long[], int, int) 。）

比較與 一致 #equals(long[], int, int, long[], int, int) equals，更具體地說，對於陣列 a 和 b ，且分別指定範圍為 [aFromIndex， aToIndex） 和 [bFromIndex， bToIndex）

{@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)。

本頁部分內容為基於 Open Source Project 所創建與分享的作品，並依授權條款所描述的使用進行修改。

適用於

Compare(Single[], Int32, Int32, Single[], Int32, Int32)

在指定範圍內以字典序方式比較兩個 float 陣列。

[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

參數

a
Single[]

第一個比較的陣列

aFromIndex
Int32

第一個要比較陣列中第一個元素的索引（包含索引）

aToIndex
Int32

第一個要比較的陣列中最後一個元素的索引（排他）

b
Single[]

第二個比較陣列

bFromIndex
Int32

第二個要比較陣列中第一個元素的索引（包含索引）

bToIndex
Int32

第二個要比較陣列中最後一個元素的索引（排他）

傳回

Int32

0若在指定範圍內，第一與第二個陣列相等且包含相同元素且順序相同;若在指定範圍內，第一個陣列字典序上小於第二個陣列，則為小0於;若在指定範圍內，第一個陣列在字典序上大於第二個陣列，則為大0於

屬性
RegisterAttribute

備註

在指定範圍內以字典序方式比較兩個 float 陣列。

如果兩個陣列在指定範圍內共享一個前綴，則字典序比較是透過比較兩個元素，例如在 Float#compare(float, float)各自陣列內的相對索引（即前綴長度）上比較。 否則，一個陣列是另一個陣列的適當前綴，字典序比較則是比較兩個範圍長度的結果。 （關於共同且真前綴的定義，請參見 #mismatch(float[], int, int, float[], int, int) 。）

比較與 一致 #equals(float[], int, int, float[], int, int) equals，更具體地說，對於陣列 a 和 b ，且分別指定範圍為 [aFromIndex， aToIndex） 和 [bFromIndex， bToIndex）

{@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)。

本頁部分內容為基於 Open Source Project 所創建與分享的作品，並依授權條款所描述的使用進行修改。

適用於

Compare(Boolean[], Int32, Int32, Boolean[], Int32, Int32)

在指定範圍內以字典序方式比較兩個 boolean 陣列。

[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

參數

a
Boolean[]

第一個比較的陣列

aFromIndex
Int32

第一個要比較陣列中第一個元素的索引（包含索引）

aToIndex
Int32

第一個要比較的陣列中最後一個元素的索引（排他）

b
Boolean[]

第二個比較陣列

bFromIndex
Int32

第二個要比較陣列中第一個元素的索引（包含索引）

bToIndex
Int32

第二個要比較陣列中最後一個元素的索引（排他）

傳回

Int32

0若在指定範圍內，第一與第二個陣列相等且包含相同元素且順序相同;若在指定範圍內，第一個陣列字典序上小於第二個陣列，則為小0於;若在指定範圍內，第一個陣列在字典序上大於第二個陣列，則為大0於

屬性
RegisterAttribute

備註

在指定範圍內以字典序方式比較兩個 boolean 陣列。

如果兩個陣列在指定範圍內共享一個前綴，則字典序比較是透過比較兩個元素，例如在 Boolean#compare(boolean, boolean)各自陣列內的相對索引（即前綴長度）上比較。 否則，一個陣列是另一個陣列的適當前綴，字典序比較則是比較兩個範圍長度的結果。 （關於共同且真前綴的定義，請參見 #mismatch(boolean[], int, int, boolean[], int, int) 。）

比較與 一致 #equals(boolean[], int, int, boolean[], int, int) equals，更具體地說，對於陣列 a 和 b ，且分別指定範圍為 [aFromIndex， aToIndex） 和 [bFromIndex， bToIndex）

{@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)。

本頁部分內容為基於 Open Source Project 所創建與分享的作品，並依授權條款所描述的使用進行修改。

適用於

Compare(Int32[], Int32, Int32, Int32[], Int32, Int32)

在指定範圍內以字典序方式比較兩個 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

參數

a
Int32[]

第一個比較的陣列

aFromIndex
Int32

第一個要比較陣列中第一個元素的索引（包含索引）

aToIndex
Int32

第一個要比較的陣列中最後一個元素的索引（排他）

b
Int32[]

第二個比較陣列

bFromIndex
Int32

第二個要比較陣列中第一個元素的索引（包含索引）

bToIndex
Int32

第二個要比較陣列中最後一個元素的索引（排他）

傳回

Int32

0若在指定範圍內，第一與第二個陣列相等且包含相同元素且順序相同;若在指定範圍內，第一個陣列字典序上小於第二個陣列，則為小0於;若在指定範圍內，第一個陣列在字典序上大於第二個陣列，則為大0於

屬性
RegisterAttribute

備註

在指定範圍內以字典序方式比較兩個 int 陣列。

如果兩個陣列在指定範圍內共享一個前綴，則字典序比較是透過比較兩個元素，例如在 Integer#compare(int, int)各自陣列內的相對索引（即前綴長度）上比較。 否則，一個陣列是另一個陣列的適當前綴，字典序比較則是比較兩個範圍長度的結果。 （關於共同且真前綴的定義，請參見 #mismatch(int[], int, int, int[], int, int) 。）

比較與 一致 #equals(int[], int, int, int[], int, int) equals，更具體地說，對於陣列 a 和 b ，且分別指定範圍為 [aFromIndex， aToIndex） 和 [bFromIndex， bToIndex）

{@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)。

本頁部分內容為基於 Open Source Project 所創建與分享的作品，並依授權條款所描述的使用進行修改。

適用於

Compare(Object[], Int32, Int32, Object[], Int32, Int32)

在指定範圍內以字典序方式比較兩個 Object 陣列。

[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

參數

a
Object[]

第一個比較的陣列

aFromIndex
Int32

第一個要比較陣列中第一個元素的索引（包含索引）

aToIndex
Int32

第一個要比較的陣列中最後一個元素的索引（排他）

b
Object[]

第二個比較陣列

bFromIndex
Int32

第二個要比較陣列中第一個元素的索引（包含索引）

bToIndex
Int32

第二個要比較陣列中最後一個元素的索引（排他）

傳回

Int32

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，更具體地說，對於陣列 a 和 b ，且分別指定範圍為 [aFromIndex， atoIndex） 和 [bFromIndex， btoIndex）

{@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)。

本頁部分內容為基於 Open Source Project 所創建與分享的作品，並依授權條款所描述的使用進行修改。

適用於

Compare(Int32[], Int32[])

以字典序方式比較兩個 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

參數

a
Int32[]

第一個比較的陣列

b
Int32[]

第二個比較陣列

傳回

Int32

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

本頁部分內容為基於 Open Source Project 所創建與分享的作品，並依授權條款所描述的使用進行修改。

適用於

Compare(Single[], Single[])

以字典序方式比較兩個 float 陣列。

[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

參數

a
Single[]

第一個比較的陣列

b
Single[]

第二個比較陣列

傳回

Int32

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

本頁部分內容為基於 Open Source Project 所創建與分享的作品，並依授權條款所描述的使用進行修改。

適用於

Compare(Int64[], Int64[])

以字典序方式比較兩個 long 陣列。

[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

參數

a
Int64[]

第一個比較的陣列

b
Int64[]

第二個比較陣列

傳回

Int32

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

本頁部分內容為基於 Open Source Project 所創建與分享的作品，並依授權條款所描述的使用進行修改。

適用於

Compare(Int16[], Int16[])

以字典序方式比較兩個 short 陣列。

[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

參數

a
Int16[]

第一個比較的陣列

b
Int16[]

第二個比較陣列

傳回

Int32

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

本頁部分內容為基於 Open Source Project 所創建與分享的作品，並依授權條款所描述的使用進行修改。

適用於

Compare(Double[], Double[])

以字典序方式比較兩個 double 陣列。

[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

參數

a
Double[]

第一個比較的陣列

b
Double[]

第二個比較陣列

傳回

Int32

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

本頁部分內容為基於 Open Source Project 所創建與分享的作品，並依授權條款所描述的使用進行修改。

適用於

Compare(Char[], Char[])

以字典序方式比較兩個 char 陣列。

[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

參數

a
Char[]

第一個比較的陣列

b
Char[]

第二個比較陣列

傳回

Int32

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

本頁部分內容為基於 Open Source Project 所創建與分享的作品，並依授權條款所描述的使用進行修改。

適用於

Compare(Byte[], Byte[])

以字典序方式比較兩個 byte 陣列。

[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

參數

a
Byte[]

第一個比較的陣列

b
Byte[]

第二個比較陣列

傳回

Int32

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

本頁部分內容為基於 Open Source Project 所創建與分享的作品，並依授權條款所描述的使用進行修改。

適用於

Compare(Boolean[], Boolean[])

以字典序方式比較兩個 boolean 陣列。

[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

參數

a
Boolean[]

第一個比較的陣列

b
Boolean[]

第二個比較陣列

傳回

Int32

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

本頁部分內容為基於 Open Source Project 所創建與分享的作品，並依授權條款所描述的使用進行修改。

適用於

Compare(Object[], Object[])

在可比元素內，以字典序方式比較兩個 Object 陣列。

[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

參數

a
Object[]

第一個比較的陣列

b
Object[]

第二個比較陣列

傳回

Int32

0若第一與第二個陣列相等且包含相同元素且順序相同;若第一個陣列在字典序上小於第二個陣列，則為小0於;若第一個陣列在字典序上大於第二個陣列，則為大0於

屬性
RegisterAttribute JavaTypeParametersAttribute

備註

在可比元素內，以字典序方式比較兩個 Object 陣列。

若兩個陣列共享共同前綴，字典序比較即為將兩個元素Ti在相應陣列中索引為前綴長度的索引中進行比較，例如：

{@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[])。

本頁部分內容為基於 Open Source Project 所創建與分享的作品，並依授權條款所描述的使用進行修改。

適用於

Compare(Object[], Object[], IComparator)

使用指定的比較器字典序比較兩個 Object 陣列。

[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

參數

a
Object[]

第一個比較的陣列

b
Object[]

第二個比較陣列

cmp
IComparator

比較器用來比較陣列元素

傳回

Int32

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>)。

本頁部分內容為基於 Open Source Project 所創建與分享的作品，並依授權條款所描述的使用進行修改。

適用於