语言

Arrays.Mismatch 方法

定义

重载

名称 说明
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

比较数组元素的比较器

返回

指定范围中两个数组之间的第一个不匹配的相对索引,否则 -1。

特性

注解

查找并返回指定范围中两 Object 个数组之间的第一个不匹配的相对索引,否则如果未找到不匹配,则返回 -1。 索引的范围为 0(非独占),最大长度(含)为较小范围。

如果两个数组在指定范围内共享一个公共前缀,则返回的相对索引是公共前缀的长度,并且随后两个元素在相应数组中的相对索引之间不匹配。 如果一个数组是另一个数组的正确前缀,则超过指定的范围,则返回的相对索引是较小范围的长度,随后相对索引仅对具有较大范围的数组有效。 否则,不存在不匹配的情况。

如果以下表达式为 true,则分别使用两个非null 数组以及 ab 指定范围 [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 指示每个数组中的第一个元素不匹配。

如果以下表达式为 true,则分别使用两个非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>)。

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

适用于

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

要测试的第二个数组中最后一个元素的索引(独占)

返回

指定范围中两个数组之间的第一个不匹配的相对索引,否则 -1。

特性

注解

查找并返回指定范围中两 float 个数组之间的第一个不匹配的相对索引,否则如果未找到不匹配,则返回 -1。 索引的范围为 0(非独占),最大长度(含)为较小范围。

如果两个数组在指定范围内共享一个公共前缀,则返回的相对索引是公共前缀的长度,并且随后两个元素在相应数组中的相对索引之间不匹配。 如果一个数组是另一个数组的正确前缀,则超过指定的范围,则返回的相对索引是较小范围的长度,随后相对索引仅对具有较大范围的数组有效。 否则,不存在不匹配的情况。

如果以下表达式为 true,则分别使用两个非null 数组以及 ab 指定范围 [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 指示每个数组中的第一个元素不匹配。

如果以下表达式为 true,则分别使用两个非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)。

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

适用于

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

要测试的第二个数组中最后一个元素的索引(独占)

返回

指定范围中两个数组之间的第一个不匹配的相对索引,否则 -1。

特性

注解

查找并返回指定范围中两 long 个数组之间的第一个不匹配的相对索引,否则如果未找到不匹配,则返回 -1。 索引的范围为 0(非独占),最大长度(含)为较小范围。

如果两个数组在指定范围内共享一个公共前缀,则返回的相对索引是公共前缀的长度,并且随后两个元素在相应数组中的相对索引之间不匹配。 如果一个数组是另一个数组的正确前缀,则超过指定的范围,则返回的相对索引是较小范围的长度,随后相对索引仅对具有较大范围的数组有效。 否则,不存在不匹配的情况。

如果以下表达式为 true,则分别使用两个非null 数组以及 ab 指定范围 [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 指示每个数组中的第一个元素不匹配。

如果以下表达式为 true,则分别使用两个非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)。

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

适用于

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

要测试的第二个数组中最后一个元素的索引(独占)

返回

指定范围中两个数组之间的第一个不匹配的相对索引,否则 -1。

特性

注解

查找并返回指定范围中两 int 个数组之间的第一个不匹配的相对索引,否则如果未找到不匹配,则返回 -1。 索引的范围为 0(非独占),最大长度(含)为较小范围。

如果两个数组在指定范围内共享一个公共前缀,则返回的相对索引是公共前缀的长度,并且随后两个元素在相应数组中的相对索引之间不匹配。 如果一个数组是另一个数组的正确前缀,则超过指定的范围,则返回的相对索引是较小范围的长度,随后相对索引仅对具有较大范围的数组有效。 否则,不存在不匹配的情况。

如果以下表达式为 true,则分别使用两个非null 数组以及 ab 指定范围 [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 指示每个数组中的第一个元素不匹配。

如果以下表达式为 true,则分别使用两个非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)。

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

适用于

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

要测试的第二个数组中最后一个元素的索引(独占)

返回

指定范围中两个数组之间的第一个不匹配的相对索引,否则 -1。

特性

注解

查找并返回指定范围中两 short 个数组之间的第一个不匹配的相对索引,否则如果未找到不匹配,则返回 -1。 索引的范围为 0(非独占),最大长度(含)为较小范围。

如果两个数组在指定范围内共享一个公共前缀,则返回的相对索引是公共前缀的长度,并且随后两个元素在相应数组中的相对索引之间不匹配。 如果一个数组是另一个数组的正确前缀,则超过指定的范围,则返回的相对索引是较小范围的长度,随后相对索引仅对具有较大范围的数组有效。 否则,不存在不匹配的情况。

