Arrays.Mismatch メソッド

[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

パラメーター

返品

指定した範囲の 2 つの配列間の最初の不一致の相対インデックス。それ以外の場合は -1。

属性

RegisterAttribute JavaTypeParametersAttribute

注釈

指定した範囲の 2 つの Object 配列間の最初の不一致の相対インデックスを検索して返します。一致しない場合は -1 返します。 インデックスは、小さい範囲の長さ (両端を含む) まで 0 (両端を含む) の範囲になります。

指定された範囲で 2 つの配列が共通のプレフィックスを共有する場合、返される相対インデックスは共通プレフィックスの長さであり、それぞれの配列内のその相対インデックスにある 2 つの要素の間に不一致があることを示します。 一方の配列が、指定された範囲のもう一方の正しいプレフィックスである場合、返される相対インデックスは、より小さい範囲の長さになり、その後の相対インデックスは、より大きな範囲の配列に対してのみ有効になります。 それ以外の場合は、不一致はありません。

指定した範囲 [aFromIndex, atoIndex) と [bFromIndex, btoIndex) を持つaとbの 2 つの非null配列は、次の式が true の場合に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の一般的なプレフィックス長は、各配列の最初の要素が一致しない点に注意してください。

指定した範囲 [aFromIndex, atoIndex) と [bFromIndex, btoIndex) を持つaとbの 2 つの非null配列は、次の式が true の場合は適切なプレフィックスを共有します。

{@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ドキュメント。

このページの一部は、によって作成および共有され、に記載されている条件に従って使用される作業に基づく変更です。

[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

パラメーター

返品

指定した範囲の 2 つの配列間の最初の不一致の相対インデックス。それ以外の場合は -1。

属性

RegisterAttribute

注釈

指定した範囲の 2 つの float 配列間の最初の不一致の相対インデックスを検索して返します。一致しない場合は -1 返します。 インデックスは、小さい範囲の長さ (両端を含む) まで 0 (両端を含む) の範囲になります。

指定された範囲で 2 つの配列が共通のプレフィックスを共有する場合、返される相対インデックスは共通プレフィックスの長さであり、それぞれの配列内のその相対インデックスにある 2 つの要素の間に不一致があることを示します。 一方の配列が、指定された範囲のもう一方の正しいプレフィックスである場合、返される相対インデックスは、より小さい範囲の長さになり、その後の相対インデックスは、より大きな範囲の配列に対してのみ有効になります。 それ以外の場合は、不一致はありません。

指定した範囲 [aFromIndex, aToIndex) と [bFromIndex, bToIndex) を持つaとbの 2 つの非null配列は、次の式が true の場合に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の一般的なプレフィックス長は、各配列の最初の要素が一致しない点に注意してください。

指定した範囲 [aFromIndex, aToIndex) と [bFromIndex, bToIndex) を持つaとbの 2 つの非null配列は、次の式が true の場合は適切なプレフィックスを共有します。

{@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ドキュメント。

このページの一部は、によって作成および共有され、に記載されている条件に従って使用される作業に基づく変更です。

[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

パラメーター

返品

指定した範囲の 2 つの配列間の最初の不一致の相対インデックス。それ以外の場合は -1。

属性

RegisterAttribute

注釈

指定した範囲の 2 つの long 配列間の最初の不一致の相対インデックスを検索して返します。一致しない場合は -1 返します。 インデックスは、小さい範囲の長さ (両端を含む) まで 0 (両端を含む) の範囲になります。

指定された範囲で 2 つの配列が共通のプレフィックスを共有する場合、返される相対インデックスは共通プレフィックスの長さであり、それぞれの配列内のその相対インデックスにある 2 つの要素の間に不一致があることを示します。 一方の配列が、指定された範囲のもう一方の正しいプレフィックスである場合、返される相対インデックスは、より小さい範囲の長さになり、その後の相対インデックスは、より大きな範囲の配列に対してのみ有効になります。 それ以外の場合は、不一致はありません。

指定した範囲 [aFromIndex, aToIndex) と [bFromIndex, bToIndex) を持つaとbの 2 つの非null配列は、次の式が true の場合に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の一般的なプレフィックス長は、各配列の最初の要素が一致しない点に注意してください。

指定した範囲 [aFromIndex, aToIndex) と [bFromIndex, bToIndex) を持つaとbの 2 つの非null配列は、次の式が true の場合は適切なプレフィックスを共有します。

{@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ドキュメント。

このページの一部は、によって作成および共有され、に記載されている条件に従って使用される作業に基づく変更です。

[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

パラメーター

返品

指定した範囲の 2 つの配列間の最初の不一致の相対インデックス。それ以外の場合は -1。

属性

RegisterAttribute

注釈

指定した範囲の 2 つの int 配列間の最初の不一致の相対インデックスを検索して返します。一致しない場合は -1 返します。 インデックスは、小さい範囲の長さ (両端を含む) まで 0 (両端を含む) の範囲になります。

指定された範囲で 2 つの配列が共通のプレフィックスを共有する場合、返される相対インデックスは共通プレフィックスの長さであり、それぞれの配列内のその相対インデックスにある 2 つの要素の間に不一致があることを示します。 一方の配列が、指定された範囲のもう一方の正しいプレフィックスである場合、返される相対インデックスは、より小さい範囲の長さになり、その後の相対インデックスは、より大きな範囲の配列に対してのみ有効になります。 それ以外の場合は、不一致はありません。

指定した範囲 [aFromIndex, aToIndex) と [bFromIndex, bToIndex) を持つaとbの 2 つの非null配列は、次の式が true の場合に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の一般的なプレフィックス長は、各配列の最初の要素が一致しない点に注意してください。

指定した範囲 [aFromIndex, aToIndex) と [bFromIndex, bToIndex) を持つaとbの 2 つの非null配列は、次の式が true の場合は適切なプレフィックスを共有します。

{@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ドキュメント。

このページの一部は、によって作成および共有され、に記載されている条件に従って使用される作業に基づく変更です。

[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

パラメーター

返品

指定した範囲の 2 つの配列間の最初の不一致の相対インデックス。それ以外の場合は -1。

属性

RegisterAttribute

注釈

指定した範囲の 2 つの short 配列間の最初の不一致の相対インデックスを検索して返します。一致しない場合は -1 返します。 インデックスは、小さい範囲の長さ (両端を含む) まで 0 (両端を含む) の範囲になります。

指定された範囲で 2 つの配列が共通のプレフィックスを共有する場合、返される相対インデックスは共通プレフィックスの長さであり、それぞれの配列内のその相対インデックスにある 2 つの要素の間に不一致があることを示します。 一方の配列が、指定された範囲のもう一方の正しいプレフィックスである場合、返される相対インデックスは、より小さい範囲の長さになり、その後の相対インデックスは、より大きな範囲の配列に対してのみ有効になります。 それ以外の場合は、不一致はありません。

指定した範囲 [aFromIndex, aToIndex) と [bFromIndex, bToIndex) を持つaとbの 2 つの非null配列は、次の式が true の場合に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の一般的なプレフィックス長は、各配列の最初の要素が一致しない点に注意してください。

指定した範囲 [aFromIndex, aToIndex) と [bFromIndex, bToIndex) を持つaとbの 2 つの非null配列は、次の式が true の場合は適切なプレフィックスを共有します。

{@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ドキュメント。

このページの一部は、によって作成および共有され、に記載されている条件に従って使用される作業に基づく変更です。

[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

パラメーター

返品

指定した範囲の 2 つの配列間の最初の不一致の相対インデックス。それ以外の場合は -1。

属性

RegisterAttribute

注釈

指定した範囲の 2 つの double 配列間の最初の不一致の相対インデックスを検索して返します。一致しない場合は -1 返します。 インデックスは、小さい範囲の長さ (両端を含む) まで 0 (両端を含む) の範囲になります。

指定された範囲で 2 つの配列が共通のプレフィックスを共有する場合、返される相対インデックスは共通プレフィックスの長さであり、それぞれの配列内のその相対インデックスにある 2 つの要素の間に不一致があることを示します。 一方の配列が、指定された範囲のもう一方の正しいプレフィックスである場合、返される相対インデックスは、より小さい範囲の長さになり、その後の相対インデックスは、より大きな範囲の配列に対してのみ有効になります。 それ以外の場合は、不一致はありません。

指定した範囲 [aFromIndex, aToIndex) と [bFromIndex, bToIndex) を持つaとbの 2 つの非null配列は、次の式が true の場合に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の一般的なプレフィックス長は、各配列の最初の要素が一致しない点に注意してください。

指定した範囲 [aFromIndex, aToIndex) と [bFromIndex, bToIndex) を持つaとbの 2 つの非null配列は、次の式が true の場合は適切なプレフィックスを共有します。

{@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ドキュメント。

このページの一部は、によって作成および共有され、に記載されている条件に従って使用される作業に基づく変更です。

[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

パラメーター

返品

指定した範囲の 2 つの配列間の最初の不一致の相対インデックス。それ以外の場合は -1。

属性

RegisterAttribute

注釈

指定した範囲の 2 つの char 配列間の最初の不一致の相対インデックスを検索して返します。一致しない場合は -1 返します。 インデックスは、小さい範囲の長さ (両端を含む) まで 0 (両端を含む) の範囲になります。

指定された範囲で 2 つの配列が共通のプレフィックスを共有する場合、返される相対インデックスは共通プレフィックスの長さであり、それぞれの配列内のその相対インデックスにある 2 つの要素の間に不一致があることを示します。 一方の配列が、指定された範囲のもう一方の正しいプレフィックスである場合、返される相対インデックスは、より小さい範囲の長さになり、その後の相対インデックスは、より大きな範囲の配列に対してのみ有効になります。 それ以外の場合は、不一致はありません。

指定した範囲 [aFromIndex, aToIndex) と [bFromIndex, bToIndex) を持つaとbの 2 つの非null配列は、次の式が true の場合に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の一般的なプレフィックス長は、各配列の最初の要素が一致しない点に注意してください。

指定した範囲 [aFromIndex, aToIndex) と [bFromIndex, bToIndex) を持つaとbの 2 つの非null配列は、次の式が true の場合は適切なプレフィックスを共有します。

{@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ドキュメント。

このページの一部は、によって作成および共有され、に記載されている条件に従って使用される作業に基づく変更です。

[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

パラメーター

返品

指定した範囲の 2 つの配列間の最初の不一致の相対インデックス。それ以外の場合は -1。

属性

RegisterAttribute

注釈

指定した範囲の 2 つの byte 配列間の最初の不一致の相対インデックスを検索して返します。一致しない場合は -1 返します。 インデックスは、小さい範囲の長さ (両端を含む) まで 0 (両端を含む) の範囲になります。

指定された範囲で 2 つの配列が共通のプレフィックスを共有する場合、返される相対インデックスは共通プレフィックスの長さであり、それぞれの配列内のその相対インデックスにある 2 つの要素の間に不一致があることを示します。 一方の配列が、指定された範囲のもう一方の正しいプレフィックスである場合、返される相対インデックスは、より小さい範囲の長さになり、その後の相対インデックスは、より大きな範囲の配列に対してのみ有効になります。 それ以外の場合は、不一致はありません。

指定した範囲 [aFromIndex, aToIndex) と [bFromIndex, bToIndex) を持つaとbの 2 つの非null配列は、次の式が true の場合に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の一般的なプレフィックス長は、各配列の最初の要素が一致しない点に注意してください。

指定した範囲 [aFromIndex, aToIndex) と [bFromIndex, bToIndex) を持つaとbの 2 つの非null配列は、次の式が true の場合は適切なプレフィックスを共有します。

{@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ドキュメント。

このページの一部は、によって作成および共有され、に記載されている条件に従って使用される作業に基づく変更です。

[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

パラメーター

返品

指定した範囲の 2 つの配列間の最初の不一致の相対インデックス。それ以外の場合は -1。

属性

RegisterAttribute

注釈

指定した範囲の 2 つの boolean 配列間の最初の不一致の相対インデックスを検索して返します。一致しない場合は -1 返します。 インデックスは、小さい範囲の長さ (両端を含む) まで 0 (両端を含む) の範囲になります。

指定された範囲で 2 つの配列が共通のプレフィックスを共有する場合、返される相対インデックスは共通プレフィックスの長さであり、それぞれの配列内のその相対インデックスにある 2 つの要素の間に不一致があることを示します。 一方の配列が、指定された範囲のもう一方の正しいプレフィックスである場合、返される相対インデックスは、より小さい範囲の長さになり、その後の相対インデックスは、より大きな範囲の配列に対してのみ有効になります。 それ以外の場合は、不一致はありません。

指定した範囲 [aFromIndex, aToIndex) と [bFromIndex, bToIndex) を持つaとbの 2 つの非null配列は、次の式が true の場合に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の一般的なプレフィックス長は、各配列の最初の要素が一致しない点に注意してください。

指定した範囲 [aFromIndex, aToIndex) と [bFromIndex, bToIndex) を持つaとbの 2 つの非null配列は、次の式が true の場合は適切なプレフィックスを共有します。

{@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ドキュメント。

このページの一部は、によって作成および共有され、に記載されている条件に従って使用される作業に基づく変更です。

[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

パラメーター

返品

指定した範囲の 2 つの配列間の最初の不一致の相対インデックス。それ以外の場合は -1。

属性

RegisterAttribute

注釈

指定した範囲の 2 つの Object 配列間の最初の不一致の相対インデックスを検索して返します。一致しない場合は -1 返します。 インデックスは、小さい範囲の長さ (両端を含む) まで 0 (両端を含む) の範囲になります。

指定された範囲で 2 つの配列が共通のプレフィックスを共有する場合、返される相対インデックスは共通プレフィックスの長さであり、それぞれの配列内のその相対インデックスにある 2 つの要素の間に不一致があることを示します。 一方の配列が、指定された範囲のもう一方の正しいプレフィックスである場合、返される相対インデックスは、より小さい範囲の長さになり、その後の相対インデックスは、より大きな範囲の配列に対してのみ有効になります。 それ以外の場合は、不一致はありません。

指定した範囲 [aFromIndex, atoIndex) と [bFromIndex, btoIndex) を持つaとbの 2 つの非null配列は、次の式が true の場合に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の一般的なプレフィックス長は、各配列の最初の要素が一致しない点に注意してください。

指定した範囲 [aFromIndex, atoIndex) と [bFromIndex, btoIndex) を持つaとbの 2 つの非null配列は、次の式が true の場合は適切なプレフィックスを共有します。

{@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ドキュメント。

このページの一部は、によって作成および共有され、に記載されている条件に従って使用される作業に基づく変更です。

[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

パラメーター

返品

2 つの配列間の最初の不一致のインデックス。それ以外の場合は -1。

属性

RegisterAttribute

注釈

2 つの float 配列間の最初の不一致のインデックスを検索して返します。一致しない場合は -1 返します。 インデックスは、小さい配列の長さ (両端を含む) までの 0 (両端を含む) の範囲になります。

2 つの配列が共通のプレフィックスを共有する場合、返されるインデックスは共通プレフィックスの長さであり、それぞれの配列内のそのインデックスの 2 つの要素間に不一致があることを示します。 一方の配列がもう一方の配列の正しいプレフィックスである場合、返されるインデックスは小さい配列の長さであり、その後のインデックスは大きな配列に対してのみ有効です。 それ以外の場合は、不一致はありません。

aとbの 2 つの非null配列は、次の式が true の場合に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の一般的なプレフィックス長は、各配列の最初の要素が一致しない点に注意してください。

次の式が true の場合、aとbの 2 つの非null配列が適切なプレフィックスを共有します。

{@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ドキュメント。

このページの一部は、によって作成および共有され、に記載されている条件に従って使用される作業に基づく変更です。

[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

パラメーター

返品

2 つの配列間の最初の不一致のインデックス。それ以外の場合は -1。

属性

RegisterAttribute

注釈

2 つの long 配列間の最初の不一致のインデックスを検索して返します。一致しない場合は -1 返します。 インデックスは、小さい配列の長さ (両端を含む) までの 0 (両端を含む) の範囲になります。

2 つの配列が共通のプレフィックスを共有する場合、返されるインデックスは共通プレフィックスの長さであり、それぞれの配列内のそのインデックスの 2 つの要素間に不一致があることを示します。 一方の配列がもう一方の配列の正しいプレフィックスである場合、返されるインデックスは小さい配列の長さであり、その後のインデックスは大きな配列に対してのみ有効です。 それ以外の場合は、不一致はありません。

aとbの 2 つの非null配列は、次の式が true の場合にpl長さの共通プレフィックスを共有します。

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

0の一般的なプレフィックス長は、各配列の最初の要素が一致しない点に注意してください。

次の式が true の場合、aとbの 2 つの非null配列が適切なプレフィックスを共有します。

{@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ドキュメント。

このページの一部は、によって作成および共有され、に記載されている条件に従って使用される作業に基づく変更です。

[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

パラメーター

返品

2 つの配列間の最初の不一致のインデックス。それ以外の場合は -1。

属性

RegisterAttribute

注釈

2 つの int 配列間の最初の不一致のインデックスを検索して返します。一致しない場合は -1 返します。 インデックスは、小さい配列の長さ (両端を含む) までの 0 (両端を含む) の範囲になります。

2 つの配列が共通のプレフィックスを共有する場合、返されるインデックスは共通プレフィックスの長さであり、それぞれの配列内のそのインデックスの 2 つの要素間に不一致があることを示します。 一方の配列がもう一方の配列の正しいプレフィックスである場合、返されるインデックスは小さい配列の長さであり、その後のインデックスは大きな配列に対してのみ有効です。 それ以外の場合は、不一致はありません。

aとbの 2 つの非null配列は、次の式が true の場合にpl長さの共通プレフィックスを共有します。

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

0の一般的なプレフィックス長は、各配列の最初の要素が一致しない点に注意してください。

次の式が true の場合、aとbの 2 つの非null配列が適切なプレフィックスを共有します。

{@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ドキュメント。

このページの一部は、によって作成および共有され、に記載されている条件に従って使用される作業に基づく変更です。

[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

パラメーター

返品

2 つの配列間の最初の不一致のインデックス。それ以外の場合は -1。

属性

RegisterAttribute

注釈

2 つの short 配列間の最初の不一致のインデックスを検索して返します。一致しない場合は -1 返します。 インデックスは、小さい配列の長さ (両端を含む) までの 0 (両端を含む) の範囲になります。

2 つの配列が共通のプレフィックスを共有する場合、返されるインデックスは共通プレフィックスの長さであり、それぞれの配列内のそのインデックスの 2 つの要素間に不一致があることを示します。 一方の配列がもう一方の配列の正しいプレフィックスである場合、返されるインデックスは小さい配列の長さであり、その後のインデックスは大きな配列に対してのみ有効です。 それ以外の場合は、不一致はありません。

aとbの 2 つの非null配列は、次の式が true の場合にpl長さの共通プレフィックスを共有します。

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

0の一般的なプレフィックス長は、各配列の最初の要素が一致しない点に注意してください。

次の式が true の場合、aとbの 2 つの非null配列が適切なプレフィックスを共有します。

{@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ドキュメント。

このページの一部は、によって作成および共有され、に記載されている条件に従って使用される作業に基づく変更です。

[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

パラメーター

返品

2 つの配列間の最初の不一致のインデックス。それ以外の場合は -1。

属性

RegisterAttribute

注釈

2 つの double 配列間の最初の不一致のインデックスを検索して返します。一致しない場合は -1 返します。 インデックスは、小さい配列の長さ (両端を含む) までの 0 (両端を含む) の範囲になります。

2 つの配列が共通のプレフィックスを共有する場合、返されるインデックスは共通プレフィックスの長さであり、それぞれの配列内のそのインデックスの 2 つの要素間に不一致があることを示します。 一方の配列がもう一方の配列の正しいプレフィックスである場合、返されるインデックスは小さい配列の長さであり、その後のインデックスは大きな配列に対してのみ有効です。 それ以外の場合は、不一致はありません。

aとbの 2 つの非null配列は、次の式が true の場合に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の一般的なプレフィックス長は、各配列の最初の要素が一致しない点に注意してください。

次の式が true の場合、aとbの 2 つの非null配列が適切なプレフィックスを共有します。

{@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ドキュメント。

このページの一部は、によって作成および共有され、に記載されている条件に従って使用される作業に基づく変更です。

[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

パラメーター

返品

2 つの配列間の最初の不一致のインデックス。それ以外の場合は -1。

属性

RegisterAttribute

注釈

2 つの char 配列間の最初の不一致のインデックスを検索して返します。一致しない場合は -1 返します。 インデックスは、小さい配列の長さ (両端を含む) までの 0 (両端を含む) の範囲になります。

2 つの配列が共通のプレフィックスを共有する場合、返されるインデックスは共通プレフィックスの長さであり、それぞれの配列内のそのインデックスの 2 つの要素間に不一致があることを示します。 一方の配列がもう一方の配列の正しいプレフィックスである場合、返されるインデックスは小さい配列の長さであり、その後のインデックスは大きな配列に対してのみ有効です。 それ以外の場合は、不一致はありません。

aとbの 2 つの非null配列は、次の式が true の場合にpl長さの共通プレフィックスを共有します。

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

0の一般的なプレフィックス長は、各配列の最初の要素が一致しない点に注意してください。

次の式が true の場合、aとbの 2 つの非null配列が適切なプレフィックスを共有します。

{@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ドキュメント。

このページの一部は、によって作成および共有され、に記載されている条件に従って使用される作業に基づく変更です。

[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

パラメーター

返品

2 つの配列間の最初の不一致のインデックス。それ以外の場合は -1。

属性

RegisterAttribute

注釈

2 つの byte 配列間の最初の不一致のインデックスを検索して返します。一致しない場合は -1 返します。 インデックスは、小さい配列の長さ (両端を含む) までの 0 (両端を含む) の範囲になります。

2 つの配列が共通のプレフィックスを共有する場合、返されるインデックスは共通プレフィックスの長さであり、それぞれの配列内のそのインデックスの 2 つの要素間に不一致があることを示します。 一方の配列がもう一方の配列の正しいプレフィックスである場合、返されるインデックスは小さい配列の長さであり、その後のインデックスは大きな配列に対してのみ有効です。 それ以外の場合は、不一致はありません。

aとbの 2 つの非null配列は、次の式が true の場合にpl長さの共通プレフィックスを共有します。

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

0の一般的なプレフィックス長は、各配列の最初の要素が一致しない点に注意してください。

次の式が true の場合、aとbの 2 つの非null配列が適切なプレフィックスを共有します。

{@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ドキュメント。

このページの一部は、によって作成および共有され、に記載されている条件に従って使用される作業に基づく変更です。

[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

パラメーター

返品

2 つの配列間の最初の不一致のインデックス。それ以外の場合は -1。

属性

RegisterAttribute

注釈

2 つの boolean 配列間の最初の不一致のインデックスを検索して返します。一致しない場合は -1 返します。 インデックスは、小さい配列の長さ (両端を含む) までの 0 (両端を含む) の範囲になります。

2 つの配列が共通のプレフィックスを共有する場合、返されるインデックスは共通プレフィックスの長さであり、それぞれの配列内のそのインデックスの 2 つの要素間に不一致があることを示します。 一方の配列がもう一方の配列の正しいプレフィックスである場合、返されるインデックスは小さい配列の長さであり、その後のインデックスは大きな配列に対してのみ有効です。 それ以外の場合は、不一致はありません。

aとbの 2 つの非null配列は、次の式が true の場合にpl長さの共通プレフィックスを共有します。

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

0の一般的なプレフィックス長は、各配列の最初の要素が一致しない点に注意してください。

次の式が true の場合、aとbの 2 つの非null配列が適切なプレフィックスを共有します。

{@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ドキュメント。

このページの一部は、によって作成および共有され、に記載されている条件に従って使用される作業に基づく変更です。

[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

パラメーター

返品

2 つの配列間の最初の不一致のインデックス。それ以外の場合は -1。

属性

RegisterAttribute

注釈

2 つの Object 配列間の最初の不一致のインデックスを検索して返します。一致しない場合は -1 返します。 インデックスは、小さい配列の長さ (両端を含む) までの 0 (両端を含む) の範囲になります。

2 つの配列が共通のプレフィックスを共有する場合、返されるインデックスは共通プレフィックスの長さであり、それぞれの配列内のそのインデックスの 2 つの要素間に不一致があることを示します。 一方の配列がもう一方の配列の正しいプレフィックスである場合、返されるインデックスは小さい配列の長さであり、その後のインデックスは大きな配列に対してのみ有効です。 それ以外の場合は、不一致はありません。

aとbの 2 つの非null配列は、次の式が true の場合に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の一般的なプレフィックス長は、各配列の最初の要素が一致しない点に注意してください。

次の式が true の場合、aとbの 2 つの非null配列が適切なプレフィックスを共有します。

{@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ドキュメント。

このページの一部は、によって作成および共有され、に記載されている条件に従って使用される作業に基づく変更です。

[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

パラメーター

返品

2 つの配列間の最初の不一致のインデックス。それ以外の場合は -1。

属性

RegisterAttribute JavaTypeParametersAttribute

注釈

2 つの Object 配列間の最初の不一致のインデックスを検索して返します。一致しない場合は -1 返します。 インデックスは、小さい配列の長さ (両端を含む) までの 0 (両端を含む) の範囲になります。

指定された比較子は、各配列の 2 つの配列要素が等しくないかどうかを判断するために使用されます。

2 つの配列が共通のプレフィックスを共有する場合、返されるインデックスは共通プレフィックスの長さであり、それぞれの配列内のそのインデックスの 2 つの要素間に不一致があることを示します。 一方の配列がもう一方の配列の正しいプレフィックスである場合、返されるインデックスは小さい配列の長さであり、その後のインデックスは大きな配列に対してのみ有効です。 それ以外の場合は、不一致はありません。

aとbの 2 つの非null配列は、次の式が true の場合に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の一般的なプレフィックス長は、各配列の最初の要素が一致しない点に注意してください。

次の式が true の場合、aとbの 2 つの非null配列が適切なプレフィックスを共有します。

{@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ドキュメント。

このページの一部は、によって作成および共有され、に記載されている条件に従って使用される作業に基づく変更です。