Arrays.Mismatch 方法
定义
重要
一些信息与预发行产品相关,相应产品在发行之前可能会进行重大修改。 对于此处提供的信息,Microsoft 不作任何明示或暗示的担保。
重载
| 名称 | 说明 |
|---|---|
| Mismatch(Object[], Int32, Int32, Object[], Int32, Int32, IComparator) |
查找并返回指定范围中两 |
| Mismatch(Single[], Int32, Int32, Single[], Int32, Int32) |
查找并返回指定范围中两 |
| Mismatch(Int64[], Int32, Int32, Int64[], Int32, Int32) |
查找并返回指定范围中两 |
| Mismatch(Int32[], Int32, Int32, Int32[], Int32, Int32) |
查找并返回指定范围中两 |
| Mismatch(Int16[], Int32, Int32, Int16[], Int32, Int32) |
查找并返回指定范围中两 |
| Mismatch(Double[], Int32, Int32, Double[], Int32, Int32) |
查找并返回指定范围中两 |
| Mismatch(Char[], Int32, Int32, Char[], Int32, Int32) |
查找并返回指定范围中两 |
| Mismatch(Byte[], Int32, Int32, Byte[], Int32, Int32) |
查找并返回指定范围中两 |
| Mismatch(Boolean[], Int32, Int32, Boolean[], Int32, Int32) |
查找并返回指定范围中两 |
| Mismatch(Object[], Int32, Int32, Object[], Int32, Int32) |
查找并返回指定范围中两 |
| Mismatch(Single[], Single[]) |
查找并返回两 |
| Mismatch(Int64[], Int64[]) |
查找并返回两 |
| Mismatch(Int32[], Int32[]) |
查找并返回两 |
| Mismatch(Int16[], Int16[]) |
查找并返回两 |
| Mismatch(Double[], Double[]) |
查找并返回两 |
| Mismatch(Char[], Char[]) |
查找并返回两 |
| Mismatch(Byte[], Byte[]) |
查找并返回两 |
| Mismatch(Boolean[], Boolean[]) |
查找并返回两 |
| Mismatch(Object[], Object[]) |
查找并返回两 |
| Mismatch(Object[], Object[], IComparator) |
查找并返回两 |
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>)。
本页的某些部分是根据 创建和共享的工作进行的修改,并根据 许可证中所述的条款使用。