Arrays.Compare Método

[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

Parâmetros

Retornos

o valor 0 se, nos intervalos especificados, a primeira e a segunda matriz forem iguais e contiverem os mesmos elementos na mesma ordem; um valor menor do que 0 se, nos intervalos especificados, a primeira matriz for lexicograficamente menor que a segunda matriz; e um valor maior do que 0 se, nos intervalos especificados, a primeira matriz for lexicograficamente maior que a segunda matriz

Atributos

RegisterAttribute

Comentários

Compara duas byte matrizes lexicograficamente em relação aos intervalos especificados.

Se as duas matrizes, nos intervalos especificados, compartilharem um prefixo comum, a comparação lexicográfica será o resultado da comparação de dois elementos, como se fosse, Byte#compare(byte, byte)em um índice relativo dentro das respectivas matrizes que é o comprimento do prefixo. Caso contrário, uma matriz é um prefixo adequado da outra e, a comparação lexicográfica é o resultado da comparação dos dois comprimentos de intervalo. (Consulte #mismatch(byte[], int, int, byte[], int, int) a definição de um prefixo comum e adequado.)

A comparação é consistente com #equals(byte[], int, int, byte[], int, int) equals, mais especificamente, as seguintes retenções para matrizes a e b com intervalos especificados [aFromIndex, aToIndex) e [bFromIndex, bToIndex) respectivamente:

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

Adicionado em 9.

Documentação Java para java.util.Arrays.compare(.*byte[], .*int, .*int, .*byte[], .*int, .*int).

Partes desta página são modificações baseadas no trabalho criado e compartilhado pelo Project Open Source do Open Source e usadas de acordo com os termos descritos na 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

Parâmetros

Retornos

o valor 0 se, nos intervalos especificados, a primeira e a segunda matriz forem iguais e contiverem os mesmos elementos na mesma ordem; um valor menor do que 0 se, nos intervalos especificados, a primeira matriz for lexicograficamente menor que a segunda matriz; e um valor maior do que 0 se, nos intervalos especificados, a primeira matriz for lexicograficamente maior que a segunda matriz

Atributos

RegisterAttribute

Comentários

Compara duas char matrizes lexicograficamente em relação aos intervalos especificados.

Se as duas matrizes, nos intervalos especificados, compartilharem um prefixo comum, a comparação lexicográfica será o resultado da comparação de dois elementos, como se fosse, Character#compare(char, char)em um índice relativo dentro das respectivas matrizes que é o comprimento do prefixo. Caso contrário, uma matriz é um prefixo adequado da outra e, a comparação lexicográfica é o resultado da comparação dos dois comprimentos de intervalo. (Consulte #mismatch(char[], int, int, char[], int, int) a definição de um prefixo comum e adequado.)

A comparação é consistente com #equals(char[], int, int, char[], int, int) equals, mais especificamente, as seguintes retenções para matrizes a e b com intervalos especificados [aFromIndex, aToIndex) e [bFromIndex, bToIndex) respectivamente:

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

Adicionado em 9.

Documentação Java para java.util.Arrays.compare(.*char[], .*int, .*int, .*char[], .*int, .*int).

Partes desta página são modificações baseadas no trabalho criado e compartilhado pelo Project Open Source do Open Source e usadas de acordo com os termos descritos na 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

Parâmetros

Retornos

o valor 0 se, nos intervalos especificados, a primeira e a segunda matriz forem iguais e contiverem os mesmos elementos na mesma ordem; um valor menor do que 0 se, nos intervalos especificados, a primeira matriz for lexicograficamente menor que a segunda matriz; e um valor maior do que 0 se, nos intervalos especificados, a primeira matriz for lexicograficamente maior que a segunda matriz

Atributos

RegisterAttribute

Comentários

Compara duas double matrizes lexicograficamente em relação aos intervalos especificados.

Se as duas matrizes, nos intervalos especificados, compartilharem um prefixo comum, a comparação lexicográfica será o resultado da comparação de dois elementos, como se fosse, Double#compare(double, double)em um índice relativo dentro das respectivas matrizes que é o comprimento do prefixo. Caso contrário, uma matriz é um prefixo adequado da outra e, a comparação lexicográfica é o resultado da comparação dos dois comprimentos de intervalo. (Consulte #mismatch(double[], int, int, double[], int, int) a definição de um prefixo comum e adequado.)

A comparação é consistente com #equals(double[], int, int, double[], int, int) equals, mais especificamente, as seguintes retenções para matrizes a e b com intervalos especificados [aFromIndex, aToIndex) e [bFromIndex, bToIndex) respectivamente:

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

Adicionado em 9.

Documentação Java para java.util.Arrays.compare(.*double[], .*int, .*int, .*double[], .*int, .*int).

Partes desta página são modificações baseadas no trabalho criado e compartilhado pelo Project Open Source do Open Source e usadas de acordo com os termos descritos na 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

Parâmetros

Retornos

o valor 0 se, nos intervalos especificados, a primeira e a segunda matriz forem iguais e contiverem os mesmos elementos na mesma ordem; um valor menor do que 0 se, nos intervalos especificados, a primeira matriz for lexicograficamente menor que a segunda matriz; e um valor maior do que 0 se, nos intervalos especificados, a primeira matriz for lexicograficamente maior que a segunda matriz

Atributos

RegisterAttribute

Comentários

Compara duas short matrizes lexicograficamente em relação aos intervalos especificados.

Se as duas matrizes, nos intervalos especificados, compartilharem um prefixo comum, a comparação lexicográfica será o resultado da comparação de dois elementos, como se fosse, Short#compare(short, short)em um índice relativo dentro das respectivas matrizes que é o comprimento do prefixo. Caso contrário, uma matriz é um prefixo adequado da outra e, a comparação lexicográfica é o resultado da comparação dos dois comprimentos de intervalo. (Consulte #mismatch(short[], int, int, short[], int, int) a definição de um prefixo comum e adequado.)

A comparação é consistente com #equals(short[], int, int, short[], int, int) equals, mais especificamente, as seguintes retenções para matrizes a e b com intervalos especificados [aFromIndex, aToIndex) e [bFromIndex, bToIndex) respectivamente:

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

Adicionado em 9.

Documentação Java para java.util.Arrays.compare(.*short[], .*int, .*int, .*short[], .*int, .*int).

Partes desta página são modificações baseadas no trabalho criado e compartilhado pelo Project Open Source do Open Source e usadas de acordo com os termos descritos na 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

Parâmetros

Retornos

o valor 0 se, nos intervalos especificados, a primeira e a segunda matriz forem iguais e contiverem os mesmos elementos na mesma ordem; um valor menor do que 0 se, nos intervalos especificados, a primeira matriz for lexicograficamente menor que a segunda matriz; e um valor maior do que 0 se, nos intervalos especificados, a primeira matriz for lexicograficamente maior que a segunda matriz

Atributos

RegisterAttribute JavaTypeParametersAttribute

Comentários

Compara duas Object matrizes lexicograficamente em relação aos intervalos especificados.

Se as duas matrizes, nos intervalos especificados, compartilharem um prefixo comum, a comparação lexicográfica será o resultado da comparação com o comparador especificado de dois elementos em um índice relativo dentro das respectivas matrizes que é o comprimento do prefixo. Caso contrário, uma matriz é um prefixo adequado da outra e, a comparação lexicográfica é o resultado da comparação dos dois comprimentos de intervalo. (Consulte #mismatch(Object[], int, int, Object[], int, int) a definição de um prefixo comum e adequado.)

Adicionado em 9.

Documentação Java para java.util.Arrays.compare(T[], int, int, T[], int, int, java.util.Comparator<? super T>).

Partes desta página são modificações baseadas no trabalho criado e compartilhado pelo Project Open Source do Open Source e usadas de acordo com os termos descritos na 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

Parâmetros

Retornos

o valor 0 se, nos intervalos especificados, a primeira e a segunda matriz forem iguais e contiverem os mesmos elementos na mesma ordem; um valor menor do que 0 se, nos intervalos especificados, a primeira matriz for lexicograficamente menor que a segunda matriz; e um valor maior do que 0 se, nos intervalos especificados, a primeira matriz for lexicograficamente maior que a segunda matriz

Atributos

RegisterAttribute

Comentários

Compara duas long matrizes lexicograficamente em relação aos intervalos especificados.

Se as duas matrizes, nos intervalos especificados, compartilharem um prefixo comum, a comparação lexicográfica será o resultado da comparação de dois elementos, como se fosse, Long#compare(long, long)em um índice relativo dentro das respectivas matrizes que é o comprimento do prefixo. Caso contrário, uma matriz é um prefixo adequado da outra e, a comparação lexicográfica é o resultado da comparação dos dois comprimentos de intervalo. (Consulte #mismatch(long[], int, int, long[], int, int) a definição de um prefixo comum e adequado.)

A comparação é consistente com #equals(long[], int, int, long[], int, int) equals, mais especificamente, as seguintes retenções para matrizes a e b com intervalos especificados [aFromIndex, aToIndex) e [bFromIndex, bToIndex) respectivamente:

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

Adicionado em 9.

Documentação Java para java.util.Arrays.compare(.*long[], .*int, .*int, .*long[], .*int, .*int).

Partes desta página são modificações baseadas no trabalho criado e compartilhado pelo Project Open Source do Open Source e usadas de acordo com os termos descritos na 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

Parâmetros

Retornos

o valor 0 se, nos intervalos especificados, a primeira e a segunda matriz forem iguais e contiverem os mesmos elementos na mesma ordem; um valor menor do que 0 se, nos intervalos especificados, a primeira matriz for lexicograficamente menor que a segunda matriz; e um valor maior do que 0 se, nos intervalos especificados, a primeira matriz for lexicograficamente maior que a segunda matriz

Atributos

RegisterAttribute

Comentários

Compara duas float matrizes lexicograficamente em relação aos intervalos especificados.

Se as duas matrizes, nos intervalos especificados, compartilharem um prefixo comum, a comparação lexicográfica será o resultado da comparação de dois elementos, como se fosse, Float#compare(float, float)em um índice relativo dentro das respectivas matrizes que é o comprimento do prefixo. Caso contrário, uma matriz é um prefixo adequado da outra e, a comparação lexicográfica é o resultado da comparação dos dois comprimentos de intervalo. (Consulte #mismatch(float[], int, int, float[], int, int) a definição de um prefixo comum e adequado.)

A comparação é consistente com #equals(float[], int, int, float[], int, int) equals, mais especificamente, as seguintes retenções para matrizes a e b com intervalos especificados [aFromIndex, aToIndex) e [bFromIndex, bToIndex) respectivamente:

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

Adicionado em 9.

Documentação Java para java.util.Arrays.compare(.*float[], .*int, .*int, .*float[], .*int, .*int).

Partes desta página são modificações baseadas no trabalho criado e compartilhado pelo Project Open Source do Open Source e usadas de acordo com os termos descritos na 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

Parâmetros

Retornos

o valor 0 se, nos intervalos especificados, a primeira e a segunda matriz forem iguais e contiverem os mesmos elementos na mesma ordem; um valor menor do que 0 se, nos intervalos especificados, a primeira matriz for lexicograficamente menor que a segunda matriz; e um valor maior do que 0 se, nos intervalos especificados, a primeira matriz for lexicograficamente maior que a segunda matriz

Atributos

RegisterAttribute

Comentários

Compara duas boolean matrizes lexicograficamente em relação aos intervalos especificados.

Se as duas matrizes, nos intervalos especificados, compartilharem um prefixo comum, a comparação lexicográfica será o resultado da comparação de dois elementos, como se fosse, Boolean#compare(boolean, boolean)em um índice relativo dentro das respectivas matrizes que é o comprimento do prefixo. Caso contrário, uma matriz é um prefixo adequado da outra e, a comparação lexicográfica é o resultado da comparação dos dois comprimentos de intervalo. (Consulte #mismatch(boolean[], int, int, boolean[], int, int) a definição de um prefixo comum e adequado.)

A comparação é consistente com #equals(boolean[], int, int, boolean[], int, int) equals, mais especificamente, as seguintes retenções para matrizes a e b com intervalos especificados [aFromIndex, aToIndex) e [bFromIndex, bToIndex) respectivamente:

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

Adicionado em 9.

Documentação Java para java.util.Arrays.compare(.*boolean[], .*int, .*int, .*boolean[], .*int, .*int).

Partes desta página são modificações baseadas no trabalho criado e compartilhado pelo Project Open Source do Open Source e usadas de acordo com os termos descritos na 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

Parâmetros

Retornos

o valor 0 se, nos intervalos especificados, a primeira e a segunda matriz forem iguais e contiverem os mesmos elementos na mesma ordem; um valor menor do que 0 se, nos intervalos especificados, a primeira matriz for lexicograficamente menor que a segunda matriz; e um valor maior do que 0 se, nos intervalos especificados, a primeira matriz for lexicograficamente maior que a segunda matriz

Atributos

RegisterAttribute

Comentários

Compara duas int matrizes lexicograficamente em relação aos intervalos especificados.

Se as duas matrizes, nos intervalos especificados, compartilharem um prefixo comum, a comparação lexicográfica será o resultado da comparação de dois elementos, como se fosse, Integer#compare(int, int)em um índice relativo dentro das respectivas matrizes que é o comprimento do prefixo. Caso contrário, uma matriz é um prefixo adequado da outra e, a comparação lexicográfica é o resultado da comparação dos dois comprimentos de intervalo. (Consulte #mismatch(int[], int, int, int[], int, int) a definição de um prefixo comum e adequado.)

A comparação é consistente com #equals(int[], int, int, int[], int, int) equals, mais especificamente, as seguintes retenções para matrizes a e b com intervalos especificados [aFromIndex, aToIndex) e [bFromIndex, bToIndex) respectivamente:

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

Adicionado em 9.

Documentação Java para java.util.Arrays.compare(.*int[], .*int, .*int, .*int[], .*int, .*int).

Partes desta página são modificações baseadas no trabalho criado e compartilhado pelo Project Open Source do Open Source e usadas de acordo com os termos descritos na 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

Parâmetros

Retornos

o valor 0 se, nos intervalos especificados, a primeira e a segunda matriz forem iguais e contiverem os mesmos elementos na mesma ordem; um valor menor do que 0 se, nos intervalos especificados, a primeira matriz for lexicograficamente menor que a segunda matriz; e um valor maior do que 0 se, nos intervalos especificados, a primeira matriz for lexicograficamente maior que a segunda matriz

Atributos

RegisterAttribute JavaTypeParametersAttribute

Comentários

Compara duas Object matrizes lexicograficamente em relação aos intervalos especificados.

Se as duas matrizes, nos intervalos especificados, compartilharem um prefixo comum, a comparação lexicográfica será o resultado da comparação de dois elementos do tipo T em um índice i relativo dentro das respectivas matrizes que são o comprimento do prefixo, como se fosse:

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

Caso contrário, uma matriz é um prefixo adequado da outra e, a comparação lexicográfica é o resultado da comparação dos dois comprimentos de intervalo. (Consulte #mismatch(Object[], int, int, Object[], int, int) a definição de um prefixo comum e adequado.)

A comparação é consistente com #equals(Object[], int, int, Object[], int, int) equals, mais especificamente, as seguintes retenções para matrizes a e b com intervalos especificados [aFromIndex, atoIndex) e [bFromIndex, btoIndex) respectivamente:

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

Adicionado em 9.

Documentação Java para java.util.Arrays.compare(T[], int, int, T[], int, int).

Partes desta página são modificações baseadas no trabalho criado e compartilhado pelo Project Open Source do Open Source e usadas de acordo com os termos descritos na 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

Parâmetros

Retornos

o valor 0 se a primeira e a segunda matriz forem iguais e contiverem os mesmos elementos na mesma ordem; um valor menor do que 0 se a primeira matriz for lexicograficamente menor que a segunda matriz; e um valor maior que 0 se a primeira matriz for lexicograficamente maior que a segunda matriz

Atributos

RegisterAttribute

Comentários

Compara duas int matrizes lexicograficamente.

Se as duas matrizes compartilharem um prefixo comum, a comparação lexicográfica será o resultado da comparação de dois elementos, como se por Integer#compare(int, int), em um índice dentro das respectivas matrizes que é o comprimento do prefixo. Caso contrário, uma matriz é um prefixo adequado da outra e, a comparação lexicográfica é o resultado da comparação dos dois comprimentos de matriz. (Consulte #mismatch(int[], int[]) a definição de um prefixo comum e adequado.)

Uma null referência de matriz é considerada lexicograficamente menor que uma referência não matriznull . Duas null referências de matriz são consideradas iguais.

A comparação é consistente com #equals(int[], int[]) equals, mais especificamente, as seguintes retenções para matrizes a e b:

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

Adicionado em 9.

Documentação Java para java.util.Arrays.compare(.*int[], .*int[]).

Partes desta página são modificações baseadas no trabalho criado e compartilhado pelo Project Open Source do Open Source e usadas de acordo com os termos descritos na 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

Parâmetros

Retornos

o valor 0 se a primeira e a segunda matriz forem iguais e contiverem os mesmos elementos na mesma ordem; um valor menor do que 0 se a primeira matriz for lexicograficamente menor que a segunda matriz; e um valor maior que 0 se a primeira matriz for lexicograficamente maior que a segunda matriz

Atributos

RegisterAttribute

Comentários

Compara duas float matrizes lexicograficamente.

Se as duas matrizes compartilharem um prefixo comum, a comparação lexicográfica será o resultado da comparação de dois elementos, como se por Float#compare(float, float), em um índice dentro das respectivas matrizes que é o comprimento do prefixo. Caso contrário, uma matriz é um prefixo adequado da outra e, a comparação lexicográfica é o resultado da comparação dos dois comprimentos de matriz. (Consulte #mismatch(float[], float[]) a definição de um prefixo comum e adequado.)

Uma null referência de matriz é considerada lexicograficamente menor que uma referência não matriznull . Duas null referências de matriz são consideradas iguais.

A comparação é consistente com #equals(float[], float[]) equals, mais especificamente, as seguintes retenções para matrizes a e b:

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

Adicionado em 9.

Documentação Java para java.util.Arrays.compare(.*float[], .*float[]).

Partes desta página são modificações baseadas no trabalho criado e compartilhado pelo Project Open Source do Open Source e usadas de acordo com os termos descritos na 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

Parâmetros

Retornos

o valor 0 se a primeira e a segunda matriz forem iguais e contiverem os mesmos elementos na mesma ordem; um valor menor do que 0 se a primeira matriz for lexicograficamente menor que a segunda matriz; e um valor maior que 0 se a primeira matriz for lexicograficamente maior que a segunda matriz

Atributos

RegisterAttribute

Comentários

Compara duas long matrizes lexicograficamente.

Se as duas matrizes compartilharem um prefixo comum, a comparação lexicográfica será o resultado da comparação de dois elementos, como se por Long#compare(long, long), em um índice dentro das respectivas matrizes que é o comprimento do prefixo. Caso contrário, uma matriz é um prefixo adequado da outra e, a comparação lexicográfica é o resultado da comparação dos dois comprimentos de matriz. (Consulte #mismatch(long[], long[]) a definição de um prefixo comum e adequado.)

Uma null referência de matriz é considerada lexicograficamente menor que uma referência não matriznull . Duas null referências de matriz são consideradas iguais.

A comparação é consistente com #equals(long[], long[]) equals, mais especificamente, as seguintes retenções para matrizes a e b:

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

Adicionado em 9.

Documentação Java para java.util.Arrays.compare(.*long[], .*long[]).

Partes desta página são modificações baseadas no trabalho criado e compartilhado pelo Project Open Source do Open Source e usadas de acordo com os termos descritos na 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

Parâmetros

Retornos

o valor 0 se a primeira e a segunda matriz forem iguais e contiverem os mesmos elementos na mesma ordem; um valor menor do que 0 se a primeira matriz for lexicograficamente menor que a segunda matriz; e um valor maior que 0 se a primeira matriz for lexicograficamente maior que a segunda matriz

Atributos

RegisterAttribute

Comentários

Compara duas short matrizes lexicograficamente.

Se as duas matrizes compartilharem um prefixo comum, a comparação lexicográfica será o resultado da comparação de dois elementos, como se por Short#compare(short, short), em um índice dentro das respectivas matrizes que é o comprimento do prefixo. Caso contrário, uma matriz é um prefixo adequado da outra e, a comparação lexicográfica é o resultado da comparação dos dois comprimentos de matriz. (Consulte #mismatch(short[], short[]) a definição de um prefixo comum e adequado.)

Uma null referência de matriz é considerada lexicograficamente menor que uma referência não matriznull . Duas null referências de matriz são consideradas iguais.

A comparação é consistente com #equals(short[], short[]) equals, mais especificamente, as seguintes retenções para matrizes a e b:

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

Adicionado em 9.

Documentação Java para java.util.Arrays.compare(.*short[], .*short[]).

Partes desta página são modificações baseadas no trabalho criado e compartilhado pelo Project Open Source do Open Source e usadas de acordo com os termos descritos na 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

Parâmetros

Retornos

o valor 0 se a primeira e a segunda matriz forem iguais e contiverem os mesmos elementos na mesma ordem; um valor menor do que 0 se a primeira matriz for lexicograficamente menor que a segunda matriz; e um valor maior que 0 se a primeira matriz for lexicograficamente maior que a segunda matriz

Atributos

RegisterAttribute

Comentários

Compara duas double matrizes lexicograficamente.

Se as duas matrizes compartilharem um prefixo comum, a comparação lexicográfica será o resultado da comparação de dois elementos, como se por Double#compare(double, double), em um índice dentro das respectivas matrizes que é o comprimento do prefixo. Caso contrário, uma matriz é um prefixo adequado da outra e, a comparação lexicográfica é o resultado da comparação dos dois comprimentos de matriz. (Consulte #mismatch(double[], double[]) a definição de um prefixo comum e adequado.)

Uma null referência de matriz é considerada lexicograficamente menor que uma referência não matriznull . Duas null referências de matriz são consideradas iguais.

A comparação é consistente com #equals(double[], double[]) equals, mais especificamente, as seguintes retenções para matrizes a e b:

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

Adicionado em 9.

Documentação Java para java.util.Arrays.compare(.*double[], .*double[]).

Partes desta página são modificações baseadas no trabalho criado e compartilhado pelo Project Open Source do Open Source e usadas de acordo com os termos descritos na 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

Parâmetros

Retornos

o valor 0 se a primeira e a segunda matriz forem iguais e contiverem os mesmos elementos na mesma ordem; um valor menor do que 0 se a primeira matriz for lexicograficamente menor que a segunda matriz; e um valor maior que 0 se a primeira matriz for lexicograficamente maior que a segunda matriz

Atributos

RegisterAttribute

Comentários

Compara duas char matrizes lexicograficamente.

Se as duas matrizes compartilharem um prefixo comum, a comparação lexicográfica será o resultado da comparação de dois elementos, como se por Character#compare(char, char), em um índice dentro das respectivas matrizes que é o comprimento do prefixo. Caso contrário, uma matriz é um prefixo adequado da outra e, a comparação lexicográfica é o resultado da comparação dos dois comprimentos de matriz. (Consulte #mismatch(char[], char[]) a definição de um prefixo comum e adequado.)

Uma null referência de matriz é considerada lexicograficamente menor que uma referência não matriznull . Duas null referências de matriz são consideradas iguais.

A comparação é consistente com #equals(char[], char[]) equals, mais especificamente, as seguintes retenções para matrizes a e b:

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

Adicionado em 9.

Documentação Java para java.util.Arrays.compare(.*char[], .*char[]).

Partes desta página são modificações baseadas no trabalho criado e compartilhado pelo Project Open Source do Open Source e usadas de acordo com os termos descritos na 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

Parâmetros

Retornos

o valor 0 se a primeira e a segunda matriz forem iguais e contiverem os mesmos elementos na mesma ordem; um valor menor do que 0 se a primeira matriz for lexicograficamente menor que a segunda matriz; e um valor maior que 0 se a primeira matriz for lexicograficamente maior que a segunda matriz

Atributos

RegisterAttribute

Comentários

Compara duas byte matrizes lexicograficamente.

Se as duas matrizes compartilharem um prefixo comum, a comparação lexicográfica será o resultado da comparação de dois elementos, como se por Byte#compare(byte, byte), em um índice dentro das respectivas matrizes que é o comprimento do prefixo. Caso contrário, uma matriz é um prefixo adequado da outra e, a comparação lexicográfica é o resultado da comparação dos dois comprimentos de matriz. (Consulte #mismatch(byte[], byte[]) a definição de um prefixo comum e adequado.)

Uma null referência de matriz é considerada lexicograficamente menor que uma referência não matriznull . Duas null referências de matriz são consideradas iguais.

A comparação é consistente com #equals(byte[], byte[]) equals, mais especificamente, as seguintes retenções para matrizes a e b:

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

Adicionado em 9.

Documentação Java para java.util.Arrays.compare(.*byte[], .*byte[]).

Partes desta página são modificações baseadas no trabalho criado e compartilhado pelo Project Open Source do Open Source e usadas de acordo com os termos descritos na 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

Parâmetros

Retornos

o valor 0 se a primeira e a segunda matriz forem iguais e contiverem os mesmos elementos na mesma ordem; um valor menor do que 0 se a primeira matriz for lexicograficamente menor que a segunda matriz; e um valor maior que 0 se a primeira matriz for lexicograficamente maior que a segunda matriz

Atributos

RegisterAttribute

Comentários

Compara duas boolean matrizes lexicograficamente.

Se as duas matrizes compartilharem um prefixo comum, a comparação lexicográfica será o resultado da comparação de dois elementos, como se por Boolean#compare(boolean, boolean), em um índice dentro das respectivas matrizes que é o comprimento do prefixo. Caso contrário, uma matriz é um prefixo adequado da outra e, a comparação lexicográfica é o resultado da comparação dos dois comprimentos de matriz. (Consulte #mismatch(boolean[], boolean[]) a definição de um prefixo comum e adequado.)

Uma null referência de matriz é considerada lexicograficamente menor que uma referência não matriznull . Duas null referências de matriz são consideradas iguais.

A comparação é consistente com #equals(boolean[], boolean[]) equals, mais especificamente, as seguintes retenções para matrizes a e b:

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

Adicionado em 9.

Documentação Java para java.util.Arrays.compare(.*boolean[], .*boolean[]).

Partes desta página são modificações baseadas no trabalho criado e compartilhado pelo Project Open Source do Open Source e usadas de acordo com os termos descritos na 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

Parâmetros

Retornos

o valor 0 se a primeira e a segunda matriz forem iguais e contiverem os mesmos elementos na mesma ordem; um valor menor do que 0 se a primeira matriz for lexicograficamente menor que a segunda matriz; e um valor maior que 0 se a primeira matriz for lexicograficamente maior que a segunda matriz

Atributos

RegisterAttribute JavaTypeParametersAttribute

Comentários

Compara duas Object matrizes, dentro de elementos comparáveis, lexicograficamente.

Se as duas matrizes compartilharem um prefixo comum, a comparação lexicográfica será o resultado da comparação de dois elementos do tipo T em um índice i dentro das respectivas matrizes que é o comprimento do prefixo, como se fosse:

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

Caso contrário, uma matriz é um prefixo adequado da outra e, a comparação lexicográfica é o resultado da comparação dos dois comprimentos de matriz. (Consulte #mismatch(Object[], Object[]) a definição de um prefixo comum e adequado.)

Uma null referência de matriz é considerada lexicograficamente menor que uma referência não matriznull . Duas null referências de matriz são consideradas iguais. Um null elemento de matriz é considerado lexicograficamente menor que um elemento não matriznull . Dois null elementos de matriz são considerados iguais.

A comparação é consistente com #equals(Object[], Object[]) equals, mais especificamente, as seguintes retenções para matrizes a e b:

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

Adicionado em 9.

Documentação Java para java.util.Arrays.compare(T[], T[]).

Partes desta página são modificações baseadas no trabalho criado e compartilhado pelo Project Open Source do Open Source e usadas de acordo com os termos descritos na 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

Parâmetros

Retornos

o valor 0 se a primeira e a segunda matriz forem iguais e contiverem os mesmos elementos na mesma ordem; um valor menor do que 0 se a primeira matriz for lexicograficamente menor que a segunda matriz; e um valor maior que 0 se a primeira matriz for lexicograficamente maior que a segunda matriz

Atributos

RegisterAttribute JavaTypeParametersAttribute

Comentários

Compara duas Object matrizes lexicograficamente usando um comparador especificado.

Se as duas matrizes compartilharem um prefixo comum, a comparação lexicográfica será o resultado da comparação com o comparador especificado de dois elementos em um índice dentro das respectivas matrizes que é o comprimento do prefixo. Caso contrário, uma matriz é um prefixo adequado da outra e, a comparação lexicográfica é o resultado da comparação dos dois comprimentos de matriz. (Consulte #mismatch(Object[], Object[]) a definição de um prefixo comum e adequado.)

Uma null referência de matriz é considerada lexicograficamente menor que uma referência não matriznull . Duas null referências de matriz são consideradas iguais.

Adicionado em 9.

Documentação Java para java.util.Arrays.compare(T[], T[], java.util.Comparator<? super T>).

Partes desta página são modificações baseadas no trabalho criado e compartilhado pelo Android Open Source Project e usadas de acordo com os termos descritos na Licença de Atribuição Creative Commons 2.5.