Arrays.Compare Método

Definición

Espacio de nombres:: Java.Util

Ensamblado:: Mono.Android.dll

Importante

Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.

Sobrecargas

Nombre	Description
Compare(Byte[], Int32, Int32, Byte[], Int32, Int32)	Compara dos `byte` matrices lexicográficamente en los intervalos especificados.
Compare(Char[], Int32, Int32, Char[], Int32, Int32)	Compara dos `char` matrices lexicográficamente en los intervalos especificados.
Compare(Double[], Int32, Int32, Double[], Int32, Int32)	Compara dos `double` matrices lexicográficamente en los intervalos especificados.
Compare(Int16[], Int32, Int32, Int16[], Int32, Int32)	Compara dos `short` matrices lexicográficamente en los intervalos especificados.
Compare(Object[], Int32, Int32, Object[], Int32, Int32, IComparator)	Compara dos `Object` matrices lexicográficamente en los intervalos especificados.
Compare(Int64[], Int32, Int32, Int64[], Int32, Int32)	Compara dos `long` matrices lexicográficamente en los intervalos especificados.
Compare(Single[], Int32, Int32, Single[], Int32, Int32)	Compara dos `float` matrices lexicográficamente en los intervalos especificados.
Compare(Boolean[], Int32, Int32, Boolean[], Int32, Int32)	Compara dos `boolean` matrices lexicográficamente en los intervalos especificados.
Compare(Int32[], Int32, Int32, Int32[], Int32, Int32)	Compara dos `int` matrices lexicográficamente en los intervalos especificados.
Compare(Object[], Int32, Int32, Object[], Int32, Int32)	Compara dos `Object` matrices lexicográficamente en los intervalos especificados.
Compare(Int32[], Int32[])	Compara dos `int` matrices lexicográficamente.
Compare(Single[], Single[])	Compara dos `float` matrices lexicográficamente.
Compare(Int64[], Int64[])	Compara dos `long` matrices lexicográficamente.
Compare(Int16[], Int16[])	Compara dos `short` matrices lexicográficamente.
Compare(Double[], Double[])	Compara dos `double` matrices lexicográficamente.
Compare(Char[], Char[])	Compara dos `char` matrices lexicográficamente.
Compare(Byte[], Byte[])	Compara dos `byte` matrices lexicográficamente.
Compare(Boolean[], Boolean[])	Compara dos `boolean` matrices lexicográficamente.
Compare(Object[], Object[])	Compara dos `Object` matrices, dentro de elementos comparables, lexicográficamente.
Compare(Object[], Object[], IComparator)	Compara dos `Object` matrices lexicográficamente mediante un comparador especificado.

Compare(Byte[], Int32, Int32, Byte[], Int32, Int32)

Compara dos byte matrices lexicográficamente en los intervalos especificados.

