Arrays.Equals 方法
定义
重要
一些信息与预发行产品相关，相应产品在发行之前可能会进行重大修改。 对于此处提供的信息，Microsoft 不作任何明示或暗示的担保。
重载
Equals(Byte[], Int32, Int32, Byte[], Int32, Int32)
如果指定范围内的 两个指定字节数组相等 ，则返回 true。
[Android.Runtime.Register("equals", "([BII[BII)Z", "", ApiSince=33)]
public static bool Equals (byte[] a, int aFromIndex, int aToIndex, byte[] b, int bFromIndex, int bToIndex);[<Android.Runtime.Register("equals", "([BII[BII)Z", "", ApiSince=33)>]
static member Equals : byte[] * int * int * byte[] * int * int -> bool参数
- a
- Byte[]
要测试是否相等的第一个数组
- aFromIndex
- Int32
要测试的第一个数组中第一个元素的索引（非独占）
- aToIndex
- Int32
要测试的第一个数组中最后一个元素的索引（独占）
- b
- Byte[]
要测试是否相等的第二个数组
- bFromIndex
- Int32
要测试的第二个数组中第一个元素的索引（非独占）
- bToIndex
- Int32
要测试的第二个数组中最后一个元素的索引（独占）
返回
true 如果两个数组在指定范围内相等，则为
- 属性
注解
如果指定范围内的 两个指定字节数组相等 ，则返回 true。
如果每个范围涵盖的元素数相同，并且两个数组中指定范围上的所有相应元素对相等，则两个数组被视为相等。 换句话说，如果两个数组包含指定范围中的相同元素，则它们的顺序相同。
已在 9 中添加。
适用于 . 的 java.util.Arrays.equals(byte[], int, int, byte[], int, int)Java 文档
本页的某些部分是根据 Android 开放源代码项目创建和共享的工作进行的修改，并根据 Creative Commons 2.5 属性许可证中所述的术语使用。
适用于
Equals(Char[], Int32, Int32, Char[], Int32, Int32)
如果指定范围内的 两个指定字符数组相等 ，则返回 true。
[Android.Runtime.Register("equals", "([CII[CII)Z", "", ApiSince=33)]
public static bool Equals (char[] a, int aFromIndex, int aToIndex, char[] b, int bFromIndex, int bToIndex);[<Android.Runtime.Register("equals", "([CII[CII)Z", "", ApiSince=33)>]
static member Equals : char[] * int * int * char[] * int * int -> bool参数
- a
- Char[]
要测试是否相等的第一个数组
- aFromIndex
- Int32
要测试的第一个数组中第一个元素的索引（非独占）
- aToIndex
- Int32
要测试的第一个数组中最后一个元素的索引（独占）
- b
- Char[]
要测试是否相等的第二个数组
- bFromIndex
- Int32
要测试的第二个数组中第一个元素的索引（非独占）
- bToIndex
- Int32
要测试的第二个数组中最后一个元素的索引（独占）
返回
true 如果两个数组在指定范围内相等，则为
- 属性
注解
如果指定范围内的 两个指定字符数组相等 ，则返回 true。
如果每个范围涵盖的元素数相同，并且两个数组中指定范围上的所有相应元素对相等，则两个数组被视为相等。 换句话说，如果两个数组包含指定范围中的相同元素，则它们的顺序相同。
已在 9 中添加。
适用于 . 的 java.util.Arrays.equals(char[], int, int, char[], int, int)Java 文档
本页的某些部分是根据 Android 开放源代码项目创建和共享的工作进行的修改，并根据 Creative Commons 2.5 属性许可证中所述的术语使用。
适用于
Equals(Object[], Int32, Int32, Object[], Int32, Int32, IComparator)
如果对象的两个指定数组在指定范围内彼此相等，则返回 true。
[Android.Runtime.Register("equals", "([Ljava/lang/Object;II[Ljava/lang/Object;IILjava/util/Comparator;)Z", "", ApiSince=33)]
[Java.Interop.JavaTypeParameters(new System.String[] { "T" })]
public static bool Equals (Java.Lang.Object[] a, int aFromIndex, int aToIndex, Java.Lang.Object[] b, int bFromIndex, int bToIndex, Java.Util.IComparator cmp);[<Android.Runtime.Register("equals", "([Ljava/lang/Object;II[Ljava/lang/Object;IILjava/util/Comparator;)Z", "", ApiSince=33)>]
[<Java.Interop.JavaTypeParameters(new System.String[] { "T" })>]
static member Equals : Java.Lang.Object[] * int * int * Java.Lang.Object[] * int * int * Java.Util.IComparator -> bool参数
- a
- Object[]
要测试是否相等的第一个数组
- aFromIndex
- Int32
要测试的第一个数组中第一个元素的索引（非独占）
- aToIndex
- Int32
要测试的第一个数组中最后一个元素的索引（独占）
- b
- Object[]
要测试是否相等的第二个数组
- bFromIndex
- Int32
要测试的第二个数组中第一个元素的索引（非独占）
- bToIndex
- Int32
要测试的第二个数组中最后一个元素的索引（独占）
- cmp
- IComparator
比较数组元素的比较器
返回
true 如果两个数组在指定范围内相等，则为
- 属性
注解
如果对象的两个指定数组在指定范围内彼此相等，则返回 true。
如果每个范围涵盖的元素数相同，并且两个数组中指定范围上的所有相应元素对相等，则两个数组被视为相等。 换句话说，如果两个数组包含指定范围中的相同元素，则它们的顺序相同。
如果给定指定的比较器，则e2两个对象e1被视为相等。 cmp.compare(e1, e2) == 0
已在 9 中添加。
本页的某些部分是根据 Android 开放源代码项目创建和共享的工作进行的修改，并根据 Creative Commons 2.5 属性许可证中所述的术语使用。
适用于
Equals(Double[], Int32, Int32, Double[], Int32, Int32)
如果两个指定的双精度数组在指定范围内相等，则返回 true。
[Android.Runtime.Register("equals", "([DII[DII)Z", "", ApiSince=33)]
public static bool Equals (double[] a, int aFromIndex, int aToIndex, double[] b, int bFromIndex, int bToIndex);[<Android.Runtime.Register("equals", "([DII[DII)Z", "", ApiSince=33)>]
static member Equals : double[] * int * int * double[] * int * int -> bool参数
- a
- Double[]
要测试是否相等的第一个数组
- aFromIndex
- Int32
要测试的第一个数组中第一个元素的索引（非独占）
- aToIndex
- Int32
要测试的第一个数组中最后一个元素的索引（独占）
- b
- Double[]
要测试是否相等的第二个数组
- bFromIndex
- Int32
要测试的第二个数组中第一个元素的索引（非独占）
- bToIndex
- Int32
要测试的第二个数组中最后一个元素的索引（独占）
返回
true 如果两个数组在指定范围内相等，则为
- 属性
注解
如果两个指定的双精度数组在指定范围内相等，则返回 true。
如果每个范围涵盖的元素数相同，并且两个数组中指定范围上的所有相应元素对相等，则两个数组被视为相等。 换句话说，如果两个数组包含指定范围中的相同元素，则它们的顺序相同。
两个双打 d1 ， d2 如果以下情况，则被视为相等：
{@code new Double(d1).equals(new Double(d2))}
（与运算符不同 == ，此方法认为 NaN 等于自身，0.0d 与 -0.0d 不相等。
已在 9 中添加。
适用于 . 的 java.util.Arrays.equals(double[], int, int, double[], int, int)Java 文档
本页的某些部分是根据 Android 开放源代码项目创建和共享的工作进行的修改，并根据 Creative Commons 2.5 属性许可证中所述的术语使用。
适用于
Equals(Single[], Int32, Int32, Single[], Int32, Int32)
如果两个指定的浮点数组在指定范围内 相等 ，则返回 true。
[Android.Runtime.Register("equals", "([FII[FII)Z", "", ApiSince=33)]
public static bool Equals (float[] a, int aFromIndex, int aToIndex, float[] b, int bFromIndex, int bToIndex);[<Android.Runtime.Register("equals", "([FII[FII)Z", "", ApiSince=33)>]
static member Equals : single[] * int * int * single[] * int * int -> bool参数
- a
- Single[]
要测试是否相等的第一个数组
- aFromIndex
- Int32
要测试的第一个数组中第一个元素的索引（非独占）
- aToIndex
- Int32
要测试的第一个数组中最后一个元素的索引（独占）
- b
- Single[]
要测试是否相等的第二个数组
- bFromIndex
- Int32
要测试的第二个数组中第一个元素的索引（非独占）
- bToIndex
- Int32
要测试的第二个数组中最后一个元素的索引（独占）
返回
true 如果两个数组在指定范围内相等，则为
- 属性
注解
如果两个指定的浮点数组在指定范围内 相等 ，则返回 true。
如果每个范围涵盖的元素数相同，并且两个数组中指定范围上的所有相应元素对相等，则两个数组被视为相等。 换句话说，如果两个数组包含指定范围中的相同元素，则它们的顺序相同。
两个浮点数 f1 ，如果 f2 以下情况，则被视为相等：
{@code new Float(f1).equals(new Float(f2))}
（与运算符不同 == ，此方法认为 NaN 等于自身，0.0f 与 -0.0f 不相等）
已在 9 中添加。
适用于 . 的 java.util.Arrays.equals(float[], int, int, float[], int, int)Java 文档
本页的某些部分是根据 Android 开放源代码项目创建和共享的工作进行的修改，并根据 Creative Commons 2.5 属性许可证中所述的术语使用。
适用于
Equals(Int32[], Int32, Int32, Int32[], Int32, Int32)
如果两个指定的 ints 数组在指定范围内 相等 ，则返回 true。
[Android.Runtime.Register("equals", "([III[III)Z", "", ApiSince=33)]
public static bool Equals (int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex);[<Android.Runtime.Register("equals", "([III[III)Z", "", ApiSince=33)>]
static member Equals : int[] * int * int * int[] * int * int -> bool参数
- a
- Int32[]
要测试是否相等的第一个数组
- aFromIndex
- Int32
要测试的第一个数组中第一个元素的索引（非独占）
- aToIndex
- Int32
要测试的第一个数组中最后一个元素的索引（独占）
- b
- Int32[]
要测试是否相等的第二个数组
- bFromIndex
- Int32
要测试的第二个数组中第一个元素的索引（非独占）
- bToIndex
- Int32
要测试的第二个数组中最后一个元素的索引（独占）
返回
true 如果两个数组在指定范围内相等，则为
- 属性
注解
如果两个指定的 ints 数组在指定范围内 相等 ，则返回 true。
如果每个范围涵盖的元素数相同，并且两个数组中指定范围上的所有相应元素对相等，则两个数组被视为相等。 换句话说，如果两个数组包含指定范围中的相同元素，则它们的顺序相同。
已在 9 中添加。
适用于 . 的 java.util.Arrays.equals(int[], int, int, int[], int, int)Java 文档
本页的某些部分是根据 Android 开放源代码项目创建和共享的工作进行的修改，并根据 Creative Commons 2.5 属性许可证中所述的术语使用。
适用于
Equals(Int64[], Int32, Int32, Int64[], Int32, Int32)
如果两个指定的长数组在指定范围内 相等 ，则返回 true。
[Android.Runtime.Register("equals", "([JII[JII)Z", "", ApiSince=33)]
public static bool Equals (long[] a, int aFromIndex, int aToIndex, long[] b, int bFromIndex, int bToIndex);[<Android.Runtime.Register("equals", "([JII[JII)Z", "", ApiSince=33)>]
static member Equals : int64[] * int * int * int64[] * int * int -> bool参数
- a
- Int64[]
要测试是否相等的第一个数组
- aFromIndex
- Int32
要测试的第一个数组中第一个元素的索引（非独占）
- aToIndex
- Int32
要测试的第一个数组中最后一个元素的索引（独占）
- b
- Int64[]
要测试是否相等的第二个数组
- bFromIndex
- Int32
要测试的第二个数组中第一个元素的索引（非独占）
- bToIndex
- Int32
要测试的第二个数组中最后一个元素的索引（独占）
返回
true 如果两个数组在指定范围内相等，则为
- 属性
注解
如果两个指定的长数组在指定范围内 相等 ，则返回 true。
如果每个范围涵盖的元素数相同，并且两个数组中指定范围上的所有相应元素对相等，则两个数组被视为相等。 换句话说，如果两个数组包含指定范围中的相同元素，则它们的顺序相同。
已在 9 中添加。
适用于 . 的 java.util.Arrays.equals(long[], int, int, long[], int, int)Java 文档
本页的某些部分是根据 Android 开放源代码项目创建和共享的工作进行的修改，并根据 Creative Commons 2.5 属性许可证中所述的术语使用。
适用于
Equals(Boolean[], Int32, Int32, Boolean[], Int32, Int32)
如果两个指定的布尔数组在指定的范围 上相等 ，则返回 true。
[Android.Runtime.Register("equals", "([ZII[ZII)Z", "", ApiSince=33)]
public static bool Equals (bool[] a, int aFromIndex, int aToIndex, bool[] b, int bFromIndex, int bToIndex);[<Android.Runtime.Register("equals", "([ZII[ZII)Z", "", ApiSince=33)>]
static member Equals : bool[] * int * int * bool[] * int * int -> bool参数
- a
- Boolean[]
要测试是否相等的第一个数组
- aFromIndex
- Int32
要测试的第一个数组中第一个元素的索引（非独占）
- aToIndex
- Int32
要测试的第一个数组中最后一个元素的索引（独占）
- b
- Boolean[]
要测试是否相等的第二个数组
- bFromIndex
- Int32
要测试的第二个数组中第一个元素的索引（非独占）
- bToIndex
- Int32
要测试的第二个数组中最后一个元素的索引（独占）
返回
true 如果两个数组在指定范围内相等，则为
- 属性
注解
如果两个指定的布尔数组在指定的范围 上相等 ，则返回 true。
如果每个范围涵盖的元素数相同，并且两个数组中指定范围上的所有相应元素对相等，则两个数组被视为相等。 换句话说，如果两个数组包含指定范围中的相同元素，则它们的顺序相同。
已在 9 中添加。
适用于 . 的 java.util.Arrays.equals(boolean[], int, int, boolean[], int, int)Java 文档
本页的某些部分是根据 Android 开放源代码项目创建和共享的工作进行的修改，并根据 Creative Commons 2.5 属性许可证中所述的术语使用。
适用于
Equals(Int16[], Int32, Int32, Int16[], Int32, Int32)
如果两个指定的短数组在指定范围内 相等 ，则返回 true。
[Android.Runtime.Register("equals", "([SII[SII)Z", "", ApiSince=33)]
public static bool Equals (short[] a, int aFromIndex, int aToIndex, short[] b, int bFromIndex, int bToIndex);[<Android.Runtime.Register("equals", "([SII[SII)Z", "", ApiSince=33)>]
static member Equals : int16[] * int * int * int16[] * int * int -> bool参数
- a
- Int16[]
要测试是否相等的第一个数组
- aFromIndex
- Int32
要测试的第一个数组中第一个元素的索引（非独占）
- aToIndex
- Int32
要测试的第一个数组中最后一个元素的索引（独占）
- b
- Int16[]
要测试是否相等的第二个数组
- bFromIndex
- Int32
要测试的第二个数组中第一个元素的索引（非独占）
- bToIndex
- Int32
要测试的第二个数组中最后一个元素的索引（独占）
返回
true 如果两个数组在指定范围内相等，则为
- 属性
注解
如果两个指定的短数组在指定范围内 相等 ，则返回 true。
如果每个范围涵盖的元素数相同，并且两个数组中指定范围上的所有相应元素对相等，则两个数组被视为相等。 换句话说，如果两个数组包含指定范围中的相同元素，则它们的顺序相同。
已在 9 中添加。
适用于 . 的 java.util.Arrays.equals(short[], int, int, short[], int, int)Java 文档
本页的某些部分是根据 Android 开放源代码项目创建和共享的工作进行的修改，并根据 Creative Commons 2.5 属性许可证中所述的术语使用。
适用于
Equals(Object[], Int32, Int32, Object[], Int32, Int32)
如果对象的两个指定数组在指定范围内彼此相等，则返回 true。
[Android.Runtime.Register("equals", "([Ljava/lang/Object;II[Ljava/lang/Object;II)Z", "", ApiSince=33)]
public static bool Equals (Java.Lang.Object[] a, int aFromIndex, int aToIndex, Java.Lang.Object[] b, int bFromIndex, int bToIndex);[<Android.Runtime.Register("equals", "([Ljava/lang/Object;II[Ljava/lang/Object;II)Z", "", ApiSince=33)>]
static member Equals : Java.Lang.Object[] * int * int * Java.Lang.Object[] * int * int -> bool参数
- a
- Object[]
要测试是否相等的第一个数组
- aFromIndex
- Int32
要测试的第一个数组中第一个元素的索引（非独占）
- aToIndex
- Int32
要测试的第一个数组中最后一个元素的索引（独占）
- b
- Object[]
要测试是否相等的第二个数组
- bFromIndex
- Int32
要测试的第二个数组中第一个元素的索引（非独占）
- bToIndex
- Int32
要测试的第二个数组中最后一个元素的索引（独占）
返回
true 如果两个数组在指定范围内相等，则为
- 属性
注解
如果对象的两个指定数组在指定范围内彼此相等，则返回 true。
如果每个范围涵盖的元素数相同，并且两个数组中指定范围上的所有相应元素对相等，则两个数组被视为相等。 换句话说，如果两个数组包含指定范围中的相同元素，则它们的顺序相同。
两个对象e1，如果Objects.equals(e1, e2)为 ，e2则被视为相等。
已在 9 中添加。
适用于 . 的 java.util.Arrays.equals(java.lang.Object[], int, int, java.lang.Object[], int, int)Java 文档
本页的某些部分是根据 Android 开放源代码项目创建和共享的工作进行的修改，并根据 Creative Commons 2.5 属性许可证中所述的术语使用。
适用于
Equals(Int16[], Int16[])
如果true两个指定的短数组彼此相等，则返回。
[Android.Runtime.Register("equals", "([S[S)Z", "")]
public static bool Equals (short[]? a, short[]? a2);[<Android.Runtime.Register("equals", "([S[S)Z", "")>]
static member Equals : int16[] * int16[] -> bool参数
- a
- Int16[]
要测试的一个数组是否相等
- a2
- Int16[]
要测试是否相等的另一个数组
返回
true 如果两个数组相等，则为
- 属性
注解
如果true两个指定的短数组彼此相等，则返回。 如果两个数组都包含相同数量的元素，并且两个数组中的所有对应元素对相等，则两个数组被视为相等。 换句话说，如果两个数组包含相同顺序的相同元素，则两个数组相等。 此外，如果两个数组引用都相等，则两个 null数组引用被视为相等。
适用于 . 的 java.util.Arrays.equals(short[], short[])Java 文档
本页的某些部分是根据 Android 开放源代码项目创建和共享的工作进行的修改，并根据 Creative Commons 2.5 属性许可证中所述的术语使用。
适用于
Equals(Single[], Single[])
如果true两个指定的浮点数组彼此相等，则返回。
[Android.Runtime.Register("equals", "([F[F)Z", "")]
public static bool Equals (float[]? a, float[]? a2);[<Android.Runtime.Register("equals", "([F[F)Z", "")>]
static member Equals : single[] * single[] -> bool参数
- a
- Single[]
要测试的一个数组是否相等
- a2
- Single[]
要测试是否相等的另一个数组
返回
true 如果两个数组相等，则为
- 属性
注解
如果true两个指定的浮点数组彼此相等，则返回。 如果两个数组都包含相同数量的元素，并且两个数组中的所有对应元素对相等，则两个数组被视为相等。 换句话说，如果两个数组包含相同顺序的相同元素，则两个数组相等。 此外，如果两个数组引用都相等，则两个 null数组引用被视为相等。
两个浮点数 f1 ，如果 f2 以下情况，则被视为相等：
{@code new Float(f1).equals(new Float(f2))}
（与运算符不同 == ，此方法认为 NaN 等于自身，0.0f 与 -0.0f 不相等）
适用于 . 的 java.util.Arrays.equals(float[], float[])Java 文档
本页的某些部分是根据 Android 开放源代码项目创建和共享的工作进行的修改，并根据 Creative Commons 2.5 属性许可证中所述的术语使用。
适用于
Equals(Int64[], Int64[])
如果 true 两个指定的长 数组相等 ，则返回。
[Android.Runtime.Register("equals", "([J[J)Z", "")]
public static bool Equals (long[]? a, long[]? a2);[<Android.Runtime.Register("equals", "([J[J)Z", "")>]
static member Equals : int64[] * int64[] -> bool参数
- a
- Int64[]
要测试的一个数组是否相等
- a2
- Int64[]
要测试是否相等的另一个数组
返回
true 如果两个数组相等，则为
- 属性
注解
如果 true 两个指定的长 数组相等 ，则返回。 如果两个数组都包含相同数量的元素，并且两个数组中的所有对应元素对相等，则两个数组被视为相等。 换句话说，如果两个数组包含相同顺序的相同元素，则两个数组相等。 此外，如果两个数组引用都相等，则两个 null数组引用被视为相等。
适用于 . 的 java.util.Arrays.equals(long[], long[])Java 文档
本页的某些部分是根据 Android 开放源代码项目创建和共享的工作进行的修改，并根据 Creative Commons 2.5 属性许可证中所述的术语使用。
适用于
Equals(Int32[], Int32[])
如果true两个指定的 int 数组彼此相等，则返回。
[Android.Runtime.Register("equals", "([I[I)Z", "")]
public static bool Equals (int[]? a, int[]? a2);[<Android.Runtime.Register("equals", "([I[I)Z", "")>]
static member Equals : int[] * int[] -> bool参数
- a
- Int32[]
要测试的一个数组是否相等
- a2
- Int32[]
要测试是否相等的另一个数组
返回
true 如果两个数组相等，则为
- 属性
注解
如果true两个指定的 int 数组彼此相等，则返回。 如果两个数组都包含相同数量的元素，并且两个数组中的所有对应元素对相等，则两个数组被视为相等。 换句话说，如果两个数组包含相同顺序的相同元素，则两个数组相等。 此外，如果两个数组引用都相等，则两个 null数组引用被视为相等。
适用于 . 的 java.util.Arrays.equals(int[], int[])Java 文档
本页的某些部分是根据 Android 开放源代码项目创建和共享的工作进行的修改，并根据 Creative Commons 2.5 属性许可证中所述的术语使用。
适用于
Equals(Double[], Double[])
返回 true 两个指定的双精度 数组是否彼此相等 。
[Android.Runtime.Register("equals", "([D[D)Z", "")]
public static bool Equals (double[]? a, double[]? a2);[<Android.Runtime.Register("equals", "([D[D)Z", "")>]
static member Equals : double[] * double[] -> bool参数
- a
- Double[]
要测试的一个数组是否相等
- a2
- Double[]
要测试是否相等的另一个数组
返回
true 如果两个数组相等，则为
- 属性
注解
返回 true 两个指定的双精度 数组是否彼此相等 。 如果两个数组都包含相同数量的元素，并且两个数组中的所有对应元素对相等，则两个数组被视为相等。 换句话说，如果两个数组包含相同顺序的相同元素，则两个数组相等。 此外，如果两个数组引用都相等，则两个 null数组引用被视为相等。
两个双打 d1 ， d2 如果以下情况，则被视为相等：
{@code new Double(d1).equals(new Double(d2))}
（与运算符不同 == ，此方法认为 NaN 等于自身，0.0d 与 -0.0d 不相等。
适用于 . 的 java.util.Arrays.equals(double[], double[])Java 文档
本页的某些部分是根据 Android 开放源代码项目创建和共享的工作进行的修改，并根据 Creative Commons 2.5 属性许可证中所述的术语使用。
适用于
Equals(Char[], Char[])
返回 true 两个指定的字符 数组是否彼此相等 。
[Android.Runtime.Register("equals", "([C[C)Z", "")]
public static bool Equals (char[]? a, char[]? a2);[<Android.Runtime.Register("equals", "([C[C)Z", "")>]
static member Equals : char[] * char[] -> bool参数
- a
- Char[]
要测试的一个数组是否相等
- a2
- Char[]
要测试是否相等的另一个数组
返回
true 如果两个数组相等，则为
- 属性
注解
返回 true 两个指定的字符 数组是否彼此相等 。 如果两个数组都包含相同数量的元素，并且两个数组中的所有对应元素对相等，则两个数组被视为相等。 换句话说，如果两个数组包含相同顺序的相同元素，则两个数组相等。 此外，如果两个数组引用都相等，则两个 null数组引用被视为相等。
适用于 . 的 java.util.Arrays.equals(char[], char[])Java 文档
本页的某些部分是根据 Android 开放源代码项目创建和共享的工作进行的修改，并根据 Creative Commons 2.5 属性许可证中所述的术语使用。
适用于
Equals(Byte[], Byte[])
true如果两个指定的字节数组彼此相等，则返回。
[Android.Runtime.Register("equals", "([B[B)Z", "")]
public static bool Equals (byte[]? a, byte[]? a2);[<Android.Runtime.Register("equals", "([B[B)Z", "")>]
static member Equals : byte[] * byte[] -> bool参数
- a
- Byte[]
要测试的一个数组是否相等
- a2
- Byte[]
要测试是否相等的另一个数组
返回
true 如果两个数组相等，则为
- 属性
注解
true如果两个指定的字节数组彼此相等，则返回。 如果两个数组都包含相同数量的元素，并且两个数组中的所有对应元素对相等，则两个数组被视为相等。 换句话说，如果两个数组包含相同顺序的相同元素，则两个数组相等。 此外，如果两个数组引用都相等，则两个 null数组引用被视为相等。
适用于 . 的 java.util.Arrays.equals(byte[], byte[])Java 文档
本页的某些部分是根据 Android 开放源代码项目创建和共享的工作进行的修改，并根据 Creative Commons 2.5 属性许可证中所述的术语使用。
适用于
Equals(Boolean[], Boolean[])
如果true两个指定的布尔数组彼此相等，则返回。
[Android.Runtime.Register("equals", "([Z[Z)Z", "")]
public static bool Equals (bool[]? a, bool[]? a2);[<Android.Runtime.Register("equals", "([Z[Z)Z", "")>]
static member Equals : bool[] * bool[] -> bool参数
- a
- Boolean[]
要测试的一个数组是否相等
- a2
- Boolean[]
要测试是否相等的另一个数组
返回
true 如果两个数组相等，则为
- 属性
注解
如果true两个指定的布尔数组彼此相等，则返回。 如果两个数组都包含相同数量的元素，并且两个数组中的所有对应元素对相等，则两个数组被视为相等。 换句话说，如果两个数组包含相同顺序的相同元素，则两个数组相等。 此外，如果两个数组引用都相等，则两个 null数组引用被视为相等。
适用于 . 的 java.util.Arrays.equals(boolean[], boolean[])Java 文档
本页的某些部分是根据 Android 开放源代码项目创建和共享的工作进行的修改，并根据 Creative Commons 2.5 属性许可证中所述的术语使用。
适用于
Equals(Object[], Object[])
如果两个指定的对象数组彼此相等，则true返回。
[Android.Runtime.Register("equals", "([Ljava/lang/Object;[Ljava/lang/Object;)Z", "")]
public static bool Equals (Java.Lang.Object[]? a, Java.Lang.Object[]? a2);[<Android.Runtime.Register("equals", "([Ljava/lang/Object;[Ljava/lang/Object;)Z", "")>]
static member Equals : Java.Lang.Object[] * Java.Lang.Object[] -> bool参数
- a
- Object[]
要测试的一个数组是否相等
- a2
- Object[]
要测试是否相等的另一个数组
返回
true 如果两个数组相等，则为
- 属性
注解
如果两个指定的对象数组彼此相等，则true返回。 如果两个数组都包含相同数量的元素，并且两个数组中的所有对应元素对相等，则这两个数组被视为相等。 两个对象e1，如果Objects.equals(e1, e2)为 ，e2则被视为相等。 换句话说，如果两个数组具有相同的顺序包含相同的元素，则两个数组相等。 此外，如果两个数组引用都相等，则两个 null数组引用被视为相等。
适用于 . 的 java.util.Arrays.equals(java.lang.Object[], java.lang.Object[])Java 文档
本页的某些部分是根据 Android 开放源代码项目创建和共享的工作进行的修改，并根据 Creative Commons 2.5 属性许可证中所述的术语使用。
适用于
Equals(Object[], Object[], IComparator)
如果两个指定的对象数组彼此相等，则true返回。
[Android.Runtime.Register("equals", "([Ljava/lang/Object;[Ljava/lang/Object;Ljava/util/Comparator;)Z", "", ApiSince=33)]
[Java.Interop.JavaTypeParameters(new System.String[] { "T" })]
public static bool Equals (Java.Lang.Object[]? a, Java.Lang.Object[]? a2, Java.Util.IComparator cmp);[<Android.Runtime.Register("equals", "([Ljava/lang/Object;[Ljava/lang/Object;Ljava/util/Comparator;)Z", "", ApiSince=33)>]
[<Java.Interop.JavaTypeParameters(new System.String[] { "T" })>]
static member Equals : Java.Lang.Object[] * Java.Lang.Object[] * Java.Util.IComparator -> bool参数
- a
- Object[]
要测试的一个数组是否相等
- a2
- Object[]
要测试是否相等的另一个数组
- cmp
- IComparator
比较数组元素的比较器
返回
true 如果两个数组相等，则为
- 属性
注解
如果两个指定的对象数组彼此相等，则true返回。
如果两个数组都包含相同数量的元素，并且两个数组中的所有对应元素对相等，则两个数组被视为相等。 换句话说，如果两个数组具有相同的顺序包含相同的元素，则两个数组相等。 此外，如果两个数组引用都相等，则两个 null数组引用被视为相等。
如果给定指定的比较器，则e2两个对象e1被视为相等。 cmp.compare(e1, e2) == 0
已在 9 中添加。
适用于 . 的 java.util.Arrays.equals(T[], T[], java.util.Comparator<? super T>)Java 文档
本页的某些部分是根据 Android 开放源代码项目创建和共享的工作进行的修改，并根据 Creative Commons 2.5 属性许可证中所述的术语使用。