Arrays.Compare Méthode

[Android.Runtime.Register("compare", "([BII[BII)I", "", ApiSince=33)]
public static int Compare(byte[] a, int aFromIndex, int aToIndex, byte[] b, int bFromIndex, int bToIndex);

[<Android.Runtime.Register("compare", "([BII[BII)I", "", ApiSince=33)>]
static member Compare : byte[] * int * int * byte[] * int * int -> int

Paramètres

Retours

la valeur 0 si, sur les plages spécifiées, le premier et le deuxième tableau sont égaux et contiennent les mêmes éléments dans le même ordre ; une valeur inférieure 0 à si, sur les plages spécifiées, le premier tableau est lexicographiquement inférieur au deuxième tableau ; et une valeur supérieure à si, sur les plages spécifiées, le premier tableau est lexicographiquement supérieur au deuxième tableau ; et une valeur supérieure 0 à si, sur les plages spécifiées, le premier tableau est lexicographiquement supérieur au deuxième tableau.

Attributs

RegisterAttribute

Remarques

Compare deux byte tableaux lexicographiquement sur les plages spécifiées.

Si les deux tableaux, sur les plages spécifiées, partagent un préfixe commun, la comparaison lexicographique est le résultat de la comparaison de deux éléments, comme si, Byte#compare(byte, byte)à un index relatif dans les tableaux respectifs qui correspond à la longueur du préfixe. Sinon, un tableau est un préfixe approprié de l’autre et, la comparaison lexicographique est le résultat de la comparaison des deux longueurs de plage. (Consultez #mismatch(byte[], int, int, byte[], int, int) la définition d’un préfixe commun et approprié.)

La comparaison est cohérente avec #equals(byte[], int, int, byte[], int, int) equals, plus précisément les conservations suivantes pour les tableaux et b avec les plages spécifiées a [aFromIndex, aToIndex) et [bFromIndex, bToIndex) respectivement :