[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

a: Byte[]

la primera matriz que se va a comparar

aFromIndex: Int32

índice (inclusivo) del primer elemento de la primera matriz que se va a comparar.

aToIndex: Int32

índice (exclusivo) del último elemento de la primera matriz que se va a comparar

b: Byte[]

la segunda matriz que se va a comparar

bFromIndex: Int32

índice (inclusivo) del primer elemento de la segunda matriz que se va a comparar.

bToIndex: Int32

índice (exclusivo) del último elemento de la segunda matriz que se va a comparar.

Devoluciones

Int32

el valor 0 si, en los intervalos especificados, la primera y la segunda matriz son iguales y contienen los mismos elementos en el mismo orden; un valor menor que 0 si, en los intervalos especificados, la primera matriz es lexicográficamente menor que la segunda matriz; y un valor mayor que 0 si, en los intervalos especificados, la primera matriz es lexicográficamente mayor que la segunda matriz.

Atributos: RegisterAttribute

Comentarios

Compara dos byte matrices lexicográficamente en los intervalos especificados.

Si las dos matrices, en los intervalos especificados, comparten un prefijo común, la comparación lexicográfica es el resultado de comparar dos elementos, como si fuera por Byte#compare(byte, byte), en un índice relativo dentro de las matrices respectivas que es la longitud del prefijo. De lo contrario, una matriz es un prefijo adecuado del otro y, la comparación lexicográfica es el resultado de comparar las dos longitudes de intervalo. (Consulte #mismatch(byte[], int, int, byte[], int, int) la definición de un prefijo común y adecuado).

La comparación es coherente con #equals(byte[], int, int, byte[], int, int) equals, más concretamente las siguientes suspensiones para matrices a y b con intervalos especificados [aFromIndex, aToIndex) y [bFromIndex, bToIndex) respectivamente:

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

Agregado en 9.

Java documentación para java.util.Arrays.compare(.*byte[], .*int, .*int, .*byte[], .*int, .*int).

Las partes de esta página son modificaciones basadas en el trabajo creado y compartido por el Android y se usan según los términos descritos en creative Creative Commons 2.5 Attribution License.

Se aplica a

Compare(Char[], Int32, Int32, Char[], Int32, Int32)

Compara dos char matrices lexicográficamente en los intervalos especificados.

[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

a: Char[]

la primera matriz que se va a comparar

aFromIndex: Int32

índice (inclusivo) del primer elemento de la primera matriz que se va a comparar.

aToIndex: Int32

índice (exclusivo) del último elemento de la primera matriz que se va a comparar

b: Char[]

la segunda matriz que se va a comparar

bFromIndex: Int32

índice (inclusivo) del primer elemento de la segunda matriz que se va a comparar.

bToIndex: Int32

índice (exclusivo) del último elemento de la segunda matriz que se va a comparar.

Devoluciones

Int32

Atributos: RegisterAttribute

Comentarios

Compara dos char matrices lexicográficamente en los intervalos especificados.

Si las dos matrices, en los intervalos especificados, comparten un prefijo común, la comparación lexicográfica es el resultado de comparar dos elementos, como si fuera por Character#compare(char, char), en un índice relativo dentro de las matrices respectivas que es la longitud del prefijo. De lo contrario, una matriz es un prefijo adecuado del otro y, la comparación lexicográfica es el resultado de comparar las dos longitudes de intervalo. (Consulte #mismatch(char[], int, int, char[], int, int) la definición de un prefijo común y adecuado).

La comparación es coherente con #equals(char[], int, int, char[], int, int) equals, más concretamente las siguientes suspensiones para matrices a y b con intervalos especificados [aFromIndex, aToIndex) y [bFromIndex, bToIndex) respectivamente:

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

Agregado en 9.

Java documentación para java.util.Arrays.compare(.*char[], .*int, .*int, .*char[], .*int, .*int).

Las partes de esta página son modificaciones basadas en el trabajo creado y compartido por el Android y se usan según los términos descritos en creative Creative Commons 2.5 Attribution License.

Se aplica a

Compare(Double[], Int32, Int32, Double[], Int32, Int32)

Compara dos double matrices lexicográficamente en los intervalos especificados.

[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

a: Double[]

la primera matriz que se va a comparar

aFromIndex: Int32

índice (inclusivo) del primer elemento de la primera matriz que se va a comparar.

aToIndex: Int32

índice (exclusivo) del último elemento de la primera matriz que se va a comparar

b: Double[]

la segunda matriz que se va a comparar

bFromIndex: Int32

índice (inclusivo) del primer elemento de la segunda matriz que se va a comparar.

bToIndex: Int32

índice (exclusivo) del último elemento de la segunda matriz que se va a comparar.

Devoluciones

Int32

Atributos: RegisterAttribute

Comentarios

Compara dos double matrices lexicográficamente en los intervalos especificados.

Si las dos matrices, en los intervalos especificados, comparten un prefijo común, la comparación lexicográfica es el resultado de comparar dos elementos, como si fuera por Double#compare(double, double), en un índice relativo dentro de las matrices respectivas que es la longitud del prefijo. De lo contrario, una matriz es un prefijo adecuado del otro y, la comparación lexicográfica es el resultado de comparar las dos longitudes de intervalo. (Consulte #mismatch(double[], int, int, double[], int, int) la definición de un prefijo común y adecuado).

La comparación es coherente con #equals(double[], int, int, double[], int, int) equals, más concretamente las siguientes suspensiones para matrices a y b con intervalos especificados [aFromIndex, aToIndex) y [bFromIndex, bToIndex) respectivamente:

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

Agregado en 9.

Java documentación para java.util.Arrays.compare(.*double[], .*int, .*int, .*double[], .*int, .*int).

Las partes de esta página son modificaciones basadas en el trabajo creado y compartido por el Android y se usan según los términos descritos en creative Creative Commons 2.5 Attribution License.

Se aplica a

Compare(Int16[], Int32, Int32, Int16[], Int32, Int32)

Compara dos short matrices lexicográficamente en los intervalos especificados.

[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

a: Int16[]

la primera matriz que se va a comparar

aFromIndex: Int32

índice (inclusivo) del primer elemento de la primera matriz que se va a comparar.

aToIndex: Int32

índice (exclusivo) del último elemento de la primera matriz que se va a comparar

b: Int16[]

la segunda matriz que se va a comparar

bFromIndex: Int32

índice (inclusivo) del primer elemento de la segunda matriz que se va a comparar.

bToIndex: Int32

índice (exclusivo) del último elemento de la segunda matriz que se va a comparar.

Devoluciones

Int32

Atributos: RegisterAttribute

Comentarios

Compara dos short matrices lexicográficamente en los intervalos especificados.

Si las dos matrices, en los intervalos especificados, comparten un prefijo común, la comparación lexicográfica es el resultado de comparar dos elementos, como si fuera por Short#compare(short, short), en un índice relativo dentro de las matrices respectivas que es la longitud del prefijo. De lo contrario, una matriz es un prefijo adecuado del otro y, la comparación lexicográfica es el resultado de comparar las dos longitudes de intervalo. (Consulte #mismatch(short[], int, int, short[], int, int) la definición de un prefijo común y adecuado).

La comparación es coherente con #equals(short[], int, int, short[], int, int) equals, más concretamente las siguientes suspensiones para matrices a y b con intervalos especificados [aFromIndex, aToIndex) y [bFromIndex, bToIndex) respectivamente:

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

Agregado en 9.

Java documentación para java.util.Arrays.compare(.*short[], .*int, .*int, .*short[], .*int, .*int).

Las partes de esta página son modificaciones basadas en el trabajo creado y compartido por el Android y se usan según los términos descritos en creative Creative Commons 2.5 Attribution License.

Se aplica a

Compare(Object[], Int32, Int32, Object[], Int32, Int32, IComparator)

Compara dos Object matrices lexicográficamente en los intervalos especificados.

[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

a: Object[]

la primera matriz que se va a comparar

aFromIndex: Int32

índice (inclusivo) del primer elemento de la primera matriz que se va a comparar.

aToIndex: Int32

índice (exclusivo) del último elemento de la primera matriz que se va a comparar

b: Object[]

la segunda matriz que se va a comparar

bFromIndex: Int32

índice (inclusivo) del primer elemento de la segunda matriz que se va a comparar.

bToIndex: Int32

índice (exclusivo) del último elemento de la segunda matriz que se va a comparar.

cmp: IComparator

comparador para comparar elementos de matriz

Devoluciones

Int32

Atributos: RegisterAttribute JavaTypeParametersAttribute

Comentarios

Compara dos Object matrices lexicográficamente en los intervalos especificados.

Si las dos matrices, en los intervalos especificados, comparten un prefijo común, la comparación lexicográfica es el resultado de comparar con el comparador especificado dos elementos en un índice relativo dentro de las matrices respectivas que es la longitud del prefijo. De lo contrario, una matriz es un prefijo adecuado del otro y, la comparación lexicográfica es el resultado de comparar las dos longitudes de intervalo. (Consulte #mismatch(Object[], int, int, Object[], int, int) la definición de un prefijo común y adecuado).

Agregado en 9.

Java documentación para java.util.Arrays.compare(T[], int, int, T[], int, int, java.util.Comparator<? super T>).

Las partes de esta página son modificaciones basadas en el trabajo creado y compartido por el Android y se usan según los términos descritos en creative Creative Commons 2.5 Attribution License.

Se aplica a

Compare(Int64[], Int32, Int32, Int64[], Int32, Int32)

Compara dos long matrices lexicográficamente en los intervalos especificados.

[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

a: Int64[]

la primera matriz que se va a comparar

aFromIndex: Int32

índice (inclusivo) del primer elemento de la primera matriz que se va a comparar.

aToIndex: Int32

índice (exclusivo) del último elemento de la primera matriz que se va a comparar

b: Int64[]

la segunda matriz que se va a comparar

bFromIndex: Int32

índice (inclusivo) del primer elemento de la segunda matriz que se va a comparar.

bToIndex: Int32

índice (exclusivo) del último elemento de la segunda matriz que se va a comparar.

Devoluciones

Int32

Atributos: RegisterAttribute

Comentarios

Compara dos long matrices lexicográficamente en los intervalos especificados.

Si las dos matrices, en los intervalos especificados, comparten un prefijo común, la comparación lexicográfica es el resultado de comparar dos elementos, como si fuera por Long#compare(long, long), en un índice relativo dentro de las matrices respectivas que es la longitud del prefijo. De lo contrario, una matriz es un prefijo adecuado del otro y, la comparación lexicográfica es el resultado de comparar las dos longitudes de intervalo. (Consulte #mismatch(long[], int, int, long[], int, int) la definición de un prefijo común y adecuado).

La comparación es coherente con #equals(long[], int, int, long[], int, int) equals, más concretamente las siguientes suspensiones para matrices a y b con intervalos especificados [aFromIndex, aToIndex) y [bFromIndex, bToIndex) respectivamente:

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

Agregado en 9.

Java documentación para java.util.Arrays.compare(.*long[], .*int, .*int, .*long[], .*int, .*int).

Las partes de esta página son modificaciones basadas en el trabajo creado y compartido por el Android y se usan según los términos descritos en creative Creative Commons 2.5 Attribution License.

Se aplica a

Compare(Single[], Int32, Int32, Single[], Int32, Int32)

Compara dos float matrices lexicográficamente en los intervalos especificados.

[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

a: Single[]

la primera matriz que se va a comparar

aFromIndex: Int32

índice (inclusivo) del primer elemento de la primera matriz que se va a comparar.

aToIndex: Int32

índice (exclusivo) del último elemento de la primera matriz que se va a comparar

b: Single[]

la segunda matriz que se va a comparar

bFromIndex: Int32

índice (inclusivo) del primer elemento de la segunda matriz que se va a comparar.

bToIndex: Int32

índice (exclusivo) del último elemento de la segunda matriz que se va a comparar.

Devoluciones

Int32

Atributos: RegisterAttribute

Comentarios

Compara dos float matrices lexicográficamente en los intervalos especificados.

Si las dos matrices, en los intervalos especificados, comparten un prefijo común, la comparación lexicográfica es el resultado de comparar dos elementos, como si fuera por Float#compare(float, float), en un índice relativo dentro de las matrices respectivas que es la longitud del prefijo. De lo contrario, una matriz es un prefijo adecuado del otro y, la comparación lexicográfica es el resultado de comparar las dos longitudes de intervalo. (Consulte #mismatch(float[], int, int, float[], int, int) la definición de un prefijo común y adecuado).

La comparación es coherente con #equals(float[], int, int, float[], int, int) equals, más concretamente las siguientes suspensiones para matrices a y b con intervalos especificados [aFromIndex, aToIndex) y [bFromIndex, bToIndex) respectivamente:

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

Agregado en 9.

Java documentación para java.util.Arrays.compare(.*float[], .*int, .*int, .*float[], .*int, .*int).

Las partes de esta página son modificaciones basadas en el trabajo creado y compartido por el Android y se usan según los términos descritos en creative Creative Commons 2.5 Attribution License.

Se aplica a

Compare(Boolean[], Int32, Int32, Boolean[], Int32, Int32)

Compara dos boolean matrices lexicográficamente en los intervalos especificados.

[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

a: Boolean[]

la primera matriz que se va a comparar

aFromIndex: Int32

índice (inclusivo) del primer elemento de la primera matriz que se va a comparar.

aToIndex: Int32

índice (exclusivo) del último elemento de la primera matriz que se va a comparar

b: Boolean[]

la segunda matriz que se va a comparar

bFromIndex: Int32

índice (inclusivo) del primer elemento de la segunda matriz que se va a comparar.

bToIndex: Int32

índice (exclusivo) del último elemento de la segunda matriz que se va a comparar.

Devoluciones

Int32

Atributos: RegisterAttribute

Comentarios

Compara dos boolean matrices lexicográficamente en los intervalos especificados.

Si las dos matrices, en los intervalos especificados, comparten un prefijo común, la comparación lexicográfica es el resultado de comparar dos elementos, como si fuera por Boolean#compare(boolean, boolean), en un índice relativo dentro de las matrices respectivas que es la longitud del prefijo. De lo contrario, una matriz es un prefijo adecuado del otro y, la comparación lexicográfica es el resultado de comparar las dos longitudes de intervalo. (Consulte #mismatch(boolean[], int, int, boolean[], int, int) la definición de un prefijo común y adecuado).

La comparación es coherente con #equals(boolean[], int, int, boolean[], int, int) equals, más concretamente las siguientes suspensiones para matrices a y b con intervalos especificados [aFromIndex, aToIndex) y [bFromIndex, bToIndex) respectivamente:

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

Agregado en 9.

Java documentación para java.util.Arrays.compare(.*boolean[], .*int, .*int, .*boolean[], .*int, .*int).

Las partes de esta página son modificaciones basadas en el trabajo creado y compartido por el Android y se usan según los términos descritos en creative Creative Commons 2.5 Attribution License.

Se aplica a

Compare(Int32[], Int32, Int32, Int32[], Int32, Int32)

Compara dos int matrices lexicográficamente en los intervalos especificados.

[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

a: Int32[]

la primera matriz que se va a comparar

aFromIndex: Int32

índice (inclusivo) del primer elemento de la primera matriz que se va a comparar.

aToIndex: Int32

índice (exclusivo) del último elemento de la primera matriz que se va a comparar

b: Int32[]

la segunda matriz que se va a comparar

bFromIndex: Int32

índice (inclusivo) del primer elemento de la segunda matriz que se va a comparar.

bToIndex: Int32

índice (exclusivo) del último elemento de la segunda matriz que se va a comparar.

Devoluciones

Int32

Atributos: RegisterAttribute

Comentarios

Compara dos int matrices lexicográficamente en los intervalos especificados.

Si las dos matrices, en los intervalos especificados, comparten un prefijo común, la comparación lexicográfica es el resultado de comparar dos elementos, como si fuera por Integer#compare(int, int), en un índice relativo dentro de las matrices respectivas que es la longitud del prefijo. De lo contrario, una matriz es un prefijo adecuado del otro y, la comparación lexicográfica es el resultado de comparar las dos longitudes de intervalo. (Consulte #mismatch(int[], int, int, int[], int, int) la definición de un prefijo común y adecuado).

La comparación es coherente con #equals(int[], int, int, int[], int, int) equals, más concretamente las siguientes suspensiones para matrices a y b con intervalos especificados [aFromIndex, aToIndex) y [bFromIndex, bToIndex) respectivamente:

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

Agregado en 9.

Java documentación para java.util.Arrays.compare(.*int[], .*int, .*int, .*int[], .*int, .*int).

Las partes de esta página son modificaciones basadas en el trabajo creado y compartido por el Android y se usan según los términos descritos en creative Creative Commons 2.5 Attribution License.

Se aplica a

Compare(Object[], Int32, Int32, Object[], Int32, Int32)

Compara dos Object matrices lexicográficamente en los intervalos especificados.

[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

a: Object[]

la primera matriz que se va a comparar

aFromIndex: Int32

índice (inclusivo) del primer elemento de la primera matriz que se va a comparar.

aToIndex: Int32

índice (exclusivo) del último elemento de la primera matriz que se va a comparar

b: Object[]

la segunda matriz que se va a comparar

bFromIndex: Int32

índice (inclusivo) del primer elemento de la segunda matriz que se va a comparar.

bToIndex: Int32

índice (exclusivo) del último elemento de la segunda matriz que se va a comparar.

Devoluciones

Int32

Atributos: RegisterAttribute JavaTypeParametersAttribute

Comentarios

Compara dos Object matrices lexicográficamente en los intervalos especificados.

Si las dos matrices, en los intervalos especificados, comparten un prefijo común, la comparación lexicográfica es el resultado de comparar dos elementos de tipo T en un índice i relativo dentro de las matrices respectivas que son la longitud del prefijo, como si fuera:

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

De lo contrario, una matriz es un prefijo adecuado del otro y, la comparación lexicográfica es el resultado de comparar las dos longitudes de intervalo. (Consulte #mismatch(Object[], int, int, Object[], int, int) la definición de un prefijo común y adecuado).

La comparación es coherente con #equals(Object[], int, int, Object[], int, int) equals, más concretamente las siguientes suspensiones para matrices a y b con intervalos especificados [aFromIndex, atoIndex) y [bFromIndex, btoIndex) respectivamente:

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

Agregado en 9.

Java documentación para java.util.Arrays.compare(T[], int, int, T[], int, int).

Las partes de esta página son modificaciones basadas en el trabajo creado y compartido por el Android y se usan según los términos descritos en creative Creative Commons 2.5 Attribution License.

Se aplica a

Compare(Int32[], Int32[])

Compara dos int matrices lexicográficamente.

[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

a: Int32[]

la primera matriz que se va a comparar

b: Int32[]

la segunda matriz que se va a comparar

Devoluciones

Int32

valor 0 si la primera y segunda matriz son iguales y contienen los mismos elementos en el mismo orden; un valor menor que 0 si la primera matriz es lexicográficamente menor que la segunda matriz; y un valor mayor que si la primera matriz es lexicográficamente mayor que 0 la segunda matriz

Atributos: RegisterAttribute

Comentarios

Compara dos int matrices lexicográficamente.

Si las dos matrices comparten un prefijo común, la comparación lexicográfica es el resultado de comparar dos elementos, como si fuera por Integer#compare(int, int), en un índice dentro de las matrices respectivas que es la longitud del prefijo. De lo contrario, una matriz es un prefijo adecuado del otro y, la comparación lexicográfica es el resultado de comparar las dos longitudes de matriz. (Consulte #mismatch(int[], int[]) la definición de un prefijo común y adecuado).

Una null referencia de matriz se considera lexicográficamente menor que una referencia que nonull es de matriz. Dos null referencias de matriz se consideran iguales.

La comparación es coherente con #equals(int[], int[]) equals, más concretamente las siguientes suspensiones para matrices a y b:

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

Agregado en 9.

Java documentación para java.util.Arrays.compare(.*int[], .*int[]).

Las partes de esta página son modificaciones basadas en el trabajo creado y compartido por el Android y se usan según los términos descritos en creative Creative Commons 2.5 Attribution License.

Se aplica a

Compare(Single[], Single[])

Compara dos float matrices lexicográficamente.

[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

a: Single[]

la primera matriz que se va a comparar

b: Single[]

la segunda matriz que se va a comparar

Devoluciones

Int32

Atributos: RegisterAttribute

Comentarios

Compara dos float matrices lexicográficamente.

Si las dos matrices comparten un prefijo común, la comparación lexicográfica es el resultado de comparar dos elementos, como si fuera por Float#compare(float, float), en un índice dentro de las matrices respectivas que es la longitud del prefijo. De lo contrario, una matriz es un prefijo adecuado del otro y, la comparación lexicográfica es el resultado de comparar las dos longitudes de matriz. (Consulte #mismatch(float[], float[]) la definición de un prefijo común y adecuado).

Una null referencia de matriz se considera lexicográficamente menor que una referencia que nonull es de matriz. Dos null referencias de matriz se consideran iguales.

La comparación es coherente con #equals(float[], float[]) equals, más concretamente las siguientes suspensiones para matrices a y b:

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

Agregado en 9.

Java documentación para java.util.Arrays.compare(.*float[], .*float[]).

Las partes de esta página son modificaciones basadas en el trabajo creado y compartido por el Android y se usan según los términos descritos en creative Creative Commons 2.5 Attribution License.

Se aplica a

Compare(Int64[], Int64[])

Compara dos long matrices lexicográficamente.

[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

a: Int64[]

la primera matriz que se va a comparar

b: Int64[]

la segunda matriz que se va a comparar

Devoluciones

Int32

Atributos: RegisterAttribute

Comentarios

Compara dos long matrices lexicográficamente.

Si las dos matrices comparten un prefijo común, la comparación lexicográfica es el resultado de comparar dos elementos, como si fuera por Long#compare(long, long), en un índice dentro de las matrices respectivas que es la longitud del prefijo. De lo contrario, una matriz es un prefijo adecuado del otro y, la comparación lexicográfica es el resultado de comparar las dos longitudes de matriz. (Consulte #mismatch(long[], long[]) la definición de un prefijo común y adecuado).

Una null referencia de matriz se considera lexicográficamente menor que una referencia que nonull es de matriz. Dos null referencias de matriz se consideran iguales.

La comparación es coherente con #equals(long[], long[]) equals, más concretamente las siguientes suspensiones para matrices a y b:

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

Agregado en 9.

Java documentación para java.util.Arrays.compare(.*long[], .*long[]).

Las partes de esta página son modificaciones basadas en el trabajo creado y compartido por el Android y se usan según los términos descritos en creative Creative Commons 2.5 Attribution License.

Se aplica a

Compare(Int16[], Int16[])

Compara dos short matrices lexicográficamente.

[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

a: Int16[]

la primera matriz que se va a comparar

b: Int16[]

la segunda matriz que se va a comparar

Devoluciones

Int32

Atributos: RegisterAttribute

Comentarios

Compara dos short matrices lexicográficamente.

Si las dos matrices comparten un prefijo común, la comparación lexicográfica es el resultado de comparar dos elementos, como si fuera por Short#compare(short, short), en un índice dentro de las matrices respectivas que es la longitud del prefijo. De lo contrario, una matriz es un prefijo adecuado del otro y, la comparación lexicográfica es el resultado de comparar las dos longitudes de matriz. (Consulte #mismatch(short[], short[]) la definición de un prefijo común y adecuado).

Una null referencia de matriz se considera lexicográficamente menor que una referencia que nonull es de matriz. Dos null referencias de matriz se consideran iguales.

La comparación es coherente con #equals(short[], short[]) equals, más concretamente las siguientes suspensiones para matrices a y b:

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

Agregado en 9.

Java documentación para java.util.Arrays.compare(.*short[], .*short[]).

Las partes de esta página son modificaciones basadas en el trabajo creado y compartido por el Android y se usan según los términos descritos en creative Creative Commons 2.5 Attribution License.

Se aplica a

Compare(Double[], Double[])

Compara dos double matrices lexicográficamente.

[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

a: Double[]

la primera matriz que se va a comparar

b: Double[]

la segunda matriz que se va a comparar

Devoluciones

Int32

Atributos: RegisterAttribute

Comentarios

Compara dos double matrices lexicográficamente.

Si las dos matrices comparten un prefijo común, la comparación lexicográfica es el resultado de comparar dos elementos, como si fuera por Double#compare(double, double), en un índice dentro de las matrices respectivas que es la longitud del prefijo. De lo contrario, una matriz es un prefijo adecuado del otro y, la comparación lexicográfica es el resultado de comparar las dos longitudes de matriz. (Consulte #mismatch(double[], double[]) la definición de un prefijo común y adecuado).

Una null referencia de matriz se considera lexicográficamente menor que una referencia que nonull es de matriz. Dos null referencias de matriz se consideran iguales.

La comparación es coherente con #equals(double[], double[]) equals, más concretamente las siguientes suspensiones para matrices a y b:

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

Agregado en 9.

Java documentación para java.util.Arrays.compare(.*double[], .*double[]).

Las partes de esta página son modificaciones basadas en el trabajo creado y compartido por el Android y se usan según los términos descritos en creative Creative Commons 2.5 Attribution License.

Se aplica a

Compare(Char[], Char[])

Compara dos char matrices lexicográficamente.

[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

a: Char[]

la primera matriz que se va a comparar

b: Char[]

la segunda matriz que se va a comparar

Devoluciones

Int32

Atributos: RegisterAttribute

Comentarios

Compara dos char matrices lexicográficamente.

Si las dos matrices comparten un prefijo común, la comparación lexicográfica es el resultado de comparar dos elementos, como si fuera por Character#compare(char, char), en un índice dentro de las matrices respectivas que es la longitud del prefijo. De lo contrario, una matriz es un prefijo adecuado del otro y, la comparación lexicográfica es el resultado de comparar las dos longitudes de matriz. (Consulte #mismatch(char[], char[]) la definición de un prefijo común y adecuado).

Una null referencia de matriz se considera lexicográficamente menor que una referencia que nonull es de matriz. Dos null referencias de matriz se consideran iguales.

La comparación es coherente con #equals(char[], char[]) equals, más concretamente las siguientes suspensiones para matrices a y b:

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

Agregado en 9.

Java documentación para java.util.Arrays.compare(.*char[], .*char[]).

Las partes de esta página son modificaciones basadas en el trabajo creado y compartido por el Android y se usan según los términos descritos en creative Creative Commons 2.5 Attribution License.

Se aplica a

Compare(Byte[], Byte[])

Compara dos byte matrices lexicográficamente.

[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

a: Byte[]

la primera matriz que se va a comparar

b: Byte[]

la segunda matriz que se va a comparar

Devoluciones

Int32

Atributos: RegisterAttribute

Comentarios

Compara dos byte matrices lexicográficamente.

Si las dos matrices comparten un prefijo común, la comparación lexicográfica es el resultado de comparar dos elementos, como si fuera por Byte#compare(byte, byte), en un índice dentro de las matrices respectivas que es la longitud del prefijo. De lo contrario, una matriz es un prefijo adecuado del otro y, la comparación lexicográfica es el resultado de comparar las dos longitudes de matriz. (Consulte #mismatch(byte[], byte[]) la definición de un prefijo común y adecuado).

Una null referencia de matriz se considera lexicográficamente menor que una referencia que nonull es de matriz. Dos null referencias de matriz se consideran iguales.

La comparación es coherente con #equals(byte[], byte[]) equals, más concretamente las siguientes suspensiones para matrices a y b:

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

Agregado en 9.

Java documentación para java.util.Arrays.compare(.*byte[], .*byte[]).

Las partes de esta página son modificaciones basadas en el trabajo creado y compartido por el Android y se usan según los términos descritos en creative Creative Commons 2.5 Attribution License.

Se aplica a

Compare(Boolean[], Boolean[])

Compara dos boolean matrices lexicográficamente.

[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

a: Boolean[]

la primera matriz que se va a comparar

b: Boolean[]

la segunda matriz que se va a comparar

Devoluciones

Int32

Atributos: RegisterAttribute

Comentarios

Compara dos boolean matrices lexicográficamente.

Si las dos matrices comparten un prefijo común, la comparación lexicográfica es el resultado de comparar dos elementos, como si fuera por Boolean#compare(boolean, boolean), en un índice dentro de las matrices respectivas que es la longitud del prefijo. De lo contrario, una matriz es un prefijo adecuado del otro y, la comparación lexicográfica es el resultado de comparar las dos longitudes de matriz. (Consulte #mismatch(boolean[], boolean[]) la definición de un prefijo común y adecuado).

Una null referencia de matriz se considera lexicográficamente menor que una referencia que nonull es de matriz. Dos null referencias de matriz se consideran iguales.

La comparación es coherente con #equals(boolean[], boolean[]) equals, más concretamente las siguientes suspensiones para matrices a y b:

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

Agregado en 9.

Java documentación para java.util.Arrays.compare(.*boolean[], .*boolean[]).

Las partes de esta página son modificaciones basadas en el trabajo creado y compartido por el Android y se usan según los términos descritos en creative Creative Commons 2.5 Attribution License.

Se aplica a

Compare(Object[], Object[])

Compara dos Object matrices, dentro de elementos comparables, lexicográficamente.

[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

a: Object[]

la primera matriz que se va a comparar

b: Object[]

la segunda matriz que se va a comparar

Devoluciones

Int32

Atributos: RegisterAttribute JavaTypeParametersAttribute

Comentarios

Compara dos Object matrices, dentro de elementos comparables, lexicográficamente.

Si las dos matrices comparten un prefijo común, la comparación lexicográfica es el resultado de comparar dos elementos de tipo T en un índice i dentro de las matrices respectivas que son la longitud del prefijo, como si fuera:

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

De lo contrario, una matriz es un prefijo adecuado del otro y, la comparación lexicográfica es el resultado de comparar las dos longitudes de matriz. (Consulte #mismatch(Object[], Object[]) la definición de un prefijo común y adecuado).

Una null referencia de matriz se considera lexicográficamente menor que una referencia que nonull es de matriz. Dos null referencias de matriz se consideran iguales. Un null elemento de matriz se considera lexicográficamente menor que un elemento que nonull es de matriz. Dos null elementos de matriz se consideran iguales.

La comparación es coherente con #equals(Object[], Object[]) equals, más concretamente las siguientes suspensiones para matrices a y b:

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

Agregado en 9.

Java documentación para java.util.Arrays.compare(T[], T[]).

Las partes de esta página son modificaciones basadas en el trabajo creado y compartido por el Android y se usan según los términos descritos en creative Creative Commons 2.5 Attribution License.

Se aplica a

Compare(Object[], Object[], IComparator)

Compara dos Object matrices lexicográficamente mediante un comparador especificado.

[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

a: Object[]

la primera matriz que se va a comparar

b: Object[]

la segunda matriz que se va a comparar

cmp: IComparator

comparador para comparar elementos de matriz

Devoluciones

Int32

Atributos: RegisterAttribute JavaTypeParametersAttribute

Comentarios

Compara dos Object matrices lexicográficamente mediante un comparador especificado.

Si las dos matrices comparten un prefijo común, la comparación lexicográfica es el resultado de comparar con el comparador especificado dos elementos en un índice dentro de las matrices respectivas que es la longitud del prefijo. De lo contrario, una matriz es un prefijo adecuado del otro y, la comparación lexicográfica es el resultado de comparar las dos longitudes de matriz. (Consulte #mismatch(Object[], Object[]) la definición de un prefijo común y adecuado).

Una null referencia de matriz se considera lexicográficamente menor que una referencia que nonull es de matriz. Dos null referencias de matriz se consideran iguales.

Agregado en 9.

Java documentación para java.util.Arrays.compare(T[], T[], java.util.Comparator<? super T>).

Las partes de esta página son modificaciones basadas en el trabajo creado y compartido por el Android y se usan según los términos descritos en creative Creative Commons 2.5 Attribution License.

Se aplica a