Arrays.Compare Metodo

[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

Parametri

Valori restituiti

il valore 0 se, negli intervalli specificati, la prima e la seconda matrice sono uguali e contengono gli stessi elementi nello stesso ordine; un valore minore di 0 se, negli intervalli specificati, la prima matrice è lessicograficamente minore della seconda matrice e un valore maggiore di 0 se, negli intervalli specificati, la prima matrice è lessicograficamente maggiore della seconda matrice.

Attributi

RegisterAttribute

Commenti

Confronta due byte matrici in modo lessicografico rispetto agli intervalli specificati.

Se le due matrici, sugli intervalli specificati, condividono un prefisso comune, il confronto lessicografico è il risultato del confronto di due elementi, come se fosse Byte#compare(byte, byte), in corrispondenza di un indice relativo all'interno delle rispettive matrici che corrisponde alla lunghezza del prefisso. In caso contrario, una matrice è un prefisso appropriato dell'altro e, il confronto lessicografico è il risultato del confronto delle due lunghezze di intervallo. Vedere #mismatch(byte[], int, int, byte[], int, int) per la definizione di un prefisso comune e appropriato.

Il confronto è coerente con #equals(byte[], int, int, byte[], int, int) equals, più specificamente i blocchi seguenti per le a matrici e b con gli intervalli specificati [aFromIndex, aToIndex) e [bFromIndex, bToIndex) rispettivamente:

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

Aggiunta in 9.

per java.util.Arrays.compare(.*byte[], .*int, .*int, .*byte[], .*int, .*int).

Le parti di questa pagina sono modifiche basate sul lavoro creato e condiviso dalla e usati in base ai termini descritti in Creative License 2.5 Attribution License.

[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

Parametri

Valori restituiti

il valore 0 se, negli intervalli specificati, la prima e la seconda matrice sono uguali e contengono gli stessi elementi nello stesso ordine; un valore minore di 0 se, negli intervalli specificati, la prima matrice è lessicograficamente minore della seconda matrice e un valore maggiore di 0 se, negli intervalli specificati, la prima matrice è lessicograficamente maggiore della seconda matrice.

Attributi

RegisterAttribute

Commenti

Confronta due char matrici in modo lessicografico rispetto agli intervalli specificati.

Se le due matrici, sugli intervalli specificati, condividono un prefisso comune, il confronto lessicografico è il risultato del confronto di due elementi, come se fosse Character#compare(char, char), in corrispondenza di un indice relativo all'interno delle rispettive matrici che corrisponde alla lunghezza del prefisso. In caso contrario, una matrice è un prefisso appropriato dell'altro e, il confronto lessicografico è il risultato del confronto delle due lunghezze di intervallo. Vedere #mismatch(char[], int, int, char[], int, int) per la definizione di un prefisso comune e appropriato.

Il confronto è coerente con #equals(char[], int, int, char[], int, int) equals, più specificamente i blocchi seguenti per le a matrici e b con gli intervalli specificati [aFromIndex, aToIndex) e [bFromIndex, bToIndex) rispettivamente:

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

Aggiunta in 9.

per java.util.Arrays.compare(.*char[], .*int, .*int, .*char[], .*int, .*int).

Le parti di questa pagina sono modifiche basate sul lavoro creato e condiviso dalla e usati in base ai termini descritti in Creative License 2.5 Attribution License.

[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

Parametri

Valori restituiti

il valore 0 se, negli intervalli specificati, la prima e la seconda matrice sono uguali e contengono gli stessi elementi nello stesso ordine; un valore minore di 0 se, negli intervalli specificati, la prima matrice è lessicograficamente minore della seconda matrice e un valore maggiore di 0 se, negli intervalli specificati, la prima matrice è lessicograficamente maggiore della seconda matrice.

Attributi

RegisterAttribute

Commenti

Confronta due double matrici in modo lessicografico rispetto agli intervalli specificati.

Se le due matrici, sugli intervalli specificati, condividono un prefisso comune, il confronto lessicografico è il risultato del confronto di due elementi, come se fosse Double#compare(double, double), in corrispondenza di un indice relativo all'interno delle rispettive matrici che corrisponde alla lunghezza del prefisso. In caso contrario, una matrice è un prefisso appropriato dell'altro e, il confronto lessicografico è il risultato del confronto delle due lunghezze di intervallo. Vedere #mismatch(double[], int, int, double[], int, int) per la definizione di un prefisso comune e appropriato.

Il confronto è coerente con #equals(double[], int, int, double[], int, int) equals, più specificamente i blocchi seguenti per le a matrici e b con gli intervalli specificati [aFromIndex, aToIndex) e [bFromIndex, bToIndex) rispettivamente:

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

Aggiunta in 9.

per java.util.Arrays.compare(.*double[], .*int, .*int, .*double[], .*int, .*int).

Le parti di questa pagina sono modifiche basate sul lavoro creato e condiviso dalla e usati in base ai termini descritti in Creative License 2.5 Attribution License.

[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

Parametri

Valori restituiti

il valore 0 se, negli intervalli specificati, la prima e la seconda matrice sono uguali e contengono gli stessi elementi nello stesso ordine; un valore minore di 0 se, negli intervalli specificati, la prima matrice è lessicograficamente minore della seconda matrice e un valore maggiore di 0 se, negli intervalli specificati, la prima matrice è lessicograficamente maggiore della seconda matrice.

Attributi

RegisterAttribute

Commenti

Confronta due short matrici in modo lessicografico rispetto agli intervalli specificati.

Se le due matrici, sugli intervalli specificati, condividono un prefisso comune, il confronto lessicografico è il risultato del confronto di due elementi, come se fosse Short#compare(short, short), in corrispondenza di un indice relativo all'interno delle rispettive matrici che corrisponde alla lunghezza del prefisso. In caso contrario, una matrice è un prefisso appropriato dell'altro e, il confronto lessicografico è il risultato del confronto delle due lunghezze di intervallo. Vedere #mismatch(short[], int, int, short[], int, int) per la definizione di un prefisso comune e appropriato.

Il confronto è coerente con #equals(short[], int, int, short[], int, int) equals, più specificamente i blocchi seguenti per le a matrici e b con gli intervalli specificati [aFromIndex, aToIndex) e [bFromIndex, bToIndex) rispettivamente:

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

Aggiunta in 9.

per java.util.Arrays.compare(.*short[], .*int, .*int, .*short[], .*int, .*int).

Le parti di questa pagina sono modifiche basate sul lavoro creato e condiviso dalla e usati in base ai termini descritti in Creative License 2.5 Attribution License.

[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

Parametri

Valori restituiti

il valore 0 se, negli intervalli specificati, la prima e la seconda matrice sono uguali e contengono gli stessi elementi nello stesso ordine; un valore minore di 0 se, negli intervalli specificati, la prima matrice è lessicograficamente minore della seconda matrice e un valore maggiore di 0 se, negli intervalli specificati, la prima matrice è lessicograficamente maggiore della seconda matrice.

Attributi

RegisterAttribute JavaTypeParametersAttribute

Commenti

Confronta due Object matrici in modo lessicografico rispetto agli intervalli specificati.

Se le due matrici, oltre gli intervalli specificati, condividono un prefisso comune, il confronto lessicografico è il risultato del confronto con il confronto specificato di due elementi in corrispondenza di un indice relativo all'interno delle rispettive matrici che corrisponde alla lunghezza del prefisso. In caso contrario, una matrice è un prefisso appropriato dell'altro e, il confronto lessicografico è il risultato del confronto delle due lunghezze di intervallo. Vedere #mismatch(Object[], int, int, Object[], int, int) per la definizione di un prefisso comune e appropriato.

Aggiunta in 9.

per java.util.Arrays.compare(T[], int, int, T[], int, int, java.util.Comparator<? super T>).

Le parti di questa pagina sono modifiche basate sul lavoro creato e condiviso dalla e usati in base ai termini descritti in Creative License 2.5 Attribution License.

[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

Parametri

Valori restituiti

il valore 0 se, negli intervalli specificati, la prima e la seconda matrice sono uguali e contengono gli stessi elementi nello stesso ordine; un valore minore di 0 se, negli intervalli specificati, la prima matrice è lessicograficamente minore della seconda matrice e un valore maggiore di 0 se, negli intervalli specificati, la prima matrice è lessicograficamente maggiore della seconda matrice.

Attributi

RegisterAttribute

Commenti

Confronta due long matrici in modo lessicografico rispetto agli intervalli specificati.

Se le due matrici, sugli intervalli specificati, condividono un prefisso comune, il confronto lessicografico è il risultato del confronto di due elementi, come se fosse Long#compare(long, long), in corrispondenza di un indice relativo all'interno delle rispettive matrici che corrisponde alla lunghezza del prefisso. In caso contrario, una matrice è un prefisso appropriato dell'altro e, il confronto lessicografico è il risultato del confronto delle due lunghezze di intervallo. Vedere #mismatch(long[], int, int, long[], int, int) per la definizione di un prefisso comune e appropriato.

Il confronto è coerente con #equals(long[], int, int, long[], int, int) equals, più specificamente i blocchi seguenti per le a matrici e b con gli intervalli specificati [aFromIndex, aToIndex) e [bFromIndex, bToIndex) rispettivamente:

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

Aggiunta in 9.

per java.util.Arrays.compare(.*long[], .*int, .*int, .*long[], .*int, .*int).

Le parti di questa pagina sono modifiche basate sul lavoro creato e condiviso dalla e usati in base ai termini descritti in Creative License 2.5 Attribution License.

[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

Parametri

Valori restituiti

il valore 0 se, negli intervalli specificati, la prima e la seconda matrice sono uguali e contengono gli stessi elementi nello stesso ordine; un valore minore di 0 se, negli intervalli specificati, la prima matrice è lessicograficamente minore della seconda matrice e un valore maggiore di 0 se, negli intervalli specificati, la prima matrice è lessicograficamente maggiore della seconda matrice.

Attributi

RegisterAttribute

Commenti

Confronta due float matrici in modo lessicografico rispetto agli intervalli specificati.

Se le due matrici, sugli intervalli specificati, condividono un prefisso comune, il confronto lessicografico è il risultato del confronto di due elementi, come se fosse Float#compare(float, float), in corrispondenza di un indice relativo all'interno delle rispettive matrici che corrisponde alla lunghezza del prefisso. In caso contrario, una matrice è un prefisso appropriato dell'altro e, il confronto lessicografico è il risultato del confronto delle due lunghezze di intervallo. Vedere #mismatch(float[], int, int, float[], int, int) per la definizione di un prefisso comune e appropriato.

Il confronto è coerente con #equals(float[], int, int, float[], int, int) equals, più specificamente i blocchi seguenti per le a matrici e b con gli intervalli specificati [aFromIndex, aToIndex) e [bFromIndex, bToIndex) rispettivamente:

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

Aggiunta in 9.

per java.util.Arrays.compare(.*float[], .*int, .*int, .*float[], .*int, .*int).

Le parti di questa pagina sono modifiche basate sul lavoro creato e condiviso dalla e usati in base ai termini descritti in Creative License 2.5 Attribution License.

[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

Parametri

Valori restituiti

il valore 0 se, negli intervalli specificati, la prima e la seconda matrice sono uguali e contengono gli stessi elementi nello stesso ordine; un valore minore di 0 se, negli intervalli specificati, la prima matrice è lessicograficamente minore della seconda matrice e un valore maggiore di 0 se, negli intervalli specificati, la prima matrice è lessicograficamente maggiore della seconda matrice.

Attributi

RegisterAttribute

Commenti

Confronta due boolean matrici in modo lessicografico rispetto agli intervalli specificati.

Se le due matrici, sugli intervalli specificati, condividono un prefisso comune, il confronto lessicografico è il risultato del confronto di due elementi, come se fosse Boolean#compare(boolean, boolean), in corrispondenza di un indice relativo all'interno delle rispettive matrici che corrisponde alla lunghezza del prefisso. In caso contrario, una matrice è un prefisso appropriato dell'altro e, il confronto lessicografico è il risultato del confronto delle due lunghezze di intervallo. Vedere #mismatch(boolean[], int, int, boolean[], int, int) per la definizione di un prefisso comune e appropriato.

Il confronto è coerente con #equals(boolean[], int, int, boolean[], int, int) equals, più specificamente i blocchi seguenti per le a matrici e b con gli intervalli specificati [aFromIndex, aToIndex) e [bFromIndex, bToIndex) rispettivamente:

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

Aggiunta in 9.

per java.util.Arrays.compare(.*boolean[], .*int, .*int, .*boolean[], .*int, .*int).

Le parti di questa pagina sono modifiche basate sul lavoro creato e condiviso dalla e usati in base ai termini descritti in Creative License 2.5 Attribution License.

[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

Parametri

Valori restituiti

il valore 0 se, negli intervalli specificati, la prima e la seconda matrice sono uguali e contengono gli stessi elementi nello stesso ordine; un valore minore di 0 se, negli intervalli specificati, la prima matrice è lessicograficamente minore della seconda matrice e un valore maggiore di 0 se, negli intervalli specificati, la prima matrice è lessicograficamente maggiore della seconda matrice.

Attributi

RegisterAttribute

Commenti

Confronta due int matrici in modo lessicografico rispetto agli intervalli specificati.

Se le due matrici, sugli intervalli specificati, condividono un prefisso comune, il confronto lessicografico è il risultato del confronto di due elementi, come se fosse Integer#compare(int, int), in corrispondenza di un indice relativo all'interno delle rispettive matrici che corrisponde alla lunghezza del prefisso. In caso contrario, una matrice è un prefisso appropriato dell'altro e, il confronto lessicografico è il risultato del confronto delle due lunghezze di intervallo. Vedere #mismatch(int[], int, int, int[], int, int) per la definizione di un prefisso comune e appropriato.

Il confronto è coerente con #equals(int[], int, int, int[], int, int) equals, più specificamente i blocchi seguenti per le a matrici e b con gli intervalli specificati [aFromIndex, aToIndex) e [bFromIndex, bToIndex) rispettivamente:

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

Aggiunta in 9.

per java.util.Arrays.compare(.*int[], .*int, .*int, .*int[], .*int, .*int).

Le parti di questa pagina sono modifiche basate sul lavoro creato e condiviso dalla e usati in base ai termini descritti in Creative License 2.5 Attribution License.

[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

Parametri

Valori restituiti

il valore 0 se, negli intervalli specificati, la prima e la seconda matrice sono uguali e contengono gli stessi elementi nello stesso ordine; un valore minore di 0 se, negli intervalli specificati, la prima matrice è lessicograficamente minore della seconda matrice e un valore maggiore di 0 se, negli intervalli specificati, la prima matrice è lessicograficamente maggiore della seconda matrice.

Attributi

RegisterAttribute JavaTypeParametersAttribute

Commenti

Confronta due Object matrici in modo lessicografico rispetto agli intervalli specificati.

Se le due matrici, oltre gli intervalli specificati, condividono un prefisso comune, il confronto lessicografico è il risultato del confronto di due elementi di tipo T in corrispondenza di un indice i relativo all'interno delle rispettive matrici che rappresenta la lunghezza del prefisso, come se:

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

In caso contrario, una matrice è un prefisso appropriato dell'altro e, il confronto lessicografico è il risultato del confronto delle due lunghezze di intervallo. Vedere #mismatch(Object[], int, int, Object[], int, int) per la definizione di un prefisso comune e appropriato.

Il confronto è coerente con #equals(Object[], int, int, Object[], int, int) equals, più specificamente i blocchi seguenti per le a matrici e b con gli intervalli specificati [aFromIndex, atoIndex) e [bFromIndex, btoIndex) rispettivamente:

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

Aggiunta in 9.

per java.util.Arrays.compare(T[], int, int, T[], int, int).

Le parti di questa pagina sono modifiche basate sul lavoro creato e condiviso dalla e usati in base ai termini descritti in Creative License 2.5 Attribution License.

[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

Parametri

Valori restituiti

valore 0 se la prima e la seconda matrice sono uguali e contengono gli stessi elementi nello stesso ordine; un valore minore di 0 se la prima matrice è lessicograficamente minore della seconda matrice e un valore maggiore di 0 se la prima matrice è lessicograficamente maggiore della seconda matrice

Attributi

RegisterAttribute

Commenti

Confronta due int matrici lessicograficamente.

Se le due matrici condividono un prefisso comune, il confronto lessicografico è il risultato del confronto di due elementi, come se fosse Integer#compare(int, int), in corrispondenza di un indice all'interno delle rispettive matrici che corrisponde alla lunghezza del prefisso. In caso contrario, una matrice è un prefisso appropriato dell'altro e, il confronto lessicografico è il risultato del confronto tra le due lunghezze della matrice. Vedere #mismatch(int[], int[]) per la definizione di un prefisso comune e appropriato.

Un null riferimento a matrice viene considerato lessicograficamente minore di unnull riferimento non di matrice. Due null riferimenti di matrice sono considerati uguali.

Il confronto è coerente con #equals(int[], int[]) equals, in particolare i blocchi seguenti per le a matrici e b:

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

Aggiunta in 9.

per java.util.Arrays.compare(.*int[], .*int[]).

Le parti di questa pagina sono modifiche basate sul lavoro creato e condiviso dalla e usati in base ai termini descritti in Creative License 2.5 Attribution License.

[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

Parametri

Valori restituiti

valore 0 se la prima e la seconda matrice sono uguali e contengono gli stessi elementi nello stesso ordine; un valore minore di 0 se la prima matrice è lessicograficamente minore della seconda matrice e un valore maggiore di 0 se la prima matrice è lessicograficamente maggiore della seconda matrice

Attributi

RegisterAttribute

Commenti

Confronta due float matrici lessicograficamente.

Se le due matrici condividono un prefisso comune, il confronto lessicografico è il risultato del confronto di due elementi, come se fosse Float#compare(float, float), in corrispondenza di un indice all'interno delle rispettive matrici che corrisponde alla lunghezza del prefisso. In caso contrario, una matrice è un prefisso appropriato dell'altro e, il confronto lessicografico è il risultato del confronto tra le due lunghezze della matrice. Vedere #mismatch(float[], float[]) per la definizione di un prefisso comune e appropriato.

Un null riferimento a matrice viene considerato lessicograficamente minore di unnull riferimento non di matrice. Due null riferimenti di matrice sono considerati uguali.

Il confronto è coerente con #equals(float[], float[]) equals, in particolare i blocchi seguenti per le a matrici e b:

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

Aggiunta in 9.

per java.util.Arrays.compare(.*float[], .*float[]).

Le parti di questa pagina sono modifiche basate sul lavoro creato e condiviso dalla e usati in base ai termini descritti in Creative License 2.5 Attribution License.

[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

Parametri

Valori restituiti

valore 0 se la prima e la seconda matrice sono uguali e contengono gli stessi elementi nello stesso ordine; un valore minore di 0 se la prima matrice è lessicograficamente minore della seconda matrice e un valore maggiore di 0 se la prima matrice è lessicograficamente maggiore della seconda matrice

Attributi

RegisterAttribute

Commenti

Confronta due long matrici lessicograficamente.

Se le due matrici condividono un prefisso comune, il confronto lessicografico è il risultato del confronto di due elementi, come se fosse Long#compare(long, long), in corrispondenza di un indice all'interno delle rispettive matrici che corrisponde alla lunghezza del prefisso. In caso contrario, una matrice è un prefisso appropriato dell'altro e, il confronto lessicografico è il risultato del confronto tra le due lunghezze della matrice. Vedere #mismatch(long[], long[]) per la definizione di un prefisso comune e appropriato.

Un null riferimento a matrice viene considerato lessicograficamente minore di unnull riferimento non di matrice. Due null riferimenti di matrice sono considerati uguali.

Il confronto è coerente con #equals(long[], long[]) equals, in particolare i blocchi seguenti per le a matrici e b:

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

Aggiunta in 9.

per java.util.Arrays.compare(.*long[], .*long[]).

Le parti di questa pagina sono modifiche basate sul lavoro creato e condiviso dalla e usati in base ai termini descritti in Creative License 2.5 Attribution License.

[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

Parametri

Valori restituiti

valore 0 se la prima e la seconda matrice sono uguali e contengono gli stessi elementi nello stesso ordine; un valore minore di 0 se la prima matrice è lessicograficamente minore della seconda matrice e un valore maggiore di 0 se la prima matrice è lessicograficamente maggiore della seconda matrice

Attributi

RegisterAttribute

Commenti

Confronta due short matrici lessicograficamente.

Se le due matrici condividono un prefisso comune, il confronto lessicografico è il risultato del confronto di due elementi, come se fosse Short#compare(short, short), in corrispondenza di un indice all'interno delle rispettive matrici che corrisponde alla lunghezza del prefisso. In caso contrario, una matrice è un prefisso appropriato dell'altro e, il confronto lessicografico è il risultato del confronto tra le due lunghezze della matrice. Vedere #mismatch(short[], short[]) per la definizione di un prefisso comune e appropriato.

Un null riferimento a matrice viene considerato lessicograficamente minore di unnull riferimento non di matrice. Due null riferimenti di matrice sono considerati uguali.

Il confronto è coerente con #equals(short[], short[]) equals, in particolare i blocchi seguenti per le a matrici e b:

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

Aggiunta in 9.

per java.util.Arrays.compare(.*short[], .*short[]).

Le parti di questa pagina sono modifiche basate sul lavoro creato e condiviso dalla e usati in base ai termini descritti in Creative License 2.5 Attribution License.

[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

Parametri

Valori restituiti

valore 0 se la prima e la seconda matrice sono uguali e contengono gli stessi elementi nello stesso ordine; un valore minore di 0 se la prima matrice è lessicograficamente minore della seconda matrice e un valore maggiore di 0 se la prima matrice è lessicograficamente maggiore della seconda matrice

Attributi

RegisterAttribute

Commenti

Confronta due double matrici lessicograficamente.

Se le due matrici condividono un prefisso comune, il confronto lessicografico è il risultato del confronto di due elementi, come se fosse Double#compare(double, double), in corrispondenza di un indice all'interno delle rispettive matrici che corrisponde alla lunghezza del prefisso. In caso contrario, una matrice è un prefisso appropriato dell'altro e, il confronto lessicografico è il risultato del confronto tra le due lunghezze della matrice. Vedere #mismatch(double[], double[]) per la definizione di un prefisso comune e appropriato.

Un null riferimento a matrice viene considerato lessicograficamente minore di unnull riferimento non di matrice. Due null riferimenti di matrice sono considerati uguali.

Il confronto è coerente con #equals(double[], double[]) equals, in particolare i blocchi seguenti per le a matrici e b:

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

Aggiunta in 9.

per java.util.Arrays.compare(.*double[], .*double[]).

Le parti di questa pagina sono modifiche basate sul lavoro creato e condiviso dalla e usati in base ai termini descritti in Creative License 2.5 Attribution License.

[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

Parametri

Valori restituiti

valore 0 se la prima e la seconda matrice sono uguali e contengono gli stessi elementi nello stesso ordine; un valore minore di 0 se la prima matrice è lessicograficamente minore della seconda matrice e un valore maggiore di 0 se la prima matrice è lessicograficamente maggiore della seconda matrice

Attributi

RegisterAttribute

Commenti

Confronta due char matrici lessicograficamente.

Se le due matrici condividono un prefisso comune, il confronto lessicografico è il risultato del confronto di due elementi, come se fosse Character#compare(char, char), in corrispondenza di un indice all'interno delle rispettive matrici che corrisponde alla lunghezza del prefisso. In caso contrario, una matrice è un prefisso appropriato dell'altro e, il confronto lessicografico è il risultato del confronto tra le due lunghezze della matrice. Vedere #mismatch(char[], char[]) per la definizione di un prefisso comune e appropriato.

Un null riferimento a matrice viene considerato lessicograficamente minore di unnull riferimento non di matrice. Due null riferimenti di matrice sono considerati uguali.

Il confronto è coerente con #equals(char[], char[]) equals, in particolare i blocchi seguenti per le a matrici e b:

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

Aggiunta in 9.

per java.util.Arrays.compare(.*char[], .*char[]).

Le parti di questa pagina sono modifiche basate sul lavoro creato e condiviso dalla e usati in base ai termini descritti in Creative License 2.5 Attribution License.

[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

Parametri

Valori restituiti

valore 0 se la prima e la seconda matrice sono uguali e contengono gli stessi elementi nello stesso ordine; un valore minore di 0 se la prima matrice è lessicograficamente minore della seconda matrice e un valore maggiore di 0 se la prima matrice è lessicograficamente maggiore della seconda matrice

Attributi

RegisterAttribute

Commenti

Confronta due byte matrici lessicograficamente.

Se le due matrici condividono un prefisso comune, il confronto lessicografico è il risultato del confronto di due elementi, come se fosse Byte#compare(byte, byte), in corrispondenza di un indice all'interno delle rispettive matrici che corrisponde alla lunghezza del prefisso. In caso contrario, una matrice è un prefisso appropriato dell'altro e, il confronto lessicografico è il risultato del confronto tra le due lunghezze della matrice. Vedere #mismatch(byte[], byte[]) per la definizione di un prefisso comune e appropriato.

Un null riferimento a matrice viene considerato lessicograficamente minore di unnull riferimento non di matrice. Due null riferimenti di matrice sono considerati uguali.

Il confronto è coerente con #equals(byte[], byte[]) equals, in particolare i blocchi seguenti per le a matrici e b:

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

Aggiunta in 9.

per java.util.Arrays.compare(.*byte[], .*byte[]).

Le parti di questa pagina sono modifiche basate sul lavoro creato e condiviso dalla e usati in base ai termini descritti in Creative License 2.5 Attribution License.

[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

Parametri

Valori restituiti

valore 0 se la prima e la seconda matrice sono uguali e contengono gli stessi elementi nello stesso ordine; un valore minore di 0 se la prima matrice è lessicograficamente minore della seconda matrice e un valore maggiore di 0 se la prima matrice è lessicograficamente maggiore della seconda matrice

Attributi

RegisterAttribute

Commenti

Confronta due boolean matrici lessicograficamente.

Se le due matrici condividono un prefisso comune, il confronto lessicografico è il risultato del confronto di due elementi, come se fosse Boolean#compare(boolean, boolean), in corrispondenza di un indice all'interno delle rispettive matrici che corrisponde alla lunghezza del prefisso. In caso contrario, una matrice è un prefisso appropriato dell'altro e, il confronto lessicografico è il risultato del confronto tra le due lunghezze della matrice. Vedere #mismatch(boolean[], boolean[]) per la definizione di un prefisso comune e appropriato.

Un null riferimento a matrice viene considerato lessicograficamente minore di unnull riferimento non di matrice. Due null riferimenti di matrice sono considerati uguali.

Il confronto è coerente con #equals(boolean[], boolean[]) equals, in particolare i blocchi seguenti per le a matrici e b:

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

Aggiunta in 9.

per java.util.Arrays.compare(.*boolean[], .*boolean[]).

Le parti di questa pagina sono modifiche basate sul lavoro creato e condiviso dalla e usati in base ai termini descritti in Creative License 2.5 Attribution License.

[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

Parametri

Valori restituiti

valore 0 se la prima e la seconda matrice sono uguali e contengono gli stessi elementi nello stesso ordine; un valore minore di 0 se la prima matrice è lessicograficamente minore della seconda matrice e un valore maggiore di 0 se la prima matrice è lessicograficamente maggiore della seconda matrice

Attributi

RegisterAttribute JavaTypeParametersAttribute

Commenti

Confronta due Object matrici, all'interno di elementi confrontabili, lessicograficamente.

Se le due matrici condividono un prefisso comune, il confronto lessicografico è il risultato del confronto di due elementi di tipo T in corrispondenza di un indice i all'interno delle rispettive matrici che rappresenta la lunghezza del prefisso, come se:

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

In caso contrario, una matrice è un prefisso appropriato dell'altro e, il confronto lessicografico è il risultato del confronto tra le due lunghezze della matrice. Vedere #mismatch(Object[], Object[]) per la definizione di un prefisso comune e appropriato.

Un null riferimento a matrice viene considerato lessicograficamente minore di unnull riferimento non di matrice. Due null riferimenti di matrice sono considerati uguali. Un null elemento di matrice viene considerato lessicograficamente minore di un elemento nonnull di matrice. Due null elementi della matrice sono considerati uguali.

Il confronto è coerente con #equals(Object[], Object[]) equals, in particolare i blocchi seguenti per le a matrici e b:

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

Aggiunta in 9.

per java.util.Arrays.compare(T[], T[]).

Le parti di questa pagina sono modifiche basate sul lavoro creato e condiviso dalla e usati in base ai termini descritti in Creative License 2.5 Attribution License.

[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

Parametri

Valori restituiti

valore 0 se la prima e la seconda matrice sono uguali e contengono gli stessi elementi nello stesso ordine; un valore minore di 0 se la prima matrice è lessicograficamente minore della seconda matrice e un valore maggiore di 0 se la prima matrice è lessicograficamente maggiore della seconda matrice

Attributi

RegisterAttribute JavaTypeParametersAttribute

Commenti

Confronta due Object matrici in modo lessicografico usando un confronto specificato.

Se le due matrici condividono un prefisso comune, il confronto lessicografico è il risultato del confronto con il confronto specificato due elementi in corrispondenza di un indice all'interno delle rispettive matrici che rappresenta la lunghezza del prefisso. In caso contrario, una matrice è un prefisso appropriato dell'altro e, il confronto lessicografico è il risultato del confronto tra le due lunghezze della matrice. Vedere #mismatch(Object[], Object[]) per la definizione di un prefisso comune e appropriato.

Un null riferimento a matrice viene considerato lessicograficamente minore di unnull riferimento non di matrice. Due null riferimenti di matrice sono considerati uguali.

Aggiunta in 9.

per java.util.Arrays.compare(T[], T[], java.util.Comparator<? super T>).

Le parti di questa pagina sono modifiche basate sul lavoro creato e condiviso dalla e usati in base ai termini descritti in Creative License 2.5 Attribution License.