{@code
                Arrays.equals(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) ==
                    (Arrays.compare(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == 0)
            }

Ajouté dans 9.

Documentation Java pour java.util.Arrays.compare(.*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("compare", "([CII[CII)I", "", ApiSince=33)]
public static int Compare(char[] a, int aFromIndex, int aToIndex, char[] b, int bFromIndex, int bToIndex);

[<Android.Runtime.Register("compare", "([CII[CII)I", "", ApiSince=33)>]
static member Compare : char[] * int * int * char[] * int * int -> int

Paramètres

Retours

la valeur 0 si, sur les plages spécifiées, le premier et le deuxième tableau sont égaux et contiennent les mêmes éléments dans le même ordre ; une valeur inférieure 0 à si, sur les plages spécifiées, le premier tableau est lexicographiquement inférieur au deuxième tableau ; et une valeur supérieure à si, sur les plages spécifiées, le premier tableau est lexicographiquement supérieur au deuxième tableau ; et une valeur supérieure 0 à si, sur les plages spécifiées, le premier tableau est lexicographiquement supérieur au deuxième tableau.

Attributs

RegisterAttribute

Remarques

Compare deux char tableaux lexicographiquement sur les plages spécifiées.

Si les deux tableaux, sur les plages spécifiées, partagent un préfixe commun, la comparaison lexicographique est le résultat de la comparaison de deux éléments, comme si, Character#compare(char, char)à un index relatif dans les tableaux respectifs qui correspond à la longueur du préfixe. Sinon, un tableau est un préfixe approprié de l’autre et, la comparaison lexicographique est le résultat de la comparaison des deux longueurs de plage. (Consultez #mismatch(char[], int, int, char[], int, int) la définition d’un préfixe commun et approprié.)

La comparaison est cohérente avec #equals(char[], int, int, char[], int, int) equals, plus précisément les conservations suivantes pour les tableaux et b avec les plages spécifiées a [aFromIndex, aToIndex) et [bFromIndex, bToIndex) respectivement :

{@code
                Arrays.equals(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) ==
                    (Arrays.compare(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == 0)
            }

Ajouté dans 9.

Documentation Java pour java.util.Arrays.compare(.*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("compare", "([DII[DII)I", "", ApiSince=33)]
public static int Compare(double[] a, int aFromIndex, int aToIndex, double[] b, int bFromIndex, int bToIndex);

[<Android.Runtime.Register("compare", "([DII[DII)I", "", ApiSince=33)>]
static member Compare : double[] * int * int * double[] * int * int -> int

Paramètres

Retours

la valeur 0 si, sur les plages spécifiées, le premier et le deuxième tableau sont égaux et contiennent les mêmes éléments dans le même ordre ; une valeur inférieure 0 à si, sur les plages spécifiées, le premier tableau est lexicographiquement inférieur au deuxième tableau ; et une valeur supérieure à si, sur les plages spécifiées, le premier tableau est lexicographiquement supérieur au deuxième tableau ; et une valeur supérieure 0 à si, sur les plages spécifiées, le premier tableau est lexicographiquement supérieur au deuxième tableau.

Attributs

RegisterAttribute

Remarques

Compare deux double tableaux lexicographiquement sur les plages spécifiées.

Si les deux tableaux, sur les plages spécifiées, partagent un préfixe commun, la comparaison lexicographique est le résultat de la comparaison de deux éléments, comme si, Double#compare(double, double)à un index relatif dans les tableaux respectifs qui correspond à la longueur du préfixe. Sinon, un tableau est un préfixe approprié de l’autre et, la comparaison lexicographique est le résultat de la comparaison des deux longueurs de plage. (Consultez #mismatch(double[], int, int, double[], int, int) la définition d’un préfixe commun et approprié.)

La comparaison est cohérente avec #equals(double[], int, int, double[], int, int) equals, plus précisément les conservations suivantes pour les tableaux et b avec les plages spécifiées a [aFromIndex, aToIndex) et [bFromIndex, bToIndex) respectivement :

{@code
                Arrays.equals(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) ==
                    (Arrays.compare(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == 0)
            }

Ajouté dans 9.

Documentation Java pour java.util.Arrays.compare(.*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("compare", "([SII[SII)I", "", ApiSince=33)]
public static int Compare(short[] a, int aFromIndex, int aToIndex, short[] b, int bFromIndex, int bToIndex);

[<Android.Runtime.Register("compare", "([SII[SII)I", "", ApiSince=33)>]
static member Compare : int16[] * int * int * int16[] * int * int -> int

Paramètres

Retours

la valeur 0 si, sur les plages spécifiées, le premier et le deuxième tableau sont égaux et contiennent les mêmes éléments dans le même ordre ; une valeur inférieure 0 à si, sur les plages spécifiées, le premier tableau est lexicographiquement inférieur au deuxième tableau ; et une valeur supérieure à si, sur les plages spécifiées, le premier tableau est lexicographiquement supérieur au deuxième tableau ; et une valeur supérieure 0 à si, sur les plages spécifiées, le premier tableau est lexicographiquement supérieur au deuxième tableau.

Attributs

RegisterAttribute

Remarques

Compare deux short tableaux lexicographiquement sur les plages spécifiées.

Si les deux tableaux, sur les plages spécifiées, partagent un préfixe commun, la comparaison lexicographique est le résultat de la comparaison de deux éléments, comme si, Short#compare(short, short)à un index relatif dans les tableaux respectifs qui correspond à la longueur du préfixe. Sinon, un tableau est un préfixe approprié de l’autre et, la comparaison lexicographique est le résultat de la comparaison des deux longueurs de plage. (Consultez #mismatch(short[], int, int, short[], int, int) la définition d’un préfixe commun et approprié.)

La comparaison est cohérente avec #equals(short[], int, int, short[], int, int) equals, plus précisément les conservations suivantes pour les tableaux et b avec les plages spécifiées a [aFromIndex, aToIndex) et [bFromIndex, bToIndex) respectivement :

{@code
                Arrays.equals(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) ==
                    (Arrays.compare(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == 0)
            }

Ajouté dans 9.

Documentation Java pour java.util.Arrays.compare(.*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("compare", "([Ljava/lang/Object;II[Ljava/lang/Object;IILjava/util/Comparator;)I", "", ApiSince=33)]
[Java.Interop.JavaTypeParameters(new System.String[] { "T" })]
public static int Compare(Java.Lang.Object[] a, int aFromIndex, int aToIndex, Java.Lang.Object[] b, int bFromIndex, int bToIndex, Java.Util.IComparator cmp);

[<Android.Runtime.Register("compare", "([Ljava/lang/Object;II[Ljava/lang/Object;IILjava/util/Comparator;)I", "", ApiSince=33)>]
[<Java.Interop.JavaTypeParameters(new System.String[] { "T" })>]
static member Compare : Java.Lang.Object[] * int * int * Java.Lang.Object[] * int * int * Java.Util.IComparator -> int

Paramètres

Retours

la valeur 0 si, sur les plages spécifiées, le premier et le deuxième tableau sont égaux et contiennent les mêmes éléments dans le même ordre ; une valeur inférieure 0 à si, sur les plages spécifiées, le premier tableau est lexicographiquement inférieur au deuxième tableau ; et une valeur supérieure à si, sur les plages spécifiées, le premier tableau est lexicographiquement supérieur au deuxième tableau ; et une valeur supérieure 0 à si, sur les plages spécifiées, le premier tableau est lexicographiquement supérieur au deuxième tableau.

Attributs

RegisterAttribute JavaTypeParametersAttribute

Remarques

Compare deux Object tableaux lexicographiquement sur les plages spécifiées.

Si les deux tableaux, sur les plages spécifiées, partagent un préfixe commun, la comparaison lexicographique est le résultat de la comparaison avec le comparateur spécifié deux éléments à un index relatif dans les tableaux respectifs qui est la longueur du préfixe. Sinon, un tableau est un préfixe approprié de l’autre et, la comparaison lexicographique est le résultat de la comparaison des deux longueurs de plage. (Consultez #mismatch(Object[], int, int, Object[], int, int) la définition d’un préfixe commun et approprié.)

Ajouté dans 9.

Documentation Java pour java.util.Arrays.compare(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("compare", "([JII[JII)I", "", ApiSince=33)]
public static int Compare(long[] a, int aFromIndex, int aToIndex, long[] b, int bFromIndex, int bToIndex);

[<Android.Runtime.Register("compare", "([JII[JII)I", "", ApiSince=33)>]
static member Compare : int64[] * int * int * int64[] * int * int -> int

Paramètres

Retours

la valeur 0 si, sur les plages spécifiées, le premier et le deuxième tableau sont égaux et contiennent les mêmes éléments dans le même ordre ; une valeur inférieure 0 à si, sur les plages spécifiées, le premier tableau est lexicographiquement inférieur au deuxième tableau ; et une valeur supérieure à si, sur les plages spécifiées, le premier tableau est lexicographiquement supérieur au deuxième tableau ; et une valeur supérieure 0 à si, sur les plages spécifiées, le premier tableau est lexicographiquement supérieur au deuxième tableau.

Attributs

RegisterAttribute

Remarques

Compare deux long tableaux lexicographiquement sur les plages spécifiées.

Si les deux tableaux, sur les plages spécifiées, partagent un préfixe commun, la comparaison lexicographique est le résultat de la comparaison de deux éléments, comme si, Long#compare(long, long)à un index relatif dans les tableaux respectifs qui correspond à la longueur du préfixe. Sinon, un tableau est un préfixe approprié de l’autre et, la comparaison lexicographique est le résultat de la comparaison des deux longueurs de plage. (Consultez #mismatch(long[], int, int, long[], int, int) la définition d’un préfixe commun et approprié.)

La comparaison est cohérente avec #equals(long[], int, int, long[], int, int) equals, plus précisément les conservations suivantes pour les tableaux et b avec les plages spécifiées a [aFromIndex, aToIndex) et [bFromIndex, bToIndex) respectivement :

{@code
                Arrays.equals(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) ==
                    (Arrays.compare(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == 0)
            }

Ajouté dans 9.

Documentation Java pour java.util.Arrays.compare(.*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("compare", "([FII[FII)I", "", ApiSince=33)]
public static int Compare(float[] a, int aFromIndex, int aToIndex, float[] b, int bFromIndex, int bToIndex);

[<Android.Runtime.Register("compare", "([FII[FII)I", "", ApiSince=33)>]
static member Compare : single[] * int * int * single[] * int * int -> int

Paramètres

Retours

la valeur 0 si, sur les plages spécifiées, le premier et le deuxième tableau sont égaux et contiennent les mêmes éléments dans le même ordre ; une valeur inférieure 0 à si, sur les plages spécifiées, le premier tableau est lexicographiquement inférieur au deuxième tableau ; et une valeur supérieure à si, sur les plages spécifiées, le premier tableau est lexicographiquement supérieur au deuxième tableau ; et une valeur supérieure 0 à si, sur les plages spécifiées, le premier tableau est lexicographiquement supérieur au deuxième tableau.

Attributs

RegisterAttribute

Remarques

Compare deux float tableaux lexicographiquement sur les plages spécifiées.

Si les deux tableaux, sur les plages spécifiées, partagent un préfixe commun, la comparaison lexicographique est le résultat de la comparaison de deux éléments, comme si, Float#compare(float, float)à un index relatif dans les tableaux respectifs qui correspond à la longueur du préfixe. Sinon, un tableau est un préfixe approprié de l’autre et, la comparaison lexicographique est le résultat de la comparaison des deux longueurs de plage. (Consultez #mismatch(float[], int, int, float[], int, int) la définition d’un préfixe commun et approprié.)

La comparaison est cohérente avec #equals(float[], int, int, float[], int, int) equals, plus précisément les conservations suivantes pour les tableaux et b avec les plages spécifiées a [aFromIndex, aToIndex) et [bFromIndex, bToIndex) respectivement :

{@code
                Arrays.equals(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) ==
                    (Arrays.compare(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == 0)
            }

Ajouté dans 9.

Documentation Java pour java.util.Arrays.compare(.*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("compare", "([ZII[ZII)I", "", ApiSince=33)]
public static int Compare(bool[] a, int aFromIndex, int aToIndex, bool[] b, int bFromIndex, int bToIndex);

[<Android.Runtime.Register("compare", "([ZII[ZII)I", "", ApiSince=33)>]
static member Compare : bool[] * int * int * bool[] * int * int -> int

Paramètres

Retours

la valeur 0 si, sur les plages spécifiées, le premier et le deuxième tableau sont égaux et contiennent les mêmes éléments dans le même ordre ; une valeur inférieure 0 à si, sur les plages spécifiées, le premier tableau est lexicographiquement inférieur au deuxième tableau ; et une valeur supérieure à si, sur les plages spécifiées, le premier tableau est lexicographiquement supérieur au deuxième tableau ; et une valeur supérieure 0 à si, sur les plages spécifiées, le premier tableau est lexicographiquement supérieur au deuxième tableau.

Attributs

RegisterAttribute

Remarques

Compare deux boolean tableaux lexicographiquement sur les plages spécifiées.

Si les deux tableaux, sur les plages spécifiées, partagent un préfixe commun, la comparaison lexicographique est le résultat de la comparaison de deux éléments, comme si, Boolean#compare(boolean, boolean)à un index relatif dans les tableaux respectifs qui correspond à la longueur du préfixe. Sinon, un tableau est un préfixe approprié de l’autre et, la comparaison lexicographique est le résultat de la comparaison des deux longueurs de plage. (Consultez #mismatch(boolean[], int, int, boolean[], int, int) la définition d’un préfixe commun et approprié.)

La comparaison est cohérente avec #equals(boolean[], int, int, boolean[], int, int) equals, plus précisément les conservations suivantes pour les tableaux et b avec les plages spécifiées a [aFromIndex, aToIndex) et [bFromIndex, bToIndex) respectivement :

{@code
                Arrays.equals(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) ==
                    (Arrays.compare(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == 0)
            }

Ajouté dans 9.

Documentation Java pour java.util.Arrays.compare(.*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("compare", "([III[III)I", "", ApiSince=33)]
public static int Compare(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex);

[<Android.Runtime.Register("compare", "([III[III)I", "", ApiSince=33)>]
static member Compare : int[] * int * int * int[] * int * int -> int

Paramètres

Retours

la valeur 0 si, sur les plages spécifiées, le premier et le deuxième tableau sont égaux et contiennent les mêmes éléments dans le même ordre ; une valeur inférieure 0 à si, sur les plages spécifiées, le premier tableau est lexicographiquement inférieur au deuxième tableau ; et une valeur supérieure à si, sur les plages spécifiées, le premier tableau est lexicographiquement supérieur au deuxième tableau ; et une valeur supérieure 0 à si, sur les plages spécifiées, le premier tableau est lexicographiquement supérieur au deuxième tableau.

Attributs

RegisterAttribute

Remarques

Compare deux int tableaux lexicographiquement sur les plages spécifiées.

Si les deux tableaux, sur les plages spécifiées, partagent un préfixe commun, la comparaison lexicographique est le résultat de la comparaison de deux éléments, comme si, Integer#compare(int, int)à un index relatif dans les tableaux respectifs qui correspond à la longueur du préfixe. Sinon, un tableau est un préfixe approprié de l’autre et, la comparaison lexicographique est le résultat de la comparaison des deux longueurs de plage. (Consultez #mismatch(int[], int, int, int[], int, int) la définition d’un préfixe commun et approprié.)

La comparaison est cohérente avec #equals(int[], int, int, int[], int, int) equals, plus précisément les conservations suivantes pour les tableaux et b avec les plages spécifiées a [aFromIndex, aToIndex) et [bFromIndex, bToIndex) respectivement :

{@code
                Arrays.equals(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) ==
                    (Arrays.compare(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == 0)
            }

Ajouté dans 9.

Documentation Java pour java.util.Arrays.compare(.*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("compare", "([Ljava/lang/Comparable;II[Ljava/lang/Comparable;II)I", "", ApiSince=33)]
[Java.Interop.JavaTypeParameters(new System.String[] { "T extends java.lang.Comparable<? super T>" })]
public static int Compare(Java.Lang.Object[] a, int aFromIndex, int aToIndex, Java.Lang.Object[] b, int bFromIndex, int bToIndex);

[<Android.Runtime.Register("compare", "([Ljava/lang/Comparable;II[Ljava/lang/Comparable;II)I", "", ApiSince=33)>]
[<Java.Interop.JavaTypeParameters(new System.String[] { "T extends java.lang.Comparable<? super T>" })>]
static member Compare : Java.Lang.Object[] * int * int * Java.Lang.Object[] * int * int -> int

Paramètres

Retours

la valeur 0 si, sur les plages spécifiées, le premier et le deuxième tableau sont égaux et contiennent les mêmes éléments dans le même ordre ; une valeur inférieure 0 à si, sur les plages spécifiées, le premier tableau est lexicographiquement inférieur au deuxième tableau ; et une valeur supérieure à si, sur les plages spécifiées, le premier tableau est lexicographiquement supérieur au deuxième tableau ; et une valeur supérieure 0 à si, sur les plages spécifiées, le premier tableau est lexicographiquement supérieur au deuxième tableau.

Attributs

RegisterAttribute JavaTypeParametersAttribute

Remarques

Compare deux Object tableaux lexicographiquement sur les plages spécifiées.

Si les deux tableaux, sur les plages spécifiées, partagent un préfixe commun, la comparaison lexicographique est le résultat de la comparaison de deux éléments de type T à un index i relatif dans les tableaux respectifs qui est la longueur du préfixe, comme par :

{@code
                Comparator.nullsFirst(Comparator.<T>naturalOrder()).
                    compare(a[aFromIndex + i, b[bFromIndex + i])
            }

Sinon, un tableau est un préfixe approprié de l’autre et, la comparaison lexicographique est le résultat de la comparaison des deux longueurs de plage. (Consultez #mismatch(Object[], int, int, Object[], int, int) la définition d’un préfixe commun et approprié.)

La comparaison est cohérente avec #equals(Object[], int, int, Object[], int, int) equals, plus précisément les conservations suivantes pour les tableaux et b avec les plages spécifiées a [aFromIndex, atoIndex) et [bFromIndex, btoIndex) respectivement :

{@code
                Arrays.equals(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) ==
                    (Arrays.compare(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == 0)
            }

Ajouté dans 9.

Documentation Java pour java.util.Arrays.compare(T[], int, int, T[], 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("compare", "([I[I)I", "", ApiSince=33)]
public static int Compare(int[]? a, int[]? b);

[<Android.Runtime.Register("compare", "([I[I)I", "", ApiSince=33)>]
static member Compare : int[] * int[] -> int

Paramètres

Retours

la valeur 0 si le premier et le deuxième tableau sont égaux et contiennent les mêmes éléments dans le même ordre ; une valeur inférieure 0 à si le premier tableau est lexicographiquement inférieur au deuxième tableau ; et une valeur supérieure à 0 si le premier tableau est lexicographiquement supérieur au deuxième tableau

Attributs

RegisterAttribute

Remarques

Compare deux int tableaux lexicographiquement.

Si les deux tableaux partagent un préfixe commun, la comparaison lexicographique est le résultat de la comparaison de deux éléments, comme si, Integer#compare(int, int)à un index dans les tableaux respectifs qui correspond à la longueur du préfixe. Sinon, un tableau est un préfixe approprié de l’autre et, la comparaison lexicographique est le résultat de la comparaison des deux longueurs de tableau. (Consultez #mismatch(int[], int[]) la définition d’un préfixe commun et approprié.)

Une null référence de tableau est considérée comme lexicographiquement inférieure à une référence nonnull matricielle. Deux null références de tableau sont considérées comme égales.

La comparaison est cohérente avec #equals(int[], int[]) equals, plus précisément les conservations suivantes pour les a tableaux et b:

{@code
                Arrays.equals(a, b) == (Arrays.compare(a, b) == 0)
            }

Ajouté dans 9.

Documentation Java pour java.util.Arrays.compare(.*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("compare", "([F[F)I", "", ApiSince=33)]
public static int Compare(float[]? a, float[]? b);

[<Android.Runtime.Register("compare", "([F[F)I", "", ApiSince=33)>]
static member Compare : single[] * single[] -> int

Paramètres

Retours

la valeur 0 si le premier et le deuxième tableau sont égaux et contiennent les mêmes éléments dans le même ordre ; une valeur inférieure 0 à si le premier tableau est lexicographiquement inférieur au deuxième tableau ; et une valeur supérieure à 0 si le premier tableau est lexicographiquement supérieur au deuxième tableau

Attributs

RegisterAttribute

Remarques

Compare deux float tableaux lexicographiquement.

Si les deux tableaux partagent un préfixe commun, la comparaison lexicographique est le résultat de la comparaison de deux éléments, comme si, Float#compare(float, float)à un index dans les tableaux respectifs qui correspond à la longueur du préfixe. Sinon, un tableau est un préfixe approprié de l’autre et, la comparaison lexicographique est le résultat de la comparaison des deux longueurs de tableau. (Consultez #mismatch(float[], float[]) la définition d’un préfixe commun et approprié.)

Une null référence de tableau est considérée comme lexicographiquement inférieure à une référence nonnull matricielle. Deux null références de tableau sont considérées comme égales.

La comparaison est cohérente avec #equals(float[], float[]) equals, plus précisément les conservations suivantes pour les a tableaux et b:

{@code
                Arrays.equals(a, b) == (Arrays.compare(a, b) == 0)
            }

Ajouté dans 9.

Documentation Java pour java.util.Arrays.compare(.*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("compare", "([J[J)I", "", ApiSince=33)]
public static int Compare(long[]? a, long[]? b);

[<Android.Runtime.Register("compare", "([J[J)I", "", ApiSince=33)>]
static member Compare : int64[] * int64[] -> int

Paramètres

Retours

la valeur 0 si le premier et le deuxième tableau sont égaux et contiennent les mêmes éléments dans le même ordre ; une valeur inférieure 0 à si le premier tableau est lexicographiquement inférieur au deuxième tableau ; et une valeur supérieure à 0 si le premier tableau est lexicographiquement supérieur au deuxième tableau

Attributs

RegisterAttribute

Remarques

Compare deux long tableaux lexicographiquement.

Si les deux tableaux partagent un préfixe commun, la comparaison lexicographique est le résultat de la comparaison de deux éléments, comme si, Long#compare(long, long)à un index dans les tableaux respectifs qui correspond à la longueur du préfixe. Sinon, un tableau est un préfixe approprié de l’autre et, la comparaison lexicographique est le résultat de la comparaison des deux longueurs de tableau. (Consultez #mismatch(long[], long[]) la définition d’un préfixe commun et approprié.)

Une null référence de tableau est considérée comme lexicographiquement inférieure à une référence nonnull matricielle. Deux null références de tableau sont considérées comme égales.

La comparaison est cohérente avec #equals(long[], long[]) equals, plus précisément les conservations suivantes pour les a tableaux et b:

{@code
                Arrays.equals(a, b) == (Arrays.compare(a, b) == 0)
            }

Ajouté dans 9.

Documentation Java pour java.util.Arrays.compare(.*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("compare", "([S[S)I", "", ApiSince=33)]
public static int Compare(short[]? a, short[]? b);

[<Android.Runtime.Register("compare", "([S[S)I", "", ApiSince=33)>]
static member Compare : int16[] * int16[] -> int

Paramètres

Retours

la valeur 0 si le premier et le deuxième tableau sont égaux et contiennent les mêmes éléments dans le même ordre ; une valeur inférieure 0 à si le premier tableau est lexicographiquement inférieur au deuxième tableau ; et une valeur supérieure à 0 si le premier tableau est lexicographiquement supérieur au deuxième tableau

Attributs

RegisterAttribute

Remarques

Compare deux short tableaux lexicographiquement.

Si les deux tableaux partagent un préfixe commun, la comparaison lexicographique est le résultat de la comparaison de deux éléments, comme si, Short#compare(short, short)à un index dans les tableaux respectifs qui correspond à la longueur du préfixe. Sinon, un tableau est un préfixe approprié de l’autre et, la comparaison lexicographique est le résultat de la comparaison des deux longueurs de tableau. (Consultez #mismatch(short[], short[]) la définition d’un préfixe commun et approprié.)

Une null référence de tableau est considérée comme lexicographiquement inférieure à une référence nonnull matricielle. Deux null références de tableau sont considérées comme égales.

La comparaison est cohérente avec #equals(short[], short[]) equals, plus précisément les conservations suivantes pour les a tableaux et b:

{@code
                Arrays.equals(a, b) == (Arrays.compare(a, b) == 0)
            }

Ajouté dans 9.

Documentation Java pour java.util.Arrays.compare(.*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("compare", "([D[D)I", "", ApiSince=33)]
public static int Compare(double[]? a, double[]? b);

[<Android.Runtime.Register("compare", "([D[D)I", "", ApiSince=33)>]
static member Compare : double[] * double[] -> int

Paramètres

Retours

la valeur 0 si le premier et le deuxième tableau sont égaux et contiennent les mêmes éléments dans le même ordre ; une valeur inférieure 0 à si le premier tableau est lexicographiquement inférieur au deuxième tableau ; et une valeur supérieure à 0 si le premier tableau est lexicographiquement supérieur au deuxième tableau

Attributs

RegisterAttribute

Remarques

Compare deux double tableaux lexicographiquement.

Si les deux tableaux partagent un préfixe commun, la comparaison lexicographique est le résultat de la comparaison de deux éléments, comme si, Double#compare(double, double)à un index dans les tableaux respectifs qui correspond à la longueur du préfixe. Sinon, un tableau est un préfixe approprié de l’autre et, la comparaison lexicographique est le résultat de la comparaison des deux longueurs de tableau. (Consultez #mismatch(double[], double[]) la définition d’un préfixe commun et approprié.)

Une null référence de tableau est considérée comme lexicographiquement inférieure à une référence nonnull matricielle. Deux null références de tableau sont considérées comme égales.

La comparaison est cohérente avec #equals(double[], double[]) equals, plus précisément les conservations suivantes pour les a tableaux et b:

{@code
                Arrays.equals(a, b) == (Arrays.compare(a, b) == 0)
            }

Ajouté dans 9.

Documentation Java pour java.util.Arrays.compare(.*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("compare", "([C[C)I", "", ApiSince=33)]
public static int Compare(char[]? a, char[]? b);

[<Android.Runtime.Register("compare", "([C[C)I", "", ApiSince=33)>]
static member Compare : char[] * char[] -> int

Paramètres

Retours

la valeur 0 si le premier et le deuxième tableau sont égaux et contiennent les mêmes éléments dans le même ordre ; une valeur inférieure 0 à si le premier tableau est lexicographiquement inférieur au deuxième tableau ; et une valeur supérieure à 0 si le premier tableau est lexicographiquement supérieur au deuxième tableau

Attributs

RegisterAttribute

Remarques

Compare deux char tableaux lexicographiquement.

Si les deux tableaux partagent un préfixe commun, la comparaison lexicographique est le résultat de la comparaison de deux éléments, comme si, Character#compare(char, char)à un index dans les tableaux respectifs qui correspond à la longueur du préfixe. Sinon, un tableau est un préfixe approprié de l’autre et, la comparaison lexicographique est le résultat de la comparaison des deux longueurs de tableau. (Consultez #mismatch(char[], char[]) la définition d’un préfixe commun et approprié.)

Une null référence de tableau est considérée comme lexicographiquement inférieure à une référence nonnull matricielle. Deux null références de tableau sont considérées comme égales.

La comparaison est cohérente avec #equals(char[], char[]) equals, plus précisément les conservations suivantes pour les a tableaux et b:

{@code
                Arrays.equals(a, b) == (Arrays.compare(a, b) == 0)
            }

Ajouté dans 9.

Documentation Java pour java.util.Arrays.compare(.*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("compare", "([B[B)I", "", ApiSince=33)]
public static int Compare(byte[]? a, byte[]? b);

[<Android.Runtime.Register("compare", "([B[B)I", "", ApiSince=33)>]
static member Compare : byte[] * byte[] -> int

Paramètres

Retours

la valeur 0 si le premier et le deuxième tableau sont égaux et contiennent les mêmes éléments dans le même ordre ; une valeur inférieure 0 à si le premier tableau est lexicographiquement inférieur au deuxième tableau ; et une valeur supérieure à 0 si le premier tableau est lexicographiquement supérieur au deuxième tableau

Attributs

RegisterAttribute

Remarques

Compare deux byte tableaux lexicographiquement.

Si les deux tableaux partagent un préfixe commun, la comparaison lexicographique est le résultat de la comparaison de deux éléments, comme si, Byte#compare(byte, byte)à un index dans les tableaux respectifs qui correspond à la longueur du préfixe. Sinon, un tableau est un préfixe approprié de l’autre et, la comparaison lexicographique est le résultat de la comparaison des deux longueurs de tableau. (Consultez #mismatch(byte[], byte[]) la définition d’un préfixe commun et approprié.)

Une null référence de tableau est considérée comme lexicographiquement inférieure à une référence nonnull matricielle. Deux null références de tableau sont considérées comme égales.

La comparaison est cohérente avec #equals(byte[], byte[]) equals, plus précisément les conservations suivantes pour les a tableaux et b:

{@code
                Arrays.equals(a, b) == (Arrays.compare(a, b) == 0)
            }

Ajouté dans 9.

Documentation Java pour java.util.Arrays.compare(.*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("compare", "([Z[Z)I", "", ApiSince=33)]
public static int Compare(bool[]? a, bool[]? b);

[<Android.Runtime.Register("compare", "([Z[Z)I", "", ApiSince=33)>]
static member Compare : bool[] * bool[] -> int

Paramètres

Retours

la valeur 0 si le premier et le deuxième tableau sont égaux et contiennent les mêmes éléments dans le même ordre ; une valeur inférieure 0 à si le premier tableau est lexicographiquement inférieur au deuxième tableau ; et une valeur supérieure à 0 si le premier tableau est lexicographiquement supérieur au deuxième tableau

Attributs

RegisterAttribute

Remarques

Compare deux boolean tableaux lexicographiquement.

Si les deux tableaux partagent un préfixe commun, la comparaison lexicographique est le résultat de la comparaison de deux éléments, comme si, Boolean#compare(boolean, boolean)à un index dans les tableaux respectifs qui correspond à la longueur du préfixe. Sinon, un tableau est un préfixe approprié de l’autre et, la comparaison lexicographique est le résultat de la comparaison des deux longueurs de tableau. (Consultez #mismatch(boolean[], boolean[]) la définition d’un préfixe commun et approprié.)

Une null référence de tableau est considérée comme lexicographiquement inférieure à une référence nonnull matricielle. Deux null références de tableau sont considérées comme égales.

La comparaison est cohérente avec #equals(boolean[], boolean[]) equals, plus précisément les conservations suivantes pour les a tableaux et b:

{@code
                Arrays.equals(a, b) == (Arrays.compare(a, b) == 0)
            }

Ajouté dans 9.

Documentation Java pour java.util.Arrays.compare(.*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("compare", "([Ljava/lang/Comparable;[Ljava/lang/Comparable;)I", "", ApiSince=33)]
[Java.Interop.JavaTypeParameters(new System.String[] { "T extends java.lang.Comparable<? super T>" })]
public static int Compare(Java.Lang.Object[]? a, Java.Lang.Object[]? b);

[<Android.Runtime.Register("compare", "([Ljava/lang/Comparable;[Ljava/lang/Comparable;)I", "", ApiSince=33)>]
[<Java.Interop.JavaTypeParameters(new System.String[] { "T extends java.lang.Comparable<? super T>" })>]
static member Compare : Java.Lang.Object[] * Java.Lang.Object[] -> int

Paramètres

Retours

la valeur 0 si le premier et le deuxième tableau sont égaux et contiennent les mêmes éléments dans le même ordre ; une valeur inférieure 0 à si le premier tableau est lexicographiquement inférieur au deuxième tableau ; et une valeur supérieure à 0 si le premier tableau est lexicographiquement supérieur au deuxième tableau

Attributs

RegisterAttribute JavaTypeParametersAttribute

Remarques

Compare deux Object tableaux, au sein d’éléments comparables, lexicographiquement.

Si les deux tableaux partagent un préfixe commun, la comparaison lexicographique est le résultat de la comparaison de deux éléments de type T à un index i dans les tableaux respectifs qui est la longueur du préfixe, comme par :

{@code
                Comparator.nullsFirst(Comparator.<T>naturalOrder()).
                    compare(a[i], b[i])
            }

Sinon, un tableau est un préfixe approprié de l’autre et, la comparaison lexicographique est le résultat de la comparaison des deux longueurs de tableau. (Consultez #mismatch(Object[], Object[]) la définition d’un préfixe commun et approprié.)

Une null référence de tableau est considérée comme lexicographiquement inférieure à une référence nonnull matricielle. Deux null références de tableau sont considérées comme égales. Un null élément de tableau est considéré comme lexicographiquement inférieur à un élément nonnull matriciel. Deux null éléments de tableau sont considérés comme égaux.

La comparaison est cohérente avec #equals(Object[], Object[]) equals, plus précisément les conservations suivantes pour les a tableaux et b:

{@code
                Arrays.equals(a, b) == (Arrays.compare(a, b) == 0)
            }

Ajouté dans 9.

Documentation Java pour java.util.Arrays.compare(T[], 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("compare", "([Ljava/lang/Object;[Ljava/lang/Object;Ljava/util/Comparator;)I", "", ApiSince=33)]
[Java.Interop.JavaTypeParameters(new System.String[] { "T" })]
public static int Compare(Java.Lang.Object[]? a, Java.Lang.Object[]? b, Java.Util.IComparator cmp);

[<Android.Runtime.Register("compare", "([Ljava/lang/Object;[Ljava/lang/Object;Ljava/util/Comparator;)I", "", ApiSince=33)>]
[<Java.Interop.JavaTypeParameters(new System.String[] { "T" })>]
static member Compare : Java.Lang.Object[] * Java.Lang.Object[] * Java.Util.IComparator -> int

Paramètres

Retours

la valeur 0 si le premier et le deuxième tableau sont égaux et contiennent les mêmes éléments dans le même ordre ; une valeur inférieure 0 à si le premier tableau est lexicographiquement inférieur au deuxième tableau ; et une valeur supérieure à 0 si le premier tableau est lexicographiquement supérieur au deuxième tableau

Attributs

RegisterAttribute JavaTypeParametersAttribute

Remarques

Compare deux Object tableaux lexicographiquement à l’aide d’un comparateur spécifié.

Si les deux tableaux partagent un préfixe commun, la comparaison lexicographique est le résultat de la comparaison avec le comparateur spécifié deux éléments à un index dans les tableaux respectifs qui est la longueur du préfixe. Sinon, un tableau est un préfixe approprié de l’autre et, la comparaison lexicographique est le résultat de la comparaison des deux longueurs de tableau. (Consultez #mismatch(Object[], Object[]) la définition d’un préfixe commun et approprié.)

Une null référence de tableau est considérée comme lexicographiquement inférieure à une référence nonnull matricielle. Deux null références de tableau sont considérées comme égales.

Ajouté dans 9.

Documentation Java pour java.util.Arrays.compare(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.