如果以下表达式为 true,则分别使用两个非null 数组以及 ab 指定范围 [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 指示每个数组中的第一个元素不匹配。

如果以下表达式为 true,则分别使用两个非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)。

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

适用于

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

要测试的第二个数组中最后一个元素的索引(独占)

返回

指定范围中两个数组之间的第一个不匹配的相对索引,否则 -1。

特性

注解

查找并返回指定范围中两 double 个数组之间的第一个不匹配的相对索引,否则如果未找到不匹配,则返回 -1。 索引的范围为 0(非独占),最大长度(含)为较小范围。

如果两个数组在指定范围内共享一个公共前缀,则返回的相对索引是公共前缀的长度,并且随后两个元素在相应数组中的相对索引之间不匹配。 如果一个数组是另一个数组的正确前缀,则超过指定的范围,则返回的相对索引是较小范围的长度,随后相对索引仅对具有较大范围的数组有效。 否则,不存在不匹配的情况。

如果以下表达式为 true,则分别使用两个非null 数组以及 ab 指定范围 [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 指示每个数组中的第一个元素不匹配。

如果以下表达式为 true,则分别使用两个非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)。

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

适用于

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

要测试的第二个数组中最后一个元素的索引(独占)

返回

指定范围中两个数组之间的第一个不匹配的相对索引,否则 -1。

特性

注解

查找并返回指定范围中两 char 个数组之间的第一个不匹配的相对索引,否则如果未找到不匹配,则返回 -1。 索引的范围为 0(非独占),最大长度(含)为较小范围。

如果两个数组在指定范围内共享一个公共前缀,则返回的相对索引是公共前缀的长度,并且随后两个元素在相应数组中的相对索引之间不匹配。 如果一个数组是另一个数组的正确前缀,则超过指定的范围,则返回的相对索引是较小范围的长度,随后相对索引仅对具有较大范围的数组有效。 否则,不存在不匹配的情况。

如果以下表达式为 true,则分别使用两个非null 数组以及 ab 指定范围 [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 指示每个数组中的第一个元素不匹配。

如果以下表达式为 true,则分别使用两个非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)。

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

适用于

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

要测试的第二个数组中最后一个元素的索引(独占)

返回

指定范围中两个数组之间的第一个不匹配的相对索引,否则 -1。

特性

注解

查找并返回指定范围中两 byte 个数组之间的第一个不匹配的相对索引,否则如果未找到不匹配,则返回 -1。 索引的范围为 0(非独占),最大长度(含)为较小范围。

如果两个数组在指定范围内共享一个公共前缀,则返回的相对索引是公共前缀的长度,并且随后两个元素在相应数组中的相对索引之间不匹配。 如果一个数组是另一个数组的正确前缀,则超过指定的范围,则返回的相对索引是较小范围的长度,随后相对索引仅对具有较大范围的数组有效。 否则,不存在不匹配的情况。

如果以下表达式为 true,则分别使用两个非null 数组以及 ab 指定范围 [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 指示每个数组中的第一个元素不匹配。

如果以下表达式为 true,则分别使用两个非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)。

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

适用于

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

要测试的第二个数组中最后一个元素的索引(独占)

返回

指定范围中两个数组之间的第一个不匹配的相对索引,否则 -1。

特性

注解

查找并返回指定范围中两 boolean 个数组之间的第一个不匹配的相对索引,否则如果未找到不匹配,则返回 -1。 索引的范围为 0(非独占),最大长度(含)为较小范围。

如果两个数组在指定范围内共享一个公共前缀,则返回的相对索引是公共前缀的长度,并且随后两个元素在相应数组中的相对索引之间不匹配。 如果一个数组是另一个数组的正确前缀,则超过指定的范围,则返回的相对索引是较小范围的长度,随后相对索引仅对具有较大范围的数组有效。 否则,不存在不匹配的情况。

如果以下表达式为 true,则分别使用两个非null 数组以及 ab 指定范围 [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 指示每个数组中的第一个元素不匹配。

如果以下表达式为 true,则分别使用两个非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)。

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

适用于

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

要测试的第二个数组中最后一个元素的索引(独占)

返回

指定范围中两个数组之间的第一个不匹配的相对索引,否则 -1。

特性

注解

