Arrays.Equals 方法

定義

命名空間:: Java.Util

組件:: Mono.Android.dll

重要

部分資訊涉及發行前產品，在發行之前可能會有大幅修改。 Microsoft 對此處提供的資訊，不做任何明確或隱含的瑕疵擔保。

多載

名稱	Description
Equals(Byte[], Int32, Int32, Byte[], Int32, Int32)	若兩個指定位元組陣列在指定範圍內彼此相等，則回傳為真。
Equals(Char[], Int32, Int32, Char[], Int32, Int32)	若兩個指定的字符陣列在指定範圍內彼此相等，則回傳為真。
Equals(Object[], Int32, Int32, Object[], Int32, Int32, IComparator)	若兩個指定的物件陣列在指定範圍內彼此相等，則返回為真。
Equals(Double[], Int32, Int32, Double[], Int32, Int32)	若兩個指定的雙重陣列在指定範圍內彼此相等，則回傳為真。
Equals(Single[], Int32, Int32, Single[], Int32, Int32)	若兩個指定的浮點陣列在指定範圍內彼此相等，則回傳為真。
Equals(Int32[], Int32, Int32, Int32[], Int32, Int32)	若在指定範圍內的兩個整數陣列彼此相等，則回傳為真。
Equals(Int64[], Int32, Int32, Int64[], Int32, Int32)	若兩個指定的長度陣列在指定範圍內彼此相等，則返回為真。
Equals(Boolean[], Int32, Int32, Boolean[], Int32, Int32)	若兩個指定的布林陣列在指定範圍內彼此相等，則回傳為真。
Equals(Int16[], Int32, Int32, Int16[], Int32, Int32)	若兩個指定的短路陣列在指定範圍內彼此相等，則回傳為真。
Equals(Object[], Int32, Int32, Object[], Int32, Int32)	若兩個指定的物件陣列在指定範圍內彼此相等，則返回為真。
Equals(Int16[], Int16[])	若兩個指定的短路陣列相等，則回傳`true`。
Equals(Single[], Single[])	若兩個指定的浮點陣列彼此相等，則回傳`true`。
Equals(Int64[], Int64[])	若兩個指定的 long 陣列相等，則回傳`true`。
Equals(Int32[], Int32[])	若兩個指定的整數陣列相等，則回傳`true`。
Equals(Double[], Double[])	`true`若兩個指定的雙重陣列相等，則返回。
Equals(Char[], Char[])	若兩個指定的 char 陣列相等，則回傳`true`。
Equals(Byte[], Byte[])	若兩個指定的位元組陣列相等，則回傳`true`。
Equals(Boolean[], Boolean[])	若兩個指定的布林陣列彼此相等，則回傳`true`。
Equals(Object[], Object[])	若兩個指定的物件陣列相等，則回傳`true`。
Equals(Object[], Object[], IComparator)	若兩個指定的物件陣列相等，則回傳`true`。

Equals(Byte[], Int32, Int32, Byte[], Int32, Int32)

若兩個指定位元組陣列在指定範圍內彼此相等，則回傳為真。

