Arrays.Mismatch Méthode

[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

Paramètres

Retours

index relatif de la première incompatibilité entre les deux tableaux sur les plages spécifiées ; sinon -1.

Attributs

RegisterAttribute JavaTypeParametersAttribute

Remarques

Recherche et retourne l’index relatif de la première incompatibilité entre deux Object tableaux sur les plages spécifiées, sinon retourne -1 si aucune incompatibilité n’est trouvée. L’index se trouvera dans la plage de 0 (inclus) jusqu’à la longueur (inclusive) de la plus petite plage.

Si les deux tableaux, sur les plages spécifiées, partagent un préfixe commun, l’index relatif retourné est la longueur du préfixe commun et il suit qu’il existe une incompatibilité entre les deux éléments à cet index relatif dans les tableaux respectifs. Si un tableau est un préfixe approprié de l’autre, sur les plages spécifiées, l’index relatif retourné est la longueur de la plage plus petite et il suit que l’index relatif n’est valide que pour le tableau avec la plus grande plage. Sinon, il n’y a pas d’incompatibilité.

Deux tableaux non-tableauxnull et ab avec des plages spécifiées [aFromIndex, atoIndex) et [bFromIndex, btoIndex) partagent respectivement un préfixe commun de longueur pl si l’expression suivante est vraie :

{@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
            }

Notez qu’une longueur 0 de préfixe commune indique que les premiers éléments de chaque incompatibilité de tableau.

Deux tableaux non-tableauxnull et ab avec des plages spécifiées [aFromIndex, atoIndex) et [bFromIndex, btoIndex) partagent respectivement un préfixe approprié si l’expression suivante est vraie :

{@code
                (aToIndex - aFromIndex) != (bToIndex - bFromIndex) &&
                Arrays.equals(a, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex),
                              b, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex),
                              cmp)
            }

Ajouté dans 9.

Documentation Java pour java.util.Arrays.mismatch(T[], int, int, T[], int, int, java.util.Comparator<? super T>).

Les parties de cette page sont des modifications basées sur le travail créé et partagé par le projet Android Open Source et utilisés en fonction des termes décrits dans la licence d’attribution Creative Commons 2.5.

