語言

Arrays.Mismatch 方法

定義

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

多載

名稱 Description
Mismatch(Object[], Int32, Int32, Object[], Int32, Int32, IComparator)

尋找並回傳兩個陣列在指定範圍內首次不匹配 Object 的相對索引，否則若未找到不匹配則返回 -1。
Mismatch(Single[], Int32, Int32, Single[], Int32, Int32)

尋找並回傳兩個陣列在指定範圍內首次不匹配 float 的相對索引，否則若未找到不匹配則返回 -1。
Mismatch(Int64[], Int32, Int32, Int64[], Int32, Int32)

尋找並回傳兩個陣列在指定範圍內首次不匹配 long 的相對索引，否則若未找到不匹配則返回 -1。
Mismatch(Int32[], Int32, Int32, Int32[], Int32, Int32)

尋找並回傳兩個陣列在指定範圍內首次不匹配 int 的相對索引，否則若未找到不匹配則返回 -1。
Mismatch(Int16[], Int32, Int32, Int16[], Int32, Int32)

尋找並回傳兩個陣列在指定範圍內首次不匹配 short 的相對索引，否則若未找到不匹配則返回 -1。
Mismatch(Double[], Int32, Int32, Double[], Int32, Int32)

尋找並回傳兩個陣列在指定範圍內首次不匹配 double 的相對索引，否則若未找到不匹配則返回 -1。
Mismatch(Char[], Int32, Int32, Char[], Int32, Int32)

尋找並回傳兩個陣列在指定範圍內首次不匹配 char 的相對索引，否則若未找到不匹配則返回 -1。
Mismatch(Byte[], Int32, Int32, Byte[], Int32, Int32)

尋找並回傳兩個陣列在指定範圍內首次不匹配 byte 的相對索引，否則若未找到不匹配則返回 -1。
Mismatch(Boolean[], Int32, Int32, Boolean[], Int32, Int32)

尋找並回傳兩個陣列在指定範圍內首次不匹配 boolean 的相對索引，否則若未找到不匹配則返回 -1。
Mismatch(Object[], Int32, Int32, Object[], Int32, Int32)

尋找並回傳兩個陣列在指定範圍內首次不匹配 Object 的相對索引，否則若未找到不匹配則返回 -1。
Mismatch(Single[], Single[])

尋找並回傳兩個 float 陣列間第一個不匹配的索引，否則若未找到不匹配則回傳 -1。
Mismatch(Int64[], Int64[])

尋找並回傳兩個 long 陣列間第一個不匹配的索引，否則若未找到不匹配則回傳 -1。
Mismatch(Int32[], Int32[])

尋找並回傳兩個 int 陣列間第一個不匹配的索引，否則若未找到不匹配則回傳 -1。
Mismatch(Int16[], Int16[])

尋找並回傳兩個 short 陣列間第一個不匹配的索引，否則若未找到不匹配則回傳 -1。
Mismatch(Double[], Double[])

尋找並回傳兩個 double 陣列間第一個不匹配的索引，否則若未找到不匹配則回傳 -1。
Mismatch(Char[], Char[])

尋找並回傳兩個 char 陣列間第一個不匹配的索引，否則若未找到不匹配則回傳 -1。
Mismatch(Byte[], Byte[])

尋找並回傳兩個 byte 陣列間第一個不匹配的索引，否則若未找到不匹配則回傳 -1。
Mismatch(Boolean[], Boolean[])

尋找並回傳兩個 boolean 陣列間第一個不匹配的索引，否則若未找到不匹配則回傳 -1。
Mismatch(Object[], Object[])

尋找並回傳兩個 Object 陣列間第一個不匹配的索引，否則若未找到不匹配則回傳 -1。
Mismatch(Object[], Object[], IComparator)

尋找並回傳兩個 Object 陣列間第一個不匹配的索引，否則若未找到不匹配則回傳 -1。

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

尋找並回傳兩個陣列在指定範圍內首次不匹配 Object 的相對索引，否則若未找到不匹配則返回 -1。

[Android.Runtime.Register("mismatch", "([Ljava/lang/Object;II[Ljava/lang/Object;IILjava/util/Comparator;)I", "", ApiSince=33)]
[Java.Interop.JavaTypeParameters(new System.String[] { "T" })]
public static int Mismatch(Java.Lang.Object[] a, int aFromIndex, int aToIndex, Java.Lang.Object[] b, int bFromIndex, int bToIndex, Java.Util.IComparator cmp);
[<Android.Runtime.Register("mismatch", "([Ljava/lang/Object;II[Ljava/lang/Object;IILjava/util/Comparator;)I", "", ApiSince=33)>]
[<Java.Interop.JavaTypeParameters(new System.String[] { "T" })>]
static member Mismatch : 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

在指定範圍內，兩個陣列第一次不匹配的相對指標，否則 -1為 。

屬性
RegisterAttribute JavaTypeParametersAttribute

備註

尋找並回傳兩個陣列在指定範圍內首次不匹配 Object 的相對索引，否則若未找到不匹配則返回 -1。 指數範圍範圍為 0（含）至較小範圍的長度（含）。

若兩個陣列在指定範圍內共享一個前綴，則回傳的相對索引即為該前綴的長度，因此在相應陣列中該相對索引的兩個元素存在不匹配。 若一個陣列在指定範圍內是另一個陣列的適當前綴，則回傳的相對索引即為較小範圍的長度，因此相對索引僅適用於較大範圍的陣列。 除此之外，沒有不匹配。