[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

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

傳回

Boolean

true 若兩個陣列在指定範圍內相等

屬性: RegisterAttribute

備註

若兩個指定位元組陣列在指定範圍內彼此相等，則回傳為真。

若兩個陣列涵蓋的元素數相同，且兩個陣列中指定範圍內所有對應元素對相等，則視為相等。換句話說，若兩個陣列在指定範圍內包含相同且順序相同的元素，則稱它們相等。

新增9。

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

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

適用於

Equals(Char[], Int32, Int32, Char[], Int32, Int32)

若兩個指定的字符陣列在指定範圍內彼此相等，則回傳為真。

[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

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

傳回

Boolean

true 若兩個陣列在指定範圍內相等

屬性: RegisterAttribute

備註

若兩個指定的字符陣列在指定範圍內彼此相等，則回傳為真。

新增9。

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

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

適用於

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

若兩個指定的物件陣列在指定範圍內彼此相等，則返回為真。

[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

比較器用來比較陣列元素

傳回

Boolean

true 若兩個陣列在指定範圍內相等

屬性: RegisterAttribute JavaTypeParametersAttribute

備註

若兩個指定的物件陣列在指定範圍內彼此相等，則返回為真。

若給定指定的比較器，cmp.compare(e1, e2) == 0則兩個物件 e1 和 e2 被視為相等。

新增9。

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

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

適用於

Equals(Double[], Int32, Int32, Double[], Int32, Int32)

若兩個指定的雙重陣列在指定範圍內 彼此相等 ，則回傳為真。

[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

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

傳回

Boolean

true 若兩個陣列在指定範圍內相等

屬性: RegisterAttribute

備註

若兩個指定的雙重陣列在指定範圍內 彼此相等 ，則回傳為真。

兩個雙重 d1 和 d2 視為相等，當條件是：

{@code Double.valueOf(d1).equals(Double.valueOf(d2))}

（與算 == 符不同，此方法將 NaN 視為等於自身，且 0.0d 不等於 -0.0d。）

新增9。

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

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

適用於

Equals(Single[], Int32, Int32, Single[], Int32, Int32)

若兩個指定的浮點陣列在指定範圍內彼此相等，則回傳為真。

[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

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

傳回

Boolean

true 若兩個陣列在指定範圍內相等

屬性: RegisterAttribute

備註

若兩個指定的浮點陣列在指定範圍內彼此相等，則回傳為真。

兩個浮點 f1 數和 f2 視為相等，當條件是：

{@code Float.valueOf(f1).equals(Float.valueOf(f2))}

（與算 == 符不同，此方法將 NaN 視為等於自身，且 0.0f 不等於 -0.0f。）

新增9。

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

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

適用於

Equals(Int32[], Int32, Int32, Int32[], Int32, Int32)

若在指定範圍內的兩個整數陣列彼此相等，則回傳為真。

[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

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

傳回

Boolean

true 若兩個陣列在指定範圍內相等

屬性: RegisterAttribute

備註

若在指定範圍內的兩個整數陣列彼此相等，則回傳為真。

新增9。

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

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

適用於

Equals(Int64[], Int32, Int32, Int64[], Int32, Int32)

若兩個指定的長度陣列在指定範圍內 彼此相等 ，則返回為真。

[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

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

傳回

Boolean

true 若兩個陣列在指定範圍內相等

屬性: RegisterAttribute

備註

若兩個指定的長度陣列在指定範圍內 彼此相等 ，則返回為真。

新增9。

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

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

適用於

Equals(Boolean[], Int32, Int32, Boolean[], Int32, Int32)

若兩個指定的布林陣列在指定範圍內彼此相等，則回傳為真。

[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

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

傳回

Boolean

true 若兩個陣列在指定範圍內相等

屬性: RegisterAttribute

備註

若兩個指定的布林陣列在指定範圍內彼此相等，則回傳為真。

新增9。

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

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

適用於

Equals(Int16[], Int32, Int32, Int16[], Int32, Int32)

若兩個指定的短路陣列在指定範圍內彼此相等，則回傳為真。

[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

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

傳回

Boolean

true 若兩個陣列在指定範圍內相等

屬性: RegisterAttribute

備註

若兩個指定的短路陣列在指定範圍內彼此相等，則回傳為真。

新增9。

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

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

適用於

Equals(Object[], Int32, Int32, Object[], Int32, Int32)

若兩個指定的物件陣列在指定範圍內彼此相等，則返回為真。

[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

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

傳回

Boolean

true 若兩個陣列在指定範圍內相等

屬性: RegisterAttribute

備註

若兩個指定的物件陣列在指定範圍內彼此相等，則返回為真。

兩個物件 e1 和 e2 若，則視為相等。Objects.equals(e1, e2)

新增9。

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

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

適用於

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

另一個陣列要測試相等性

傳回

Boolean

true 若兩個陣列相等

屬性: RegisterAttribute

備註

若兩個指定的短路陣列相等，則回傳true。若兩個陣列包含相同數量的元素，且兩個陣列中對應的元素對相等，則視為相等。換句話說，若兩個陣列包含相同元素且順序相同，則稱它們相等。此外，若兩個陣列參考皆為 null，則視為相等。

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

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

適用於

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

另一個陣列要測試相等性

傳回

Boolean

true 若兩個陣列相等

屬性: RegisterAttribute

備註

若兩個指定的浮點陣列彼此相等，則回傳true。若兩個陣列包含相同數量的元素，且兩個陣列中對應的元素對相等，則視為相等。換句話說，若兩個陣列包含相同元素且順序相同，則稱它們相等。此外，若兩個陣列參考皆為 null，則視為相等。

兩個浮點 f1 數和 f2 視為相等，當條件是：

{@code Float.valueOf(f1).equals(Float.valueOf(f2))}

（與算 == 符不同，此方法將 NaN 視為等於自身，且 0.0f 不等於 -0.0f。）

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

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

適用於

Equals(Int64[], Int64[])

若兩個指定的 long 陣列相等，則回傳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[]

另一個陣列要測試相等性

傳回

Boolean

true 若兩個陣列相等

屬性: RegisterAttribute

備註

若兩個指定的 long 陣列相等，則回傳true。若兩個陣列包含相同數量的元素，且兩個陣列中對應的元素對相等，則視為相等。換句話說，若兩個陣列包含相同元素且順序相同，則稱它們相等。此外，若兩個陣列參考皆為 null，則視為相等。

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

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

適用於

Equals(Int32[], Int32[])

若兩個指定的整數陣列相等，則回傳true。

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

另一個陣列要測試相等性

傳回

Boolean

true 若兩個陣列相等

屬性: RegisterAttribute

備註

若兩個指定的整數陣列相等，則回傳true。若兩個陣列包含相同數量的元素，且兩個陣列中對應的元素對相等，則視為相等。換句話說，若兩個陣列包含相同元素且順序相同，則稱它們相等。此外，若兩個陣列參考皆為 null，則視為相等。

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

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

適用於

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

另一個陣列要測試相等性

傳回

Boolean

true 若兩個陣列相等

屬性: RegisterAttribute

備註

true若兩個指定的雙重陣列相等，則返回。若兩個陣列包含相同數量的元素，且兩個陣列中對應的元素對相等，則視為相等。換句話說，若兩個陣列包含相同元素且順序相同，則稱它們相等。此外，若兩個陣列參考皆為 null，則視為相等。

兩個雙重 d1 和 d2 視為相等，當條件是：

{@code Double.valueOf(d1).equals(Double.valueOf(d2))}

（與算 == 符不同，此方法將 NaN 視為等於自身，且 0.0d 不等於 -0.0d。）

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

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

適用於

Equals(Char[], 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[]

另一個陣列要測試相等性

傳回

Boolean

true 若兩個陣列相等

屬性: RegisterAttribute

備註

若兩個指定的 char 陣列相等，則回傳true。若兩個陣列包含相同數量的元素，且兩個陣列中對應的元素對相等，則視為相等。換句話說，若兩個陣列包含相同元素且順序相同，則稱它們相等。此外，若兩個陣列參考皆為 null，則視為相等。

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

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

適用於

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

另一個陣列要測試相等性

傳回

Boolean

true 若兩個陣列相等

屬性: RegisterAttribute

備註

若兩個指定的位元組陣列相等，則回傳true。若兩個陣列包含相同數量的元素，且兩個陣列中對應的元素對相等，則視為相等。換句話說，若兩個陣列包含相同元素且順序相同，則稱它們相等。此外，若兩個陣列參考皆為 null，則視為相等。

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

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

適用於

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

另一個陣列要測試相等性

傳回

Boolean

true 若兩個陣列相等

屬性: RegisterAttribute

備註

若兩個指定的布林陣列彼此相等，則回傳true。若兩個陣列包含相同數量的元素，且兩個陣列中對應的元素對相等，則視為相等。換句話說，若兩個陣列包含相同元素且順序相同，則稱它們相等。此外，若兩個陣列參考皆為 null，則視為相等。

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

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

適用於

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

另一個陣列要測試相等性

傳回

Boolean

true 若兩個陣列相等

屬性: RegisterAttribute

備註

若兩個指定的物件陣列相等，則回傳true。若兩個陣列包含相同數量的元素，且兩個陣列中對應的元素對相等，則視為相等。兩個物件 e1 和 e2 若，則視為相等。Objects.equals(e1, e2) 換句話說，若兩個陣列包含相同元素且順序相同，則它們相等。此外，若兩個陣列參考皆為 null，則視為相等。

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

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

適用於

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