[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

Paramètres

Retours

index relatif de la première incompatibilité entre les deux tableaux sur les plages spécifiées ; sinon -1.

Attributs

RegisterAttribute

Remarques

Recherche et retourne l’index relatif de la première incompatibilité entre deux float tableaux sur les plages spécifiées, sinon retourne -1 si aucune incompatibilité n’est trouvée. L’index se trouvera dans la plage de 0 (inclus) jusqu’à la longueur (inclusive) de la plus petite plage.

Si les deux tableaux, sur les plages spécifiées, partagent un préfixe commun, l’index relatif retourné est la longueur du préfixe commun et il suit qu’il existe une incompatibilité entre les deux éléments à cet index relatif dans les tableaux respectifs. Si un tableau est un préfixe approprié de l’autre, sur les plages spécifiées, l’index relatif retourné est la longueur de la plage plus petite et il suit que l’index relatif n’est valide que pour le tableau avec la plus grande plage. Sinon, il n’y a pas d’incompatibilité.

Deux tableaux non-tableauxnull et ab avec des plages spécifiées [aFromIndex, aToIndex) et [bFromIndex, bToIndex) partagent respectivement un préfixe commun de longueur pl si l’expression suivante est vraie :

{@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
            }

Notez qu’une longueur 0 de préfixe commune indique que les premiers éléments de chaque incompatibilité de tableau.

Deux tableaux non-tableauxnull et ab avec des plages spécifiées [aFromIndex, aToIndex) et [bFromIndex, bToIndex) partagent respectivement un préfixe approprié si l’expression suivante est vraie :

{@code
                (aToIndex - aFromIndex) != (bToIndex - bFromIndex) &&
                Arrays.equals(a, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex),
                              b, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
            }

Ajouté dans 9.

Documentation Java pour java.util.Arrays.mismatch(.*float[], .*int, .*int, .*float[], .*int, .*int).

Les parties de cette page sont des modifications basées sur le travail créé et partagé par le projet Android Open Source et utilisés en fonction des termes décrits dans la licence d’attribution Creative Commons 2.5.

[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

Paramètres

Retours

index relatif de la première incompatibilité entre les deux tableaux sur les plages spécifiées ; sinon -1.

Attributs

RegisterAttribute

Remarques

Recherche et retourne l’index relatif de la première incompatibilité entre deux long tableaux sur les plages spécifiées, sinon retourne -1 si aucune incompatibilité n’est trouvée. L’index se trouvera dans la plage de 0 (inclus) jusqu’à la longueur (inclusive) de la plus petite plage.

Si les deux tableaux, sur les plages spécifiées, partagent un préfixe commun, l’index relatif retourné est la longueur du préfixe commun et il suit qu’il existe une incompatibilité entre les deux éléments à cet index relatif dans les tableaux respectifs. Si un tableau est un préfixe approprié de l’autre, sur les plages spécifiées, l’index relatif retourné est la longueur de la plage plus petite et il suit que l’index relatif n’est valide que pour le tableau avec la plus grande plage. Sinon, il n’y a pas d’incompatibilité.

Deux tableaux non-tableauxnull et ab avec des plages spécifiées [aFromIndex, aToIndex) et [bFromIndex, bToIndex) partagent respectivement un préfixe commun de longueur pl si l’expression suivante est vraie :

{@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]
            }

Notez qu’une longueur 0 de préfixe commune indique que les premiers éléments de chaque incompatibilité de tableau.

Deux tableaux non-tableauxnull et ab avec des plages spécifiées [aFromIndex, aToIndex) et [bFromIndex, bToIndex) partagent respectivement un préfixe approprié si l’expression suivante est vraie :

{@code
                (aToIndex - aFromIndex) != (bToIndex - bFromIndex) &&
                Arrays.equals(a, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex),
                              b, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
            }

Ajouté dans 9.

Documentation Java pour java.util.Arrays.mismatch(.*long[], .*int, .*int, .*long[], .*int, .*int).

Les parties de cette page sont des modifications basées sur le travail créé et partagé par le projet Android Open Source et utilisés en fonction des termes décrits dans la licence d’attribution Creative Commons 2.5.

[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

Paramètres

Retours

index relatif de la première incompatibilité entre les deux tableaux sur les plages spécifiées ; sinon -1.

Attributs

RegisterAttribute

Remarques

Recherche et retourne l’index relatif de la première incompatibilité entre deux int tableaux sur les plages spécifiées, sinon retourne -1 si aucune incompatibilité n’est trouvée. L’index se trouvera dans la plage de 0 (inclus) jusqu’à la longueur (inclusive) de la plus petite plage.

Si les deux tableaux, sur les plages spécifiées, partagent un préfixe commun, l’index relatif retourné est la longueur du préfixe commun et il suit qu’il existe une incompatibilité entre les deux éléments à cet index relatif dans les tableaux respectifs. Si un tableau est un préfixe approprié de l’autre, sur les plages spécifiées, l’index relatif retourné est la longueur de la plage plus petite et il suit que l’index relatif n’est valide que pour le tableau avec la plus grande plage. Sinon, il n’y a pas d’incompatibilité.

Deux tableaux non-tableauxnull et ab avec des plages spécifiées [aFromIndex, aToIndex) et [bFromIndex, bToIndex) partagent respectivement un préfixe commun de longueur pl si l’expression suivante est vraie :

{@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]
            }

Notez qu’une longueur 0 de préfixe commune indique que les premiers éléments de chaque incompatibilité de tableau.

Deux tableaux non-tableauxnull et ab avec des plages spécifiées [aFromIndex, aToIndex) et [bFromIndex, bToIndex) partagent respectivement un préfixe approprié si l’expression suivante est vraie :

{@code
                (aToIndex - aFromIndex) != (bToIndex - bFromIndex) &&
                Arrays.equals(a, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex),
                              b, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
            }

Ajouté dans 9.

Documentation Java pour java.util.Arrays.mismatch(.*int[], .*int, .*int, .*int[], .*int, .*int).

Les parties de cette page sont des modifications basées sur le travail créé et partagé par le projet Android Open Source et utilisés en fonction des termes décrits dans la licence d’attribution Creative Commons 2.5.

[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

Paramètres

Retours

index relatif de la première incompatibilité entre les deux tableaux sur les plages spécifiées ; sinon -1.

Attributs

RegisterAttribute

Remarques

Recherche et retourne l’index relatif de la première incompatibilité entre deux short tableaux sur les plages spécifiées, sinon retourne -1 si aucune incompatibilité n’est trouvée. L’index se trouvera dans la plage de 0 (inclus) jusqu’à la longueur (inclusive) de la plus petite plage.

Si les deux tableaux, sur les plages spécifiées, partagent un préfixe commun, l’index relatif retourné est la longueur du préfixe commun et il suit qu’il existe une incompatibilité entre les deux éléments à cet index relatif dans les tableaux respectifs. Si un tableau est un préfixe approprié de l’autre, sur les plages spécifiées, l’index relatif retourné est la longueur de la plage plus petite et il suit que l’index relatif n’est valide que pour le tableau avec la plus grande plage. Sinon, il n’y a pas d’incompatibilité.

Deux tableaux non-tableauxnull et ab avec des plages spécifiées [aFromIndex, aToIndex) et [bFromIndex, bToIndex) partagent respectivement un préfixe commun de longueur pl si l’expression suivante est vraie :

{@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]
            }

Notez qu’une longueur 0 de préfixe commune indique que les premiers éléments de chaque incompatibilité de tableau.

Deux tableaux non-tableauxnull et ab avec des plages spécifiées [aFromIndex, aToIndex) et [bFromIndex, bToIndex) partagent respectivement un préfixe approprié si l’expression suivante est vraie :

{@code
                (aToIndex - aFromIndex) != (bToIndex - bFromIndex) &&
                Arrays.equals(a, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex),
                              b, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
            }

Ajouté dans 9.

Documentation Java pour java.util.Arrays.mismatch(.*short[], .*int, .*int, .*short[], .*int, .*int).

Les parties de cette page sont des modifications basées sur le travail créé et partagé par le projet Android Open Source et utilisés en fonction des termes décrits dans la licence d’attribution Creative Commons 2.5.

[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

Paramètres

Retours

index relatif de la première incompatibilité entre les deux tableaux sur les plages spécifiées ; sinon -1.

Attributs

RegisterAttribute

Remarques

Recherche et retourne l’index relatif de la première incompatibilité entre deux double tableaux sur les plages spécifiées, sinon retourne -1 si aucune incompatibilité n’est trouvée. L’index se trouvera dans la plage de 0 (inclus) jusqu’à la longueur (inclusive) de la plus petite plage.

Si les deux tableaux, sur les plages spécifiées, partagent un préfixe commun, l’index relatif retourné est la longueur du préfixe commun et il suit qu’il existe une incompatibilité entre les deux éléments à cet index relatif dans les tableaux respectifs. Si un tableau est un préfixe approprié de l’autre, sur les plages spécifiées, l’index relatif retourné est la longueur de la plage plus petite et il suit que l’index relatif n’est valide que pour le tableau avec la plus grande plage. Sinon, il n’y a pas d’incompatibilité.

Deux tableaux non-tableauxnull et ab avec des plages spécifiées [aFromIndex, aToIndex) et [bFromIndex, bToIndex) partagent respectivement un préfixe commun de longueur pl si l’expression suivante est vraie :

{@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
            }

Notez qu’une longueur 0 de préfixe commune indique que les premiers éléments de chaque incompatibilité de tableau.

Deux tableaux non-tableauxnull et ab avec des plages spécifiées [aFromIndex, aToIndex) et [bFromIndex, bToIndex) partagent respectivement un préfixe approprié si l’expression suivante est vraie :

{@code
                (aToIndex - aFromIndex) != (bToIndex - bFromIndex) &&
                Arrays.equals(a, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex),
                              b, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
            }

Ajouté dans 9.

Documentation Java pour java.util.Arrays.mismatch(.*double[], .*int, .*int, .*double[], .*int, .*int).

Les parties de cette page sont des modifications basées sur le travail créé et partagé par le projet Android Open Source et utilisés en fonction des termes décrits dans la licence d’attribution Creative Commons 2.5.

[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

Paramètres

Retours

index relatif de la première incompatibilité entre les deux tableaux sur les plages spécifiées ; sinon -1.

Attributs

RegisterAttribute

Remarques

Recherche et retourne l’index relatif de la première incompatibilité entre deux char tableaux sur les plages spécifiées, sinon retourne -1 si aucune incompatibilité n’est trouvée. L’index se trouvera dans la plage de 0 (inclus) jusqu’à la longueur (inclusive) de la plus petite plage.

Si les deux tableaux, sur les plages spécifiées, partagent un préfixe commun, l’index relatif retourné est la longueur du préfixe commun et il suit qu’il existe une incompatibilité entre les deux éléments à cet index relatif dans les tableaux respectifs. Si un tableau est un préfixe approprié de l’autre, sur les plages spécifiées, l’index relatif retourné est la longueur de la plage plus petite et il suit que l’index relatif n’est valide que pour le tableau avec la plus grande plage. Sinon, il n’y a pas d’incompatibilité.

Deux tableaux non-tableauxnull et ab avec des plages spécifiées [aFromIndex, aToIndex) et [bFromIndex, bToIndex) partagent respectivement un préfixe commun de longueur pl si l’expression suivante est vraie :

{@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]
            }

Notez qu’une longueur 0 de préfixe commune indique que les premiers éléments de chaque incompatibilité de tableau.

Deux tableaux non-tableauxnull et ab avec des plages spécifiées [aFromIndex, aToIndex) et [bFromIndex, bToIndex) partagent respectivement un préfixe approprié si l’expression suivante est vraie :

{@code
                (aToIndex - aFromIndex) != (bToIndex - bFromIndex) &&
                Arrays.equals(a, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex),
                              b, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
            }

Ajouté dans 9.

Documentation Java pour java.util.Arrays.mismatch(.*char[], .*int, .*int, .*char[], .*int, .*int).

Les parties de cette page sont des modifications basées sur le travail créé et partagé par le projet Android Open Source et utilisés en fonction des termes décrits dans la licence d’attribution Creative Commons 2.5.

[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

Paramètres

Retours

index relatif de la première incompatibilité entre les deux tableaux sur les plages spécifiées ; sinon -1.

Attributs

RegisterAttribute

Remarques

Recherche et retourne l’index relatif de la première incompatibilité entre deux byte tableaux sur les plages spécifiées, sinon retourne -1 si aucune incompatibilité n’est trouvée. L’index se trouvera dans la plage de 0 (inclus) jusqu’à la longueur (inclusive) de la plus petite plage.

Si les deux tableaux, sur les plages spécifiées, partagent un préfixe commun, l’index relatif retourné est la longueur du préfixe commun et il suit qu’il existe une incompatibilité entre les deux éléments à cet index relatif dans les tableaux respectifs. Si un tableau est un préfixe approprié de l’autre, sur les plages spécifiées, l’index relatif retourné est la longueur de la plage plus petite et il suit que l’index relatif n’est valide que pour le tableau avec la plus grande plage. Sinon, il n’y a pas d’incompatibilité.

Deux tableaux non-tableauxnull et ab avec des plages spécifiées [aFromIndex, aToIndex) et [bFromIndex, bToIndex) partagent respectivement un préfixe commun de longueur pl si l’expression suivante est vraie :

{@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]
            }

Notez qu’une longueur 0 de préfixe commune indique que les premiers éléments de chaque incompatibilité de tableau.

Deux tableaux non-tableauxnull et ab avec des plages spécifiées [aFromIndex, aToIndex) et [bFromIndex, bToIndex) partagent respectivement un préfixe approprié si l’expression suivante est vraie :

{@code
                (aToIndex - aFromIndex) != (bToIndex - bFromIndex) &&
                Arrays.equals(a, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex),
                              b, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
            }

Ajouté dans 9.

Documentation Java pour java.util.Arrays.mismatch(.*byte[], .*int, .*int, .*byte[], .*int, .*int).

Les parties de cette page sont des modifications basées sur le travail créé et partagé par le projet Android Open Source et utilisés en fonction des termes décrits dans la licence d’attribution Creative Commons 2.5.

[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

Paramètres

Retours

index relatif de la première incompatibilité entre les deux tableaux sur les plages spécifiées ; sinon -1.

Attributs

RegisterAttribute

Remarques

Recherche et retourne l’index relatif de la première incompatibilité entre deux boolean tableaux sur les plages spécifiées, sinon retourne -1 si aucune incompatibilité n’est trouvée. L’index se trouvera dans la plage de 0 (inclus) jusqu’à la longueur (inclusive) de la plus petite plage.

Si les deux tableaux, sur les plages spécifiées, partagent un préfixe commun, l’index relatif retourné est la longueur du préfixe commun et il suit qu’il existe une incompatibilité entre les deux éléments à cet index relatif dans les tableaux respectifs. Si un tableau est un préfixe approprié de l’autre, sur les plages spécifiées, l’index relatif retourné est la longueur de la plage plus petite et il suit que l’index relatif n’est valide que pour le tableau avec la plus grande plage. Sinon, il n’y a pas d’incompatibilité.

Deux tableaux non-tableauxnull et ab avec des plages spécifiées [aFromIndex, aToIndex) et [bFromIndex, bToIndex) partagent respectivement un préfixe commun de longueur pl si l’expression suivante est vraie :

{@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]
            }

Notez qu’une longueur 0 de préfixe commune indique que les premiers éléments de chaque incompatibilité de tableau.

Deux tableaux non-tableauxnull et ab avec des plages spécifiées [aFromIndex, aToIndex) et [bFromIndex, bToIndex) partagent respectivement un préfixe approprié si l’expression suivante est vraie :

{@code
                (aToIndex - aFromIndex) != (bToIndex - bFromIndex) &&
                Arrays.equals(a, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex),
                              b, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
            }

Ajouté dans 9.

Documentation Java pour java.util.Arrays.mismatch(.*boolean[], .*int, .*int, .*boolean[], .*int, .*int).

Les parties de cette page sont des modifications basées sur le travail créé et partagé par le projet Android Open Source et utilisés en fonction des termes décrits dans la licence d’attribution Creative Commons 2.5.

[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

Paramètres

Retours

index relatif de la première incompatibilité entre les deux tableaux sur les plages spécifiées ; sinon -1.

Attributs

RegisterAttribute

Remarques

Recherche et retourne l’index relatif de la première incompatibilité entre deux Object tableaux sur les plages spécifiées, sinon retourne -1 si aucune incompatibilité n’est trouvée. L’index se trouvera dans la plage de 0 (inclus) jusqu’à la longueur (inclusive) de la plus petite plage.

Si les deux tableaux, sur les plages spécifiées, partagent un préfixe commun, l’index relatif retourné est la longueur du préfixe commun et il suit qu’il existe une incompatibilité entre les deux éléments à cet index relatif dans les tableaux respectifs. Si un tableau est un préfixe approprié de l’autre, sur les plages spécifiées, l’index relatif retourné est la longueur de la plage plus petite et il suit que l’index relatif n’est valide que pour le tableau avec la plus grande plage. Sinon, il n’y a pas d’incompatibilité.

Deux tableaux non-tableauxnull et ab avec des plages spécifiées [aFromIndex, atoIndex) et [bFromIndex, btoIndex) partagent respectivement un préfixe commun de longueur pl si l’expression suivante est vraie :

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

Notez qu’une longueur 0 de préfixe commune indique que les premiers éléments de chaque incompatibilité de tableau.

Deux tableaux non-tableauxnull et ab avec des plages spécifiées [aFromIndex, atoIndex) et [bFromIndex, btoIndex) partagent respectivement un préfixe approprié si l’expression suivante est vraie :

{@code
                (aToIndex - aFromIndex) != (bToIndex - bFromIndex) &&
                Arrays.equals(a, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex),
                              b, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
            }

Ajouté dans 9.

Documentation Java pour java.util.Arrays.mismatch(java.lang.Object[], int, int, java.lang.Object[], int, int).

Les parties de cette page sont des modifications basées sur le travail créé et partagé par le projet Android Open Source et utilisés en fonction des termes décrits dans la licence d’attribution Creative Commons 2.5.

[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

Paramètres

Retours

index de la première incompatibilité entre les deux tableaux ; sinon -1.

Attributs

RegisterAttribute

Remarques

Recherche et retourne l’index de la première incompatibilité entre deux float tableaux, sinon retourne -1 si aucune incompatibilité n’est trouvée. L’index se trouvera dans la plage de 0 (inclusive) jusqu’à la longueur (inclusive) du tableau plus petit.

Si les deux tableaux partagent un préfixe commun, l’index retourné est la longueur du préfixe commun et il suit qu’il existe une incompatibilité entre les deux éléments à cet index dans les tableaux respectifs. Si un tableau est un préfixe approprié de l’autre, l’index retourné est la longueur du tableau plus petit et il suit que l’index est valide uniquement pour le tableau plus grand. Sinon, il n’y a pas d’incompatibilité.

Deux tableaux etnull partagent abun préfixe commun de longueur pl si l’expression suivante a la valeur true :

{@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
            }

Notez qu’une longueur 0 de préfixe commune indique que les premiers éléments de chaque incompatibilité de tableau.

Deux tableaux non-tableauxnull et, a partagez bun préfixe approprié si l’expression suivante est vraie :

{@code
                a.length != b.length &&
                Arrays.equals(a, 0, Math.min(a.length, b.length),
                              b, 0, Math.min(a.length, b.length))
            }

Ajouté dans 9.

Documentation Java pour java.util.Arrays.mismatch(.*float[], .*float[]).

Les parties de cette page sont des modifications basées sur le travail créé et partagé par le projet Android Open Source et utilisés en fonction des termes décrits dans la licence d’attribution Creative Commons 2.5.

[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

Paramètres

Retours

index de la première incompatibilité entre les deux tableaux ; sinon -1.

Attributs

RegisterAttribute

Remarques

Recherche et retourne l’index de la première incompatibilité entre deux long tableaux, sinon retourne -1 si aucune incompatibilité n’est trouvée. L’index se trouvera dans la plage de 0 (inclusive) jusqu’à la longueur (inclusive) du tableau plus petit.

Si les deux tableaux partagent un préfixe commun, l’index retourné est la longueur du préfixe commun et il suit qu’il existe une incompatibilité entre les deux éléments à cet index dans les tableaux respectifs. Si un tableau est un préfixe approprié de l’autre, l’index retourné est la longueur du tableau plus petit et il suit que l’index est valide uniquement pour le tableau plus grand. Sinon, il n’y a pas d’incompatibilité.

Deux tableaux etnull partagent abun préfixe commun de longueur pl si l’expression suivante a la valeur true :

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

Notez qu’une longueur 0 de préfixe commune indique que les premiers éléments de chaque incompatibilité de tableau.

Deux tableaux non-tableauxnull et, a partagez bun préfixe approprié si l’expression suivante est vraie :

{@code
                a.length != b.length &&
                Arrays.equals(a, 0, Math.min(a.length, b.length),
                              b, 0, Math.min(a.length, b.length))
            }

Ajouté dans 9.

Documentation Java pour java.util.Arrays.mismatch(.*long[], .*long[]).

Les parties de cette page sont des modifications basées sur le travail créé et partagé par le projet Android Open Source et utilisés en fonction des termes décrits dans la licence d’attribution Creative Commons 2.5.

[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

Paramètres

Retours

index de la première incompatibilité entre les deux tableaux ; sinon -1.

Attributs

RegisterAttribute

Remarques

Recherche et retourne l’index de la première incompatibilité entre deux int tableaux, sinon retourne -1 si aucune incompatibilité n’est trouvée. L’index se trouvera dans la plage de 0 (inclusive) jusqu’à la longueur (inclusive) du tableau plus petit.

Si les deux tableaux partagent un préfixe commun, l’index retourné est la longueur du préfixe commun et il suit qu’il existe une incompatibilité entre les deux éléments à cet index dans les tableaux respectifs. Si un tableau est un préfixe approprié de l’autre, l’index retourné est la longueur du tableau plus petit et il suit que l’index est valide uniquement pour le tableau plus grand. Sinon, il n’y a pas d’incompatibilité.

Deux tableaux etnull partagent abun préfixe commun de longueur pl si l’expression suivante a la valeur true :

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

Notez qu’une longueur 0 de préfixe commune indique que les premiers éléments de chaque incompatibilité de tableau.

Deux tableaux non-tableauxnull et, a partagez bun préfixe approprié si l’expression suivante est vraie :

{@code
                a.length != b.length &&
                Arrays.equals(a, 0, Math.min(a.length, b.length),
                              b, 0, Math.min(a.length, b.length))
            }

Ajouté dans 9.

Documentation Java pour java.util.Arrays.mismatch(.*int[], .*int[]).

Les parties de cette page sont des modifications basées sur le travail créé et partagé par le projet Android Open Source et utilisés en fonction des termes décrits dans la licence d’attribution Creative Commons 2.5.

[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

Paramètres

Retours

index de la première incompatibilité entre les deux tableaux ; sinon -1.

Attributs

RegisterAttribute

Remarques

Recherche et retourne l’index de la première incompatibilité entre deux short tableaux, sinon retourne -1 si aucune incompatibilité n’est trouvée. L’index se trouvera dans la plage de 0 (inclusive) jusqu’à la longueur (inclusive) du tableau plus petit.

Si les deux tableaux partagent un préfixe commun, l’index retourné est la longueur du préfixe commun et il suit qu’il existe une incompatibilité entre les deux éléments à cet index dans les tableaux respectifs. Si un tableau est un préfixe approprié de l’autre, l’index retourné est la longueur du tableau plus petit et il suit que l’index est valide uniquement pour le tableau plus grand. Sinon, il n’y a pas d’incompatibilité.

Deux tableaux etnull partagent abun préfixe commun de longueur pl si l’expression suivante a la valeur true :

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

Notez qu’une longueur 0 de préfixe commune indique que les premiers éléments de chaque incompatibilité de tableau.

Deux tableaux non-tableauxnull et, a partagez bun préfixe approprié si l’expression suivante est vraie :

{@code
                a.length != b.length &&
                Arrays.equals(a, 0, Math.min(a.length, b.length),
                              b, 0, Math.min(a.length, b.length))
            }

Ajouté dans 9.

Documentation Java pour java.util.Arrays.mismatch(.*short[], .*short[]).

Les parties de cette page sont des modifications basées sur le travail créé et partagé par le projet Android Open Source et utilisés en fonction des termes décrits dans la licence d’attribution Creative Commons 2.5.

[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

Paramètres

Retours

index de la première incompatibilité entre les deux tableaux ; sinon -1.

Attributs

RegisterAttribute

Remarques

Recherche et retourne l’index de la première incompatibilité entre deux double tableaux, sinon retourne -1 si aucune incompatibilité n’est trouvée. L’index se trouvera dans la plage de 0 (inclusive) jusqu’à la longueur (inclusive) du tableau plus petit.

Si les deux tableaux partagent un préfixe commun, l’index retourné est la longueur du préfixe commun et il suit qu’il existe une incompatibilité entre les deux éléments à cet index dans les tableaux respectifs. Si un tableau est un préfixe approprié de l’autre, l’index retourné est la longueur du tableau plus petit et il suit que l’index est valide uniquement pour le tableau plus grand. Sinon, il n’y a pas d’incompatibilité.

Deux tableaux etnull partagent abun préfixe commun de longueur pl si l’expression suivante a la valeur true :

{@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
            }

Notez qu’une longueur 0 de préfixe commune indique que les premiers éléments de chaque incompatibilité de tableau.

Deux tableaux non-tableauxnull et, a partagez bun préfixe approprié si l’expression suivante est vraie :

{@code
                a.length != b.length &&
                Arrays.equals(a, 0, Math.min(a.length, b.length),
                              b, 0, Math.min(a.length, b.length))
            }

Ajouté dans 9.

Documentation Java pour java.util.Arrays.mismatch(.*double[], .*double[]).

Les parties de cette page sont des modifications basées sur le travail créé et partagé par le projet Android Open Source et utilisés en fonction des termes décrits dans la licence d’attribution Creative Commons 2.5.

[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

Paramètres

Retours

index de la première incompatibilité entre les deux tableaux ; sinon -1.

Attributs

RegisterAttribute

Remarques

Recherche et retourne l’index de la première incompatibilité entre deux char tableaux, sinon retourne -1 si aucune incompatibilité n’est trouvée. L’index se trouvera dans la plage de 0 (inclusive) jusqu’à la longueur (inclusive) du tableau plus petit.

Si les deux tableaux partagent un préfixe commun, l’index retourné est la longueur du préfixe commun et il suit qu’il existe une incompatibilité entre les deux éléments à cet index dans les tableaux respectifs. Si un tableau est un préfixe approprié de l’autre, l’index retourné est la longueur du tableau plus petit et il suit que l’index est valide uniquement pour le tableau plus grand. Sinon, il n’y a pas d’incompatibilité.

Deux tableaux etnull partagent abun préfixe commun de longueur pl si l’expression suivante a la valeur true :

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

Notez qu’une longueur 0 de préfixe commune indique que les premiers éléments de chaque incompatibilité de tableau.

Deux tableaux non-tableauxnull et, a partagez bun préfixe approprié si l’expression suivante est vraie :

{@code
                a.length != b.length &&
                Arrays.equals(a, 0, Math.min(a.length, b.length),
                              b, 0, Math.min(a.length, b.length))
            }

Ajouté dans 9.

Documentation Java pour java.util.Arrays.mismatch(.*char[], .*char[]).

Les parties de cette page sont des modifications basées sur le travail créé et partagé par le projet Android Open Source et utilisés en fonction des termes décrits dans la licence d’attribution Creative Commons 2.5.

[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

Paramètres

Retours

index de la première incompatibilité entre les deux tableaux ; sinon -1.

Attributs

RegisterAttribute

Remarques

Recherche et retourne l’index de la première incompatibilité entre deux byte tableaux, sinon retourne -1 si aucune incompatibilité n’est trouvée. L’index se trouvera dans la plage de 0 (inclusive) jusqu’à la longueur (inclusive) du tableau plus petit.

Si les deux tableaux partagent un préfixe commun, l’index retourné est la longueur du préfixe commun et il suit qu’il existe une incompatibilité entre les deux éléments à cet index dans les tableaux respectifs. Si un tableau est un préfixe approprié de l’autre, l’index retourné est la longueur du tableau plus petit et il suit que l’index est valide uniquement pour le tableau plus grand. Sinon, il n’y a pas d’incompatibilité.

Deux tableaux etnull partagent abun préfixe commun de longueur pl si l’expression suivante a la valeur true :

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

Notez qu’une longueur 0 de préfixe commune indique que les premiers éléments de chaque incompatibilité de tableau.

Deux tableaux non-tableauxnull et, a partagez bun préfixe approprié si l’expression suivante est vraie :

{@code
                a.length != b.length &&
                Arrays.equals(a, 0, Math.min(a.length, b.length),
                              b, 0, Math.min(a.length, b.length))
            }

Ajouté dans 9.

Documentation Java pour java.util.Arrays.mismatch(.*byte[], .*byte[]).

Les parties de cette page sont des modifications basées sur le travail créé et partagé par le projet Android Open Source et utilisés en fonction des termes décrits dans la licence d’attribution Creative Commons 2.5.

[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

Paramètres

Retours

index de la première incompatibilité entre les deux tableaux ; sinon -1.

Attributs

RegisterAttribute

Remarques

Recherche et retourne l’index de la première incompatibilité entre deux boolean tableaux, sinon retourne -1 si aucune incompatibilité n’est trouvée. L’index se trouvera dans la plage de 0 (inclusive) jusqu’à la longueur (inclusive) du tableau plus petit.

Si les deux tableaux partagent un préfixe commun, l’index retourné est la longueur du préfixe commun et il suit qu’il existe une incompatibilité entre les deux éléments à cet index dans les tableaux respectifs. Si un tableau est un préfixe approprié de l’autre, l’index retourné est la longueur du tableau plus petit et il suit que l’index est valide uniquement pour le tableau plus grand. Sinon, il n’y a pas d’incompatibilité.

Deux tableaux etnull partagent abun préfixe commun de longueur pl si l’expression suivante a la valeur true :

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

Notez qu’une longueur 0 de préfixe commune indique que les premiers éléments de chaque incompatibilité de tableau.

Deux tableaux non-tableauxnull et, a partagez bun préfixe approprié si l’expression suivante est vraie :

{@code
                a.length != b.length &&
                Arrays.equals(a, 0, Math.min(a.length, b.length),
                              b, 0, Math.min(a.length, b.length))
            }

Ajouté dans 9.

Documentation Java pour java.util.Arrays.mismatch(.*boolean[], .*boolean[]).

Les parties de cette page sont des modifications basées sur le travail créé et partagé par le projet Android Open Source et utilisés en fonction des termes décrits dans la licence d’attribution Creative Commons 2.5.

[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

Paramètres

Retours

index de la première incompatibilité entre les deux tableaux ; sinon -1.

Attributs

RegisterAttribute

Remarques

Recherche et retourne l’index de la première incompatibilité entre deux Object tableaux, sinon retourne -1 si aucune incompatibilité n’est trouvée. L’index se trouvera dans la plage de 0 (inclusive) jusqu’à la longueur (inclusive) du tableau plus petit.

Si les deux tableaux partagent un préfixe commun, l’index retourné est la longueur du préfixe commun et il suit qu’il existe une incompatibilité entre les deux éléments à cet index dans les tableaux respectifs. Si un tableau est un préfixe approprié de l’autre, l’index retourné est la longueur du tableau plus petit et il suit que l’index est valide uniquement pour le tableau plus grand. Sinon, il n’y a pas d’incompatibilité.

Deux tableaux etnull partagent abun préfixe commun de longueur pl si l’expression suivante a la valeur true :

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

Notez qu’une longueur 0 de préfixe commune indique que les premiers éléments de chaque incompatibilité de tableau.

Deux tableaux non-tableauxnull et, a partagez bun préfixe approprié si l’expression suivante est vraie :

{@code
                a.length != b.length &&
                Arrays.equals(a, 0, Math.min(a.length, b.length),
                              b, 0, Math.min(a.length, b.length))
            }

Ajouté dans 9.

Documentation Java pour java.util.Arrays.mismatch(java.lang.Object[], java.lang.Object[]).

Les parties de cette page sont des modifications basées sur le travail créé et partagé par le projet Android Open Source et utilisés en fonction des termes décrits dans la licence d’attribution Creative Commons 2.5.

[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

Paramètres

Retours

index de la première incompatibilité entre les deux tableaux ; sinon -1.

Attributs

RegisterAttribute JavaTypeParametersAttribute

Remarques

Recherche et retourne l’index de la première incompatibilité entre deux Object tableaux, sinon retourne -1 si aucune incompatibilité n’est trouvée. L’index se trouvera dans la plage de 0 (inclusive) jusqu’à la longueur (inclusive) du tableau plus petit.

Le comparateur spécifié est utilisé pour déterminer si deux éléments de tableau de chaque tableau ne sont pas égaux.

Si les deux tableaux partagent un préfixe commun, l’index retourné est la longueur du préfixe commun et il suit qu’il existe une incompatibilité entre les deux éléments à cet index dans les tableaux respectifs. Si un tableau est un préfixe approprié de l’autre, l’index retourné est la longueur du tableau plus petit et il suit que l’index est valide uniquement pour le tableau plus grand. Sinon, il n’y a pas d’incompatibilité.

Deux tableaux etnull partagent abun préfixe commun de longueur pl si l’expression suivante a la valeur true :

{@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
            }

Notez qu’une longueur 0 de préfixe commune indique que les premiers éléments de chaque incompatibilité de tableau.

Deux tableaux non-tableauxnull et, a partagez bun préfixe approprié si l’expression suivante est vraie :

{@code
                a.length != b.length &&
                Arrays.equals(a, 0, Math.min(a.length, b.length),
                              b, 0, Math.min(a.length, b.length),
                              cmp)
            }

Ajouté dans 9.

Documentation Java pour java.util.Arrays.mismatch(T[], T[], java.util.Comparator<? super T>).

Les parties de cette page sont des modifications basées sur le travail créé et partagé par le projet Android Open Source et utilisés en fonction des termes décrits dans la licence d’attribution Creative Commons 2.5.