查找并返回指定范围中两 Object 个数组之间的第一个不匹配的相对索引,否则如果未找到不匹配,则返回 -1。 索引的范围为 0(非独占),最大长度(含)为较小范围。

如果两个数组在指定范围内共享一个公共前缀,则返回的相对索引是公共前缀的长度,并且随后两个元素在相应数组中的相对索引之间不匹配。 如果一个数组是另一个数组的正确前缀,则超过指定的范围,则返回的相对索引是较小范围的长度,随后相对索引仅对具有较大范围的数组有效。 否则,不存在不匹配的情况。

如果以下表达式为 true,则分别使用两个非null 数组以及 ab 指定范围 [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 指示每个数组中的第一个元素不匹配。

如果以下表达式为 true,则分别使用两个非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)。

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

适用于

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

要针对不匹配测试的第二个数组

返回

两个数组之间的第一个不匹配的索引,否则 -1。

特性

注解

查找并返回两 float 个数组之间第一个不匹配的索引,否则如果未找到不匹配,则返回 -1。 索引的范围为 0(非独占),最大长度(含)为较小的数组。

如果两个数组共享一个通用前缀,则返回的索引是公共前缀的长度,随后会在相应数组中的该索引处的两个元素之间不匹配。 如果一个数组是另一个数组的正确前缀,则返回的索引是较小的数组的长度,并且随后索引仅对较大的数组有效。 否则,不存在不匹配的情况。

两个非null 数组, a 如果以下表达式为 true,则 b共享长度的公共 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 数组, a 如果以下表达式为 true,则 b共享正确的前缀:

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

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

适用于

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

要针对不匹配测试的第二个数组

返回

两个数组之间的第一个不匹配的索引,否则 -1。

特性

注解

查找并返回两 long 个数组之间第一个不匹配的索引,否则如果未找到不匹配,则返回 -1。 索引的范围为 0(非独占),最大长度(含)为较小的数组。

如果两个数组共享一个通用前缀,则返回的索引是公共前缀的长度,随后会在相应数组中的该索引处的两个元素之间不匹配。 如果一个数组是另一个数组的正确前缀,则返回的索引是较小的数组的长度,并且随后索引仅对较大的数组有效。 否则,不存在不匹配的情况。

两个非null 数组, a 如果以下表达式为 true,则 b共享长度的公共 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 数组, a 如果以下表达式为 true,则 b共享正确的前缀:

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

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

适用于

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

要针对不匹配测试的第二个数组

返回

两个数组之间的第一个不匹配的索引,否则 -1。

特性

注解

查找并返回两 int 个数组之间第一个不匹配的索引,否则如果未找到不匹配,则返回 -1。 索引的范围为 0(非独占),最大长度(含)为较小的数组。

如果两个数组共享一个通用前缀,则返回的索引是公共前缀的长度,随后会在相应数组中的该索引处的两个元素之间不匹配。 如果一个数组是另一个数组的正确前缀,则返回的索引是较小的数组的长度,并且随后索引仅对较大的数组有效。 否则,不存在不匹配的情况。

两个非null 数组, a 如果以下表达式为 true,则 b共享长度的公共 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 数组, a 如果以下表达式为 true,则 b共享正确的前缀:

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

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

适用于

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

要针对不匹配测试的第二个数组

返回

两个数组之间的第一个不匹配的索引,否则 -1。

特性

注解

查找并返回两 short 个数组之间第一个不匹配的索引,否则如果未找到不匹配,则返回 -1。 索引的范围为 0(非独占),最大长度(含)为较小的数组。

如果两个数组共享一个通用前缀,则返回的索引是公共前缀的长度,随后会在相应数组中的该索引处的两个元素之间不匹配。 如果一个数组是另一个数组的正确前缀,则返回的索引是较小的数组的长度,并且随后索引仅对较大的数组有效。 否则,不存在不匹配的情况。

两个非null 数组, a 如果以下表达式为 true,则 b共享长度的公共 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 数组, a 如果以下表达式为 true,则 b共享正确的前缀:

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

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

适用于

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

要针对不匹配测试的第二个数组

返回

两个数组之间的第一个不匹配的索引,否则 -1。

特性

注解

查找并返回两 double 个数组之间第一个不匹配的索引,否则如果未找到不匹配,则返回 -1。 索引的范围为 0(非独占),最大长度(含)为较小的数组。

如果两个数组共享一个通用前缀,则返回的索引是公共前缀的长度,随后会在相应数组中的该索引处的两个元素之间不匹配。 如果一个数组是另一个数组的正确前缀,则返回的索引是较小的数组的长度,并且随后索引仅对较大的数组有效。 否则,不存在不匹配的情况。

两个非null 数组, a 如果以下表达式为 true,则 b共享长度的公共 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 数组, a 如果以下表达式为 true,则 b共享正确的前缀:

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

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

适用于

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

要针对不匹配测试的第二个数组

返回

两个数组之间的第一个不匹配的索引,否则 -1。

特性

注解

查找并返回两 char 个数组之间第一个不匹配的索引,否则如果未找到不匹配,则返回 -1。 索引的范围为 0(非独占),最大长度(含)为较小的数组。

如果两个数组共享一个通用前缀,则返回的索引是公共前缀的长度,随后会在相应数组中的该索引处的两个元素之间不匹配。 如果一个数组是另一个数组的正确前缀,则返回的索引是较小的数组的长度,并且随后索引仅对较大的数组有效。 否则,不存在不匹配的情况。

两个非null 数组, a 如果以下表达式为 true,则 b共享长度的公共 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 数组, a 如果以下表达式为 true,则 b共享正确的前缀:

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

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

适用于

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

要针对不匹配测试的第二个数组

返回

两个数组之间的第一个不匹配的索引,否则 -1。

特性

注解

查找并返回两 byte 个数组之间第一个不匹配的索引,否则如果未找到不匹配,则返回 -1。 索引的范围为 0(非独占),最大长度(含)为较小的数组。

如果两个数组共享一个通用前缀,则返回的索引是公共前缀的长度,随后会在相应数组中的该索引处的两个元素之间不匹配。 如果一个数组是另一个数组的正确前缀,则返回的索引是较小的数组的长度,并且随后索引仅对较大的数组有效。 否则,不存在不匹配的情况。

两个非null 数组, a 如果以下表达式为 true,则 b共享长度的公共 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 数组, a 如果以下表达式为 true,则 b共享正确的前缀:

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

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

适用于

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

要针对不匹配测试的第二个数组

返回

两个数组之间的第一个不匹配的索引,否则 -1。

特性

注解

查找并返回两 boolean 个数组之间第一个不匹配的索引,否则如果未找到不匹配,则返回 -1。 索引的范围为 0(非独占),最大长度(含)为较小的数组。

如果两个数组共享一个通用前缀,则返回的索引是公共前缀的长度,随后会在相应数组中的该索引处的两个元素之间不匹配。 如果一个数组是另一个数组的正确前缀,则返回的索引是较小的数组的长度,并且随后索引仅对较大的数组有效。 否则,不存在不匹配的情况。

两个非null 数组, a 如果以下表达式为 true,则 b共享长度的公共 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 数组, a 如果以下表达式为 true,则 b共享正确的前缀:

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

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

适用于

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

要针对不匹配测试的第二个数组

返回

两个数组之间的第一个不匹配的索引,否则 -1。

特性

注解

查找并返回两 Object 个数组之间第一个不匹配的索引,否则如果未找到不匹配,则返回 -1。 索引的范围为 0(非独占),最大长度(含)为较小的数组。

如果两个数组共享一个通用前缀,则返回的索引是公共前缀的长度,随后会在相应数组中的该索引处的两个元素之间不匹配。 如果一个数组是另一个数组的正确前缀,则返回的索引是较小的数组的长度,并且随后索引仅对较大的数组有效。 否则,不存在不匹配的情况。

两个非null 数组, a 如果以下表达式为 true,则 b共享长度的公共 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 数组, a 如果以下表达式为 true,则 b共享正确的前缀:

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

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

适用于

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

比较数组元素的比较器

返回

两个数组之间的第一个不匹配的索引,否则 -1。

特性

注解

查找并返回两 Object 个数组之间第一个不匹配的索引,否则如果未找到不匹配,则返回 -1。 索引的范围为 0(非独占),最大长度(含)为较小的数组。

指定的比较器用于确定每个数组中的两个数组元素是否不相等。

如果两个数组共享一个通用前缀,则返回的索引是公共前缀的长度,随后会在相应数组中的该索引处的两个元素之间不匹配。 如果一个数组是另一个数组的正确前缀,则返回的索引是较小的数组的长度,并且随后索引仅对较大的数组有效。 否则,不存在不匹配的情况。

两个非null 数组, a 如果以下表达式为 true,则 b共享长度的公共 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 数组, a 如果以下表达式为 true,则 b共享正确的前缀:

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

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

适用于