兩個null非陣列，ba且分別具有指定範圍 [aFromIndex， atoIndex） 和 [bFromIndex， btoIndex） ，若以下表達式為真，則共享一個共同的前pl綴長度：

{@code
                pl >= 0 &&
                pl < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex) &&
                Arrays.equals(a, aFromIndex, aFromIndex + pl, b, bFromIndex, bFromIndex + pl, cmp) &&
                cmp.compare(a[aFromIndex + pl], b[bFromIndex + pl]) != 0
            }

注意，常見的前綴長度 0 表示每個陣列的前端元素不匹配。

兩個非null 陣列， ab 且分別具有指定範圍 [aFromIndex， atoIndex） 和 [bFromIndex， btoIndex） 的，若以下表達式為真，則共享一個真前綴：

{@code
                (aToIndex - aFromIndex) != (bToIndex - bFromIndex) &&
                Arrays.equals(a, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex),
                              b, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex),
                              cmp)
            }

新增9。

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

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

適用於

Mismatch(Single[], Int32, Int32, Single[], Int32, Int32)

尋找並回傳兩個陣列在指定範圍內首次不匹配 float 的相對索引，否則若未找到不匹配則返回 -1。

[Android.Runtime.Register("mismatch", "([FII[FII)I", "", ApiSince=33)]
public static int Mismatch(float[] a, int aFromIndex, int aToIndex, float[] b, int bFromIndex, int bToIndex);
[<Android.Runtime.Register("mismatch", "([FII[FII)I", "", ApiSince=33)>]
static member Mismatch : single[] * int * int * single[] * int * int -> int

參數

a
Single[]

第一個被測試不匹配的陣列

aFromIndex
Int32

第一個待測試陣列中第一個元素的索引（包含索引）

aToIndex
Int32

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

b
Single[]

第二個要測試是否不匹配的陣列

bFromIndex
Int32

第二個待測陣列中第一個元素的索引（包含）

bToIndex
Int32

第二個待測試陣列中最後一個元素的索引（排他）

傳回

Int32

在指定範圍內，兩個陣列第一次不匹配的相對指標，否則 -1為 。

屬性
RegisterAttribute

備註

尋找並回傳兩個陣列在指定範圍內首次不匹配 float 的相對索引，否則若未找到不匹配則返回 -1。 指數範圍範圍為 0（含）至較小範圍的長度（含）。

若兩個陣列在指定範圍內共享一個前綴，則回傳的相對索引即為該前綴的長度，因此在相應陣列中該相對索引的兩個元素存在不匹配。 若一個陣列在指定範圍內是另一個陣列的適當前綴，則回傳的相對索引即為較小範圍的長度，因此相對索引僅適用於較大範圍的陣列。 除此之外，沒有不匹配。

兩個null非陣列，ba且分別具有指定範圍 [aFromIndex， aToIndex） 和 [bFromIndex， bToIndex） ，若以下表達式為真，則共享一個共同的前pl綴長度：

{@code
                pl >= 0 &&
                pl < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex) &&
                Arrays.equals(a, aFromIndex, aFromIndex + pl, b, bFromIndex, bFromIndex + pl) &&
                Float.compare(a[aFromIndex + pl], b[bFromIndex + pl]) != 0
            }

注意，常見的前綴長度 0 表示每個陣列的前端元素不匹配。

兩個非null 陣列， ab 且分別具有指定範圍 [aFromIndex， aToIndex） 和 [bFromIndex， bToIndex） 的，若以下表達式為真，則共享一個真前綴：

{@code
                (aToIndex - aFromIndex) != (bToIndex - bFromIndex) &&
                Arrays.equals(a, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex),
                              b, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
            }

新增9。

Java 文件 java.util.Arrays.mismatch(.*float[], .*int, .*int, .*float[], .*int, .*int)。

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

適用於

Mismatch(Int64[], Int32, Int32, Int64[], Int32, Int32)

尋找並回傳兩個陣列在指定範圍內首次不匹配 long 的相對索引，否則若未找到不匹配則返回 -1。

[Android.Runtime.Register("mismatch", "([JII[JII)I", "", ApiSince=33)]
public static int Mismatch(long[] a, int aFromIndex, int aToIndex, long[] b, int bFromIndex, int bToIndex);
[<Android.Runtime.Register("mismatch", "([JII[JII)I", "", ApiSince=33)>]
static member Mismatch : int64[] * int * int * int64[] * int * int -> int

參數

a
Int64[]

第一個被測試不匹配的陣列

aFromIndex
Int32

第一個待測試陣列中第一個元素的索引（包含索引）

aToIndex
Int32

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

b
Int64[]

第二個要測試是否不匹配的陣列

bFromIndex
Int32

第二個待測陣列中第一個元素的索引（包含）

bToIndex
Int32

第二個待測試陣列中最後一個元素的索引（排他）

傳回

Int32

在指定範圍內，兩個陣列第一次不匹配的相對指標，否則 -1為 。

屬性
RegisterAttribute

備註

尋找並回傳兩個陣列在指定範圍內首次不匹配 long 的相對索引，否則若未找到不匹配則返回 -1。 指數範圍範圍為 0（含）至較小範圍的長度（含）。

若兩個陣列在指定範圍內共享一個前綴，則回傳的相對索引即為該前綴的長度，因此在相應陣列中該相對索引的兩個元素存在不匹配。 若一個陣列在指定範圍內是另一個陣列的適當前綴，則回傳的相對索引即為較小範圍的長度，因此相對索引僅適用於較大範圍的陣列。 除此之外，沒有不匹配。

兩個null非陣列，ba且分別具有指定範圍 [aFromIndex， aToIndex） 和 [bFromIndex， bToIndex） ，若以下表達式為真，則共享一個共同的前pl綴長度：

{@code
                pl >= 0 &&
                pl < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex) &&
                Arrays.equals(a, aFromIndex, aFromIndex + pl, b, bFromIndex, bFromIndex + pl) &&
                a[aFromIndex + pl] != b[bFromIndex + pl]
            }

注意，常見的前綴長度 0 表示每個陣列的前端元素不匹配。

兩個非null 陣列， ab 且分別具有指定範圍 [aFromIndex， aToIndex） 和 [bFromIndex， bToIndex） 的，若以下表達式為真，則共享一個真前綴：

{@code
                (aToIndex - aFromIndex) != (bToIndex - bFromIndex) &&
                Arrays.equals(a, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex),
                              b, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
            }

新增9。

Java 文件 java.util.Arrays.mismatch(.*long[], .*int, .*int, .*long[], .*int, .*int)。

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

適用於

Mismatch(Int32[], Int32, Int32, Int32[], Int32, Int32)

尋找並回傳兩個陣列在指定範圍內首次不匹配 int 的相對索引，否則若未找到不匹配則返回 -1。

[Android.Runtime.Register("mismatch", "([III[III)I", "", ApiSince=33)]
public static int Mismatch(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex);
[<Android.Runtime.Register("mismatch", "([III[III)I", "", ApiSince=33)>]
static member Mismatch : int[] * int * int * int[] * int * int -> int

參數

a
Int32[]

第一個被測試不匹配的陣列

aFromIndex
Int32

第一個待測試陣列中第一個元素的索引（包含索引）

aToIndex
Int32

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

b
Int32[]

第二個要測試是否不匹配的陣列

bFromIndex
Int32

第二個待測陣列中第一個元素的索引（包含）

bToIndex
Int32

第二個待測試陣列中最後一個元素的索引（排他）

傳回

Int32

在指定範圍內，兩個陣列第一次不匹配的相對指標，否則 -1為 。

屬性
RegisterAttribute

備註

尋找並回傳兩個陣列在指定範圍內首次不匹配 int 的相對索引，否則若未找到不匹配則返回 -1。 指數範圍範圍為 0（含）至較小範圍的長度（含）。

若兩個陣列在指定範圍內共享一個前綴，則回傳的相對索引即為該前綴的長度，因此在相應陣列中該相對索引的兩個元素存在不匹配。 若一個陣列在指定範圍內是另一個陣列的適當前綴，則回傳的相對索引即為較小範圍的長度，因此相對索引僅適用於較大範圍的陣列。 除此之外，沒有不匹配。

兩個null非陣列，ba且分別具有指定範圍 [aFromIndex， aToIndex） 和 [bFromIndex， bToIndex） ，若以下表達式為真，則共享一個共同的前pl綴長度：

{@code
                pl >= 0 &&
                pl < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex) &&
                Arrays.equals(a, aFromIndex, aFromIndex + pl, b, bFromIndex, bFromIndex + pl) &&
                a[aFromIndex + pl] != b[bFromIndex + pl]
            }

注意，常見的前綴長度 0 表示每個陣列的前端元素不匹配。

兩個非null 陣列， ab 且分別具有指定範圍 [aFromIndex， aToIndex） 和 [bFromIndex， bToIndex） 的，若以下表達式為真，則共享一個真前綴：

{@code
                (aToIndex - aFromIndex) != (bToIndex - bFromIndex) &&
                Arrays.equals(a, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex),
                              b, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
            }

新增9。

Java 文件 java.util.Arrays.mismatch(.*int[], .*int, .*int, .*int[], .*int, .*int)。

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

適用於

Mismatch(Int16[], Int32, Int32, Int16[], Int32, Int32)

尋找並回傳兩個陣列在指定範圍內首次不匹配 short 的相對索引，否則若未找到不匹配則返回 -1。

[Android.Runtime.Register("mismatch", "([SII[SII)I", "", ApiSince=33)]
public static int Mismatch(short[] a, int aFromIndex, int aToIndex, short[] b, int bFromIndex, int bToIndex);
[<Android.Runtime.Register("mismatch", "([SII[SII)I", "", ApiSince=33)>]
static member Mismatch : int16[] * int * int * int16[] * int * int -> int

參數

a
Int16[]

第一個被測試不匹配的陣列

aFromIndex
Int32

第一個待測試陣列中第一個元素的索引（包含索引）

aToIndex
Int32

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

b
Int16[]

第二個要測試是否不匹配的陣列

bFromIndex
Int32

第二個待測陣列中第一個元素的索引（包含）

bToIndex
Int32

第二個待測試陣列中最後一個元素的索引（排他）

傳回

Int32

在指定範圍內，兩個陣列第一次不匹配的相對指標，否則 -1為 。

屬性
RegisterAttribute

備註

尋找並回傳兩個陣列在指定範圍內首次不匹配 short 的相對索引，否則若未找到不匹配則返回 -1。 指數範圍範圍為 0（含）至較小範圍的長度（含）。

若兩個陣列在指定範圍內共享一個前綴，則回傳的相對索引即為該前綴的長度，因此在相應陣列中該相對索引的兩個元素存在不匹配。 若一個陣列在指定範圍內是另一個陣列的適當前綴，則回傳的相對索引即為較小範圍的長度，因此相對索引僅適用於較大範圍的陣列。 除此之外，沒有不匹配。

兩個null非陣列，ba且分別具有指定範圍 [aFromIndex， aToIndex） 和 [bFromIndex， bToIndex） ，若以下表達式為真，則共享一個共同的前pl綴長度：

{@code
                pl >= 0 &&
                pl < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex) &&
                Arrays.equals(a, aFromIndex, aFromIndex + pl, b, bFromIndex, bFromIndex + pl) &&
                a[aFromIndex + pl] != b[bFromIndex + pl]
            }

注意，常見的前綴長度 0 表示每個陣列的前端元素不匹配。

兩個非null 陣列， ab 且分別具有指定範圍 [aFromIndex， aToIndex） 和 [bFromIndex， bToIndex） 的，若以下表達式為真，則共享一個真前綴：

{@code
                (aToIndex - aFromIndex) != (bToIndex - bFromIndex) &&
                Arrays.equals(a, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex),
                              b, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
            }

新增9。

Java 文件 java.util.Arrays.mismatch(.*short[], .*int, .*int, .*short[], .*int, .*int)。

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

適用於

Mismatch(Double[], Int32, Int32, Double[], Int32, Int32)

尋找並回傳兩個陣列在指定範圍內首次不匹配 double 的相對索引，否則若未找到不匹配則返回 -1。

[Android.Runtime.Register("mismatch", "([DII[DII)I", "", ApiSince=33)]
public static int Mismatch(double[] a, int aFromIndex, int aToIndex, double[] b, int bFromIndex, int bToIndex);
[<Android.Runtime.Register("mismatch", "([DII[DII)I", "", ApiSince=33)>]
static member Mismatch : double[] * int * int * double[] * int * int -> int

參數

a
Double[]

第一個被測試不匹配的陣列

aFromIndex
Int32

第一個待測試陣列中第一個元素的索引（包含索引）

aToIndex
Int32

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

b
Double[]

第二個要測試是否不匹配的陣列

bFromIndex
Int32

第二個待測陣列中第一個元素的索引（包含）

bToIndex
Int32

第二個待測試陣列中最後一個元素的索引（排他）

傳回

Int32

在指定範圍內，兩個陣列第一次不匹配的相對指標，否則 -1為 。

屬性
RegisterAttribute

備註

尋找並回傳兩個陣列在指定範圍內首次不匹配 double 的相對索引，否則若未找到不匹配則返回 -1。 指數範圍範圍為 0（含）至較小範圍的長度（含）。

若兩個陣列在指定範圍內共享一個前綴，則回傳的相對索引即為該前綴的長度，因此在相應陣列中該相對索引的兩個元素存在不匹配。 若一個陣列在指定範圍內是另一個陣列的適當前綴，則回傳的相對索引即為較小範圍的長度，因此相對索引僅適用於較大範圍的陣列。 除此之外，沒有不匹配。

兩個null非陣列，ba且分別具有指定範圍 [aFromIndex， aToIndex） 和 [bFromIndex， bToIndex） ，若以下表達式為真，則共享一個共同的前pl綴長度：

{@code
                pl >= 0 &&
                pl < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex) &&
                Arrays.equals(a, aFromIndex, aFromIndex + pl, b, bFromIndex, bFromIndex + pl) &&
                Double.compare(a[aFromIndex + pl], b[bFromIndex + pl]) != 0
            }

注意，常見的前綴長度 0 表示每個陣列的前端元素不匹配。

兩個非null 陣列， ab 且分別具有指定範圍 [aFromIndex， aToIndex） 和 [bFromIndex， bToIndex） 的，若以下表達式為真，則共享一個真前綴：

{@code
                (aToIndex - aFromIndex) != (bToIndex - bFromIndex) &&
                Arrays.equals(a, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex),
                              b, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
            }

新增9。

Java 文件 java.util.Arrays.mismatch(.*double[], .*int, .*int, .*double[], .*int, .*int)。

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

適用於

Mismatch(Char[], Int32, Int32, Char[], Int32, Int32)

尋找並回傳兩個陣列在指定範圍內首次不匹配 char 的相對索引，否則若未找到不匹配則返回 -1。

[Android.Runtime.Register("mismatch", "([CII[CII)I", "", ApiSince=33)]
public static int Mismatch(char[] a, int aFromIndex, int aToIndex, char[] b, int bFromIndex, int bToIndex);
[<Android.Runtime.Register("mismatch", "([CII[CII)I", "", ApiSince=33)>]
static member Mismatch : char[] * int * int * char[] * int * int -> int

參數

a
Char[]

第一個被測試不匹配的陣列

aFromIndex
Int32

第一個待測試陣列中第一個元素的索引（包含索引）

aToIndex
Int32

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

b
Char[]

第二個要測試是否不匹配的陣列

bFromIndex
Int32

第二個待測陣列中第一個元素的索引（包含）

bToIndex
Int32

第二個待測試陣列中最後一個元素的索引（排他）

傳回

Int32

在指定範圍內，兩個陣列第一次不匹配的相對指標，否則 -1為 。

屬性
RegisterAttribute

備註

尋找並回傳兩個陣列在指定範圍內首次不匹配 char 的相對索引，否則若未找到不匹配則返回 -1。 指數範圍範圍為 0（含）至較小範圍的長度（含）。

若兩個陣列在指定範圍內共享一個前綴，則回傳的相對索引即為該前綴的長度，因此在相應陣列中該相對索引的兩個元素存在不匹配。 若一個陣列在指定範圍內是另一個陣列的適當前綴，則回傳的相對索引即為較小範圍的長度，因此相對索引僅適用於較大範圍的陣列。 除此之外，沒有不匹配。

兩個null非陣列，ba且分別具有指定範圍 [aFromIndex， aToIndex） 和 [bFromIndex， bToIndex） ，若以下表達式為真，則共享一個共同的前pl綴長度：

{@code
                pl >= 0 &&
                pl < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex) &&
                Arrays.equals(a, aFromIndex, aFromIndex + pl, b, bFromIndex, bFromIndex + pl) &&
                a[aFromIndex + pl] != b[bFromIndex + pl]
            }

注意，常見的前綴長度 0 表示每個陣列的前端元素不匹配。

兩個非null 陣列， ab 且分別具有指定範圍 [aFromIndex， aToIndex） 和 [bFromIndex， bToIndex） 的，若以下表達式為真，則共享一個真前綴：

{@code
                (aToIndex - aFromIndex) != (bToIndex - bFromIndex) &&
                Arrays.equals(a, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex),
                              b, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
            }

新增9。

Java 文件 java.util.Arrays.mismatch(.*char[], .*int, .*int, .*char[], .*int, .*int)。

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

適用於

Mismatch(Byte[], Int32, Int32, Byte[], Int32, Int32)

尋找並回傳兩個陣列在指定範圍內首次不匹配 byte 的相對索引，否則若未找到不匹配則返回 -1。

[Android.Runtime.Register("mismatch", "([BII[BII)I", "", ApiSince=33)]
public static int Mismatch(byte[]? a, int aFromIndex, int aToIndex, byte[]? b, int bFromIndex, int bToIndex);
[<Android.Runtime.Register("mismatch", "([BII[BII)I", "", ApiSince=33)>]
static member Mismatch : byte[] * int * int * byte[] * int * int -> int

參數

a
Byte[]

第一個被測試不匹配的陣列

aFromIndex
Int32

第一個待測試陣列中第一個元素的索引（包含索引）

aToIndex
Int32

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

b
Byte[]

第二個要測試是否不匹配的陣列

bFromIndex
Int32

第二個待測陣列中第一個元素的索引（包含）

bToIndex
Int32

第二個待測試陣列中最後一個元素的索引（排他）

傳回

Int32

在指定範圍內，兩個陣列第一次不匹配的相對指標，否則 -1為 。

屬性
RegisterAttribute

備註

尋找並回傳兩個陣列在指定範圍內首次不匹配 byte 的相對索引，否則若未找到不匹配則返回 -1。 指數範圍範圍為 0（含）至較小範圍的長度（含）。

若兩個陣列在指定範圍內共享一個前綴，則回傳的相對索引即為該前綴的長度，因此在相應陣列中該相對索引的兩個元素存在不匹配。 若一個陣列在指定範圍內是另一個陣列的適當前綴，則回傳的相對索引即為較小範圍的長度，因此相對索引僅適用於較大範圍的陣列。 除此之外，沒有不匹配。

兩個null非陣列，ba且分別具有指定範圍 [aFromIndex， aToIndex） 和 [bFromIndex， bToIndex） ，若以下表達式為真，則共享一個共同的前pl綴長度：

{@code
                pl >= 0 &&
                pl < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex) &&
                Arrays.equals(a, aFromIndex, aFromIndex + pl, b, bFromIndex, bFromIndex + pl) &&
                a[aFromIndex + pl] != b[bFromIndex + pl]
            }

注意，常見的前綴長度 0 表示每個陣列的前端元素不匹配。

兩個非null 陣列， ab 且分別具有指定範圍 [aFromIndex， aToIndex） 和 [bFromIndex， bToIndex） 的，若以下表達式為真，則共享一個真前綴：

{@code
                (aToIndex - aFromIndex) != (bToIndex - bFromIndex) &&
                Arrays.equals(a, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex),
                              b, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
            }

新增9。

Java 文件 java.util.Arrays.mismatch(.*byte[], .*int, .*int, .*byte[], .*int, .*int)。

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

適用於

Mismatch(Boolean[], Int32, Int32, Boolean[], Int32, Int32)

尋找並回傳兩個陣列在指定範圍內首次不匹配 boolean 的相對索引，否則若未找到不匹配則返回 -1。

[Android.Runtime.Register("mismatch", "([ZII[ZII)I", "", ApiSince=33)]
public static int Mismatch(bool[] a, int aFromIndex, int aToIndex, bool[] b, int bFromIndex, int bToIndex);
[<Android.Runtime.Register("mismatch", "([ZII[ZII)I", "", ApiSince=33)>]
static member Mismatch : bool[] * int * int * bool[] * int * int -> int

參數

a
Boolean[]

第一個被測試不匹配的陣列

aFromIndex
Int32

第一個待測試陣列中第一個元素的索引（包含索引）

aToIndex
Int32

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

b
Boolean[]

第二個要測試是否不匹配的陣列

bFromIndex
Int32

第二個待測陣列中第一個元素的索引（包含）

bToIndex
Int32

第二個待測試陣列中最後一個元素的索引（排他）

傳回

Int32

在指定範圍內，兩個陣列第一次不匹配的相對指標，否則 -1為 。

屬性
RegisterAttribute

備註

尋找並回傳兩個陣列在指定範圍內首次不匹配 boolean 的相對索引，否則若未找到不匹配則返回 -1。 指數範圍範圍為 0（含）至較小範圍的長度（含）。

若兩個陣列在指定範圍內共享一個前綴，則回傳的相對索引即為該前綴的長度，因此在相應陣列中該相對索引的兩個元素存在不匹配。 若一個陣列在指定範圍內是另一個陣列的適當前綴，則回傳的相對索引即為較小範圍的長度，因此相對索引僅適用於較大範圍的陣列。 除此之外，沒有不匹配。

兩個null非陣列，ba且分別具有指定範圍 [aFromIndex， aToIndex） 和 [bFromIndex， bToIndex） ，若以下表達式為真，則共享一個共同的前pl綴長度：

{@code
                pl >= 0 &&
                pl < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex) &&
                Arrays.equals(a, aFromIndex, aFromIndex + pl, b, bFromIndex, bFromIndex + pl) &&
                a[aFromIndex + pl] != b[bFromIndex + pl]
            }

注意，常見的前綴長度 0 表示每個陣列的前端元素不匹配。

兩個非null 陣列， ab 且分別具有指定範圍 [aFromIndex， aToIndex） 和 [bFromIndex， bToIndex） 的，若以下表達式為真，則共享一個真前綴：

{@code
                (aToIndex - aFromIndex) != (bToIndex - bFromIndex) &&
                Arrays.equals(a, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex),
                              b, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
            }

新增9。

Java 文件 java.util.Arrays.mismatch(.*boolean[], .*int, .*int, .*boolean[], .*int, .*int)。

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

適用於

Mismatch(Object[], Int32, Int32, Object[], Int32, Int32)

尋找並回傳兩個陣列在指定範圍內首次不匹配 Object 的相對索引，否則若未找到不匹配則返回 -1。

[Android.Runtime.Register("mismatch", "([Ljava/lang/Object;II[Ljava/lang/Object;II)I", "", ApiSince=33)]
public static int Mismatch(Java.Lang.Object[] a, int aFromIndex, int aToIndex, Java.Lang.Object[] b, int bFromIndex, int bToIndex);
[<Android.Runtime.Register("mismatch", "([Ljava/lang/Object;II[Ljava/lang/Object;II)I", "", ApiSince=33)>]
static member Mismatch : Java.Lang.Object[] * int * int * Java.Lang.Object[] * int * int -> int

參數

a
Object[]

第一個被測試不匹配的陣列

aFromIndex
Int32

第一個待測試陣列中第一個元素的索引（包含索引）

aToIndex
Int32

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

b
Object[]

第二個要測試是否不匹配的陣列

bFromIndex
Int32

第二個待測陣列中第一個元素的索引（包含）

bToIndex
Int32

第二個待測試陣列中最後一個元素的索引（排他）

傳回

Int32

在指定範圍內，兩個陣列第一次不匹配的相對指標，否則 -1為 。

屬性
RegisterAttribute

備註

尋找並回傳兩個陣列在指定範圍內首次不匹配 Object 的相對索引，否則若未找到不匹配則返回 -1。 指數範圍範圍為 0（含）至較小範圍的長度（含）。

若兩個陣列在指定範圍內共享一個前綴，則回傳的相對索引即為該前綴的長度，因此在相應陣列中該相對索引的兩個元素存在不匹配。 若一個陣列在指定範圍內是另一個陣列的適當前綴，則回傳的相對索引即為較小範圍的長度，因此相對索引僅適用於較大範圍的陣列。 除此之外，沒有不匹配。

兩個null非陣列，ba且分別具有指定範圍 [aFromIndex， atoIndex） 和 [bFromIndex， btoIndex） ，若以下表達式為真，則共享一個共同的前pl綴長度：

{@code
                pl >= 0 &&
                pl < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex) &&
                Arrays.equals(a, aFromIndex, aFromIndex + pl, b, bFromIndex, bFromIndex + pl) &&
                !Objects.equals(a[aFromIndex + pl], b[bFromIndex + pl])
            }

注意，常見的前綴長度 0 表示每個陣列的前端元素不匹配。

兩個非null 陣列， ab 且分別具有指定範圍 [aFromIndex， atoIndex） 和 [bFromIndex， btoIndex） 的，若以下表達式為真，則共享一個真前綴：

{@code
                (aToIndex - aFromIndex) != (bToIndex - bFromIndex) &&
                Arrays.equals(a, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex),
                              b, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
            }

新增9。

Java 文件 java.util.Arrays.mismatch(java.lang.Object[], int, int, java.lang.Object[], int, int)。

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

適用於

Mismatch(Single[], Single[])

尋找並回傳兩個 float 陣列間第一個不匹配的索引，否則若未找到不匹配則回傳 -1。

[Android.Runtime.Register("mismatch", "([F[F)I", "", ApiSince=33)]
public static int Mismatch(float[] a, float[] b);
[<Android.Runtime.Register("mismatch", "([F[F)I", "", ApiSince=33)>]
static member Mismatch : single[] * single[] -> int

參數

a
Single[]

第一個被測試不匹配的陣列

b
Single[]

第二個要測試是否不匹配的陣列

傳回

Int32

兩個陣列間第一個不匹配點的索引，否則 -1為 。

屬性
RegisterAttribute

備註

尋找並回傳兩個 float 陣列間第一個不匹配的索引，否則若未找到不匹配則回傳 -1。 索引範圍從 0（含）到較小陣列的長度（含）不等。

若兩個陣列共用一個前綴，則回傳的索引為該前綴的長度，因此在相應陣列中該索引的兩個元素存在不匹配。 若一個陣列是另一個陣列的真前綴，則回傳的索引為較小陣列的長度，因此該索引僅適用於較大陣列。 除此之外，沒有不匹配。

兩個非陣null 列 和 ab，若以下表達式為真，則共享一個 pl 長度為 的前綴：

{@code
                pl >= 0 &&
                pl < Math.min(a.length, b.length) &&
                Arrays.equals(a, 0, pl, b, 0, pl) &&
                Float.compare(a[pl], b[pl]) != 0
            }

注意，常見的前綴長度 0 表示每個陣列的前端元素不匹配。

兩個非陣null 列 和 ab，若以下表達式為真，則共享一個適當的前綴：

{@code
                a.length != b.length &&
                Arrays.equals(a, 0, Math.min(a.length, b.length),
                              b, 0, Math.min(a.length, b.length))
            }

新增9。

Java 文件 java.util.Arrays.mismatch(.*float[], .*float[])。

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

適用於

Mismatch(Int64[], Int64[])

尋找並回傳兩個 long 陣列間第一個不匹配的索引，否則若未找到不匹配則回傳 -1。

[Android.Runtime.Register("mismatch", "([J[J)I", "", ApiSince=33)]
public static int Mismatch(long[] a, long[] b);
[<Android.Runtime.Register("mismatch", "([J[J)I", "", ApiSince=33)>]
static member Mismatch : int64[] * int64[] -> int

參數

a
Int64[]

第一個被測試不匹配的陣列

b
Int64[]

第二個要測試是否不匹配的陣列

傳回

Int32

兩個陣列間第一個不匹配點的索引，否則 -1為 。

屬性
RegisterAttribute

備註

尋找並回傳兩個 long 陣列間第一個不匹配的索引，否則若未找到不匹配則回傳 -1。 索引範圍從 0（含）到較小陣列的長度（含）不等。

若兩個陣列共用一個前綴，則回傳的索引為該前綴的長度，因此在相應陣列中該索引的兩個元素存在不匹配。 若一個陣列是另一個陣列的真前綴，則回傳的索引為較小陣列的長度，因此該索引僅適用於較大陣列。 除此之外，沒有不匹配。

兩個非陣null 列 和 ab，若以下表達式為真，則共享一個 pl 長度為 的前綴：

{@code
                pl >= 0 &&
                pl < Math.min(a.length, b.length) &&
                Arrays.equals(a, 0, pl, b, 0, pl) &&
                a[pl] != b[pl]
            }

注意，常見的前綴長度 0 表示每個陣列的前端元素不匹配。

兩個非陣null 列 和 ab，若以下表達式為真，則共享一個適當的前綴：

{@code
                a.length != b.length &&
                Arrays.equals(a, 0, Math.min(a.length, b.length),
                              b, 0, Math.min(a.length, b.length))
            }

新增9。

Java 文件 java.util.Arrays.mismatch(.*long[], .*long[])。

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

適用於

Mismatch(Int32[], Int32[])

尋找並回傳兩個 int 陣列間第一個不匹配的索引，否則若未找到不匹配則回傳 -1。

[Android.Runtime.Register("mismatch", "([I[I)I", "", ApiSince=33)]
public static int Mismatch(int[] a, int[] b);
[<Android.Runtime.Register("mismatch", "([I[I)I", "", ApiSince=33)>]
static member Mismatch : int[] * int[] -> int

參數

a
Int32[]

第一個被測試不匹配的陣列

b
Int32[]

第二個要測試是否不匹配的陣列

傳回

Int32

兩個陣列間第一個不匹配點的索引，否則 -1為 。

屬性
RegisterAttribute

備註

尋找並回傳兩個 int 陣列間第一個不匹配的索引，否則若未找到不匹配則回傳 -1。 索引範圍從 0（含）到較小陣列的長度（含）不等。

若兩個陣列共用一個前綴，則回傳的索引為該前綴的長度，因此在相應陣列中該索引的兩個元素存在不匹配。 若一個陣列是另一個陣列的真前綴，則回傳的索引為較小陣列的長度，因此該索引僅適用於較大陣列。 除此之外，沒有不匹配。

兩個非陣null 列 和 ab，若以下表達式為真，則共享一個 pl 長度為 的前綴：

{@code
                pl >= 0 &&
                pl < Math.min(a.length, b.length) &&
                Arrays.equals(a, 0, pl, b, 0, pl) &&
                a[pl] != b[pl]
            }

注意，常見的前綴長度 0 表示每個陣列的前端元素不匹配。

兩個非陣null 列 和 ab，若以下表達式為真，則共享一個適當的前綴：

{@code
                a.length != b.length &&
                Arrays.equals(a, 0, Math.min(a.length, b.length),
                              b, 0, Math.min(a.length, b.length))
            }

新增9。

Java 文件 java.util.Arrays.mismatch(.*int[], .*int[])。

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

適用於

Mismatch(Int16[], Int16[])

尋找並回傳兩個 short 陣列間第一個不匹配的索引，否則若未找到不匹配則回傳 -1。

[Android.Runtime.Register("mismatch", "([S[S)I", "", ApiSince=33)]
public static int Mismatch(short[] a, short[] b);
[<Android.Runtime.Register("mismatch", "([S[S)I", "", ApiSince=33)>]
static member Mismatch : int16[] * int16[] -> int

參數

a
Int16[]

第一個被測試不匹配的陣列

b
Int16[]

第二個要測試是否不匹配的陣列

傳回

Int32

兩個陣列間第一個不匹配點的索引，否則 -1為 。

屬性
RegisterAttribute

備註

尋找並回傳兩個 short 陣列間第一個不匹配的索引，否則若未找到不匹配則回傳 -1。 索引範圍從 0（含）到較小陣列的長度（含）不等。

若兩個陣列共用一個前綴，則回傳的索引為該前綴的長度，因此在相應陣列中該索引的兩個元素存在不匹配。 若一個陣列是另一個陣列的真前綴，則回傳的索引為較小陣列的長度，因此該索引僅適用於較大陣列。 除此之外，沒有不匹配。

兩個非陣null 列 和 ab，若以下表達式為真，則共享一個 pl 長度為 的前綴：

{@code
                pl >= 0 &&
                pl < Math.min(a.length, b.length) &&
                Arrays.equals(a, 0, pl, b, 0, pl) &&
                a[pl] != b[pl]
            }

注意，常見的前綴長度 0 表示每個陣列的前端元素不匹配。

兩個非陣null 列 和 ab，若以下表達式為真，則共享一個適當的前綴：

{@code
                a.length != b.length &&
                Arrays.equals(a, 0, Math.min(a.length, b.length),
                              b, 0, Math.min(a.length, b.length))
            }

新增9。

Java 文件 java.util.Arrays.mismatch(.*short[], .*short[])。

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

適用於

Mismatch(Double[], Double[])

尋找並回傳兩個 double 陣列間第一個不匹配的索引，否則若未找到不匹配則回傳 -1。

[Android.Runtime.Register("mismatch", "([D[D)I", "", ApiSince=33)]
public static int Mismatch(double[] a, double[] b);
[<Android.Runtime.Register("mismatch", "([D[D)I", "", ApiSince=33)>]
static member Mismatch : double[] * double[] -> int

參數

a
Double[]

第一個被測試不匹配的陣列

b
Double[]

第二個要測試是否不匹配的陣列

傳回

Int32

兩個陣列間第一個不匹配點的索引，否則 -1為 。

屬性
RegisterAttribute

備註

尋找並回傳兩個 double 陣列間第一個不匹配的索引，否則若未找到不匹配則回傳 -1。 索引範圍從 0（含）到較小陣列的長度（含）不等。

若兩個陣列共用一個前綴，則回傳的索引為該前綴的長度，因此在相應陣列中該索引的兩個元素存在不匹配。 若一個陣列是另一個陣列的真前綴，則回傳的索引為較小陣列的長度，因此該索引僅適用於較大陣列。 除此之外，沒有不匹配。

兩個非陣null 列 和 ab，若以下表達式為真，則共享一個 pl 長度為 的前綴：

{@code
                pl >= 0 &&
                pl < Math.min(a.length, b.length) &&
                Arrays.equals(a, 0, pl, b, 0, pl) &&
                Double.compare(a[pl], b[pl]) != 0
            }

注意，常見的前綴長度 0 表示每個陣列的前端元素不匹配。

兩個非陣null 列 和 ab，若以下表達式為真，則共享一個適當的前綴：

{@code
                a.length != b.length &&
                Arrays.equals(a, 0, Math.min(a.length, b.length),
                              b, 0, Math.min(a.length, b.length))
            }

新增9。

Java 文件 java.util.Arrays.mismatch(.*double[], .*double[])。

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

適用於

Mismatch(Char[], Char[])

尋找並回傳兩個 char 陣列間第一個不匹配的索引，否則若未找到不匹配則回傳 -1。

[Android.Runtime.Register("mismatch", "([C[C)I", "", ApiSince=33)]
public static int Mismatch(char[] a, char[] b);
[<Android.Runtime.Register("mismatch", "([C[C)I", "", ApiSince=33)>]
static member Mismatch : char[] * char[] -> int

參數

a
Char[]

第一個被測試不匹配的陣列

b
Char[]

第二個要測試是否不匹配的陣列

傳回

Int32

兩個陣列間第一個不匹配點的索引，否則 -1為 。

屬性
RegisterAttribute

備註

尋找並回傳兩個 char 陣列間第一個不匹配的索引，否則若未找到不匹配則回傳 -1。 索引範圍從 0（含）到較小陣列的長度（含）不等。

若兩個陣列共用一個前綴，則回傳的索引為該前綴的長度，因此在相應陣列中該索引的兩個元素存在不匹配。 若一個陣列是另一個陣列的真前綴，則回傳的索引為較小陣列的長度，因此該索引僅適用於較大陣列。 除此之外，沒有不匹配。

兩個非陣null 列 和 ab，若以下表達式為真，則共享一個 pl 長度為 的前綴：

{@code
                pl >= 0 &&
                pl < Math.min(a.length, b.length) &&
                Arrays.equals(a, 0, pl, b, 0, pl) &&
                a[pl] != b[pl]
            }

注意，常見的前綴長度 0 表示每個陣列的前端元素不匹配。

兩個非陣null 列 和 ab，若以下表達式為真，則共享一個適當的前綴：

{@code
                a.length != b.length &&
                Arrays.equals(a, 0, Math.min(a.length, b.length),
                              b, 0, Math.min(a.length, b.length))
            }

新增9。

Java 文件 java.util.Arrays.mismatch(.*char[], .*char[])。

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

適用於

Mismatch(Byte[], Byte[])

尋找並回傳兩個 byte 陣列間第一個不匹配的索引，否則若未找到不匹配則回傳 -1。

[Android.Runtime.Register("mismatch", "([B[B)I", "", ApiSince=33)]
public static int Mismatch(byte[] a, byte[] b);
[<Android.Runtime.Register("mismatch", "([B[B)I", "", ApiSince=33)>]
static member Mismatch : byte[] * byte[] -> int

參數

a
Byte[]

第一個被測試不匹配的陣列

b
Byte[]

第二個要測試是否不匹配的陣列

傳回

Int32

兩個陣列間第一個不匹配點的索引，否則 -1為 。

屬性
RegisterAttribute

備註

尋找並回傳兩個 byte 陣列間第一個不匹配的索引，否則若未找到不匹配則回傳 -1。 索引範圍從 0（含）到較小陣列的長度（含）不等。

若兩個陣列共用一個前綴，則回傳的索引為該前綴的長度，因此在相應陣列中該索引的兩個元素存在不匹配。 若一個陣列是另一個陣列的真前綴，則回傳的索引為較小陣列的長度，因此該索引僅適用於較大陣列。 除此之外，沒有不匹配。

兩個非陣null 列 和 ab，若以下表達式為真，則共享一個 pl 長度為 的前綴：

{@code
                pl >= 0 &&
                pl < Math.min(a.length, b.length) &&
                Arrays.equals(a, 0, pl, b, 0, pl) &&
                a[pl] != b[pl]
            }

注意，常見的前綴長度 0 表示每個陣列的前端元素不匹配。

兩個非陣null 列 和 ab，若以下表達式為真，則共享一個適當的前綴：

{@code
                a.length != b.length &&
                Arrays.equals(a, 0, Math.min(a.length, b.length),
                              b, 0, Math.min(a.length, b.length))
            }

新增9。

Java 文件 java.util.Arrays.mismatch(.*byte[], .*byte[])。

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

適用於

Mismatch(Boolean[], Boolean[])

尋找並回傳兩個 boolean 陣列間第一個不匹配的索引，否則若未找到不匹配則回傳 -1。

[Android.Runtime.Register("mismatch", "([Z[Z)I", "", ApiSince=33)]
public static int Mismatch(bool[] a, bool[] b);
[<Android.Runtime.Register("mismatch", "([Z[Z)I", "", ApiSince=33)>]
static member Mismatch : bool[] * bool[] -> int

參數

a
Boolean[]

第一個被測試不匹配的陣列

b
Boolean[]

第二個要測試是否不匹配的陣列

傳回

Int32

兩個陣列間第一個不匹配點的索引，否則 -1為 。

屬性
RegisterAttribute

備註

尋找並回傳兩個 boolean 陣列間第一個不匹配的索引，否則若未找到不匹配則回傳 -1。 索引範圍從 0（含）到較小陣列的長度（含）不等。

若兩個陣列共用一個前綴，則回傳的索引為該前綴的長度，因此在相應陣列中該索引的兩個元素存在不匹配。 若一個陣列是另一個陣列的真前綴，則回傳的索引為較小陣列的長度，因此該索引僅適用於較大陣列。 除此之外，沒有不匹配。

兩個非陣null 列 和 ab，若以下表達式為真，則共享一個 pl 長度為 的前綴：

{@code
                pl >= 0 &&
                pl < Math.min(a.length, b.length) &&
                Arrays.equals(a, 0, pl, b, 0, pl) &&
                a[pl] != b[pl]
            }

注意，常見的前綴長度 0 表示每個陣列的前端元素不匹配。

兩個非陣null 列 和 ab，若以下表達式為真，則共享一個適當的前綴：

{@code
                a.length != b.length &&
                Arrays.equals(a, 0, Math.min(a.length, b.length),
                              b, 0, Math.min(a.length, b.length))
            }

新增9。

Java 文件 java.util.Arrays.mismatch(.*boolean[], .*boolean[])。

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

適用於

Mismatch(Object[], Object[])

尋找並回傳兩個 Object 陣列間第一個不匹配的索引，否則若未找到不匹配則回傳 -1。

[Android.Runtime.Register("mismatch", "([Ljava/lang/Object;[Ljava/lang/Object;)I", "", ApiSince=33)]
public static int Mismatch(Java.Lang.Object[] a, Java.Lang.Object[] b);
[<Android.Runtime.Register("mismatch", "([Ljava/lang/Object;[Ljava/lang/Object;)I", "", ApiSince=33)>]
static member Mismatch : Java.Lang.Object[] * Java.Lang.Object[] -> int

參數

a
Object[]

第一個被測試不匹配的陣列

b
Object[]

第二個要測試是否不匹配的陣列

傳回

Int32

兩個陣列間第一個不匹配點的索引，否則 -1為 。

屬性
RegisterAttribute

備註

尋找並回傳兩個 Object 陣列間第一個不匹配的索引，否則若未找到不匹配則回傳 -1。 索引範圍從 0（含）到較小陣列的長度（含）不等。

若兩個陣列共用一個前綴，則回傳的索引為該前綴的長度，因此在相應陣列中該索引的兩個元素存在不匹配。 若一個陣列是另一個陣列的真前綴，則回傳的索引為較小陣列的長度，因此該索引僅適用於較大陣列。 除此之外，沒有不匹配。

兩個非陣null 列 和 ab，若以下表達式為真，則共享一個 pl 長度為 的前綴：

{@code
                pl >= 0 &&
                pl < Math.min(a.length, b.length) &&
                Arrays.equals(a, 0, pl, b, 0, pl) &&
                !Objects.equals(a[pl], b[pl])
            }

注意，常見的前綴長度 0 表示每個陣列的前端元素不匹配。

兩個非陣null 列 和 ab，若以下表達式為真，則共享一個適當的前綴：

{@code
                a.length != b.length &&
                Arrays.equals(a, 0, Math.min(a.length, b.length),
                              b, 0, Math.min(a.length, b.length))
            }

新增9。

Java 文件 java.util.Arrays.mismatch(java.lang.Object[], java.lang.Object[])。

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

適用於

Mismatch(Object[], Object[], IComparator)

尋找並回傳兩個 Object 陣列間第一個不匹配的索引，否則若未找到不匹配則回傳 -1。

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

參數

a
Object[]

第一個被測試不匹配的陣列

b
Object[]

第二個要測試是否不匹配的陣列

cmp
IComparator

比較器用來比較陣列元素

傳回

Int32

兩個陣列間第一個不匹配點的索引，否則 -1為 。

屬性
RegisterAttribute JavaTypeParametersAttribute

備註

尋找並回傳兩個 Object 陣列間第一個不匹配的索引，否則若未找到不匹配則回傳 -1。 索引範圍從 0（含）到較小陣列的長度（含）不等。

指定的比較器用來判斷每個陣列中的兩個元素是否不相等。

若兩個陣列共用一個前綴，則回傳的索引為該前綴的長度，因此在相應陣列中該索引的兩個元素存在不匹配。 若一個陣列是另一個陣列的真前綴，則回傳的索引為較小陣列的長度，因此該索引僅適用於較大陣列。 除此之外，沒有不匹配。

兩個非陣null 列 和 ab，若以下表達式為真，則共享一個 pl 長度為 的前綴：

{@code
                pl >= 0 &&
                pl < Math.min(a.length, b.length) &&
                Arrays.equals(a, 0, pl, b, 0, pl, cmp)
                cmp.compare(a[pl], b[pl]) != 0
            }

注意，常見的前綴長度 0 表示每個陣列的前端元素不匹配。

兩個非陣null 列 和 ab，若以下表達式為真，則共享一個適當的前綴：

{@code
                a.length != b.length &&
                Arrays.equals(a, 0, Math.min(a.length, b.length),
                              b, 0, Math.min(a.length, b.length),
                              cmp)
            }

新增9。

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

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

適用於