Arrays.Mismatch Método

[Android.Runtime.Register("mismatch", "([Ljava/lang/Object;II[Ljava/lang/Object;IILjava/util/Comparator;)I", "", ApiSince=33)]
[Java.Interop.JavaTypeParameters(new System.String[] { "T" })]
public static int Mismatch(Java.Lang.Object[] a, int aFromIndex, int aToIndex, Java.Lang.Object[] b, int bFromIndex, int bToIndex, Java.Util.IComparator cmp);

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

Parâmetros

Retornos

o índice relativo da primeira incompatibilidade entre as duas matrizes nos intervalos especificados, caso contrário -1.

Atributos

RegisterAttribute JavaTypeParametersAttribute

Comentários

Localiza e retorna o índice relativo da primeira incompatibilidade entre duas Object matrizes nos intervalos especificados; caso contrário, retorne -1 se nenhuma incompatibilidade for encontrada. O índice estará no intervalo de 0 (inclusivo) até o comprimento (inclusivo) do intervalo menor.

Se as duas matrizes, nos intervalos especificados, compartilharem um prefixo comum, o índice relativo retornado será o comprimento do prefixo comum e, em seguida, haverá uma incompatibilidade entre os dois elementos nesse índice relativo dentro das respectivas matrizes. Se uma matriz for um prefixo adequado da outra, nos intervalos especificados, o índice relativo retornado será o comprimento do intervalo menor e o índice relativo será válido apenas para a matriz com o intervalo maior. Caso contrário, não há nenhuma incompatibilidade.

Duas matrizes nãonull- e b com intervalos especificados [aFromIndex, atoIndex) e [bFromIndex, btoIndex) respectivamente, compartilham um prefixo comum de comprimento pl se a expressão a seguir for a verdadeira:

{@code
                pl >= 0 &&
                pl < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex) &&
                Arrays.equals(a, aFromIndex, aFromIndex + pl, b, bFromIndex, bFromIndex + pl, cmp) &&
                cmp.compare(a[aFromIndex + pl], b[bFromIndex + pl]) != 0
            }

Observe que um tamanho de 0 prefixo comum indica que os primeiros elementos de cada matriz são incompatíveis.

Duas matrizes a nãonull- e b com intervalos especificados [aFromIndex, atoIndex) e [bFromIndex, btoIndex) respectivamente, compartilham um prefixo adequado se a expressão a seguir for verdadeira:

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

Adicionado em 9.

Documentação Java para java.util.Arrays.mismatch(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 Android Open Source Project e usadas de acordo com os termos descritos na Licença de Atribuição Creative Commons 2.5.

[Android.Runtime.Register("mismatch", "([FII[FII)I", "", ApiSince=33)]
public static int Mismatch(float[] a, int aFromIndex, int aToIndex, float[] b, int bFromIndex, int bToIndex);

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

Parâmetros

Retornos

o índice relativo da primeira incompatibilidade entre as duas matrizes nos intervalos especificados, caso contrário -1.

Atributos

RegisterAttribute

Comentários

Localiza e retorna o índice relativo da primeira incompatibilidade entre duas float matrizes nos intervalos especificados; caso contrário, retorne -1 se nenhuma incompatibilidade for encontrada. O índice estará no intervalo de 0 (inclusivo) até o comprimento (inclusivo) do intervalo menor.

Se as duas matrizes, nos intervalos especificados, compartilharem um prefixo comum, o índice relativo retornado será o comprimento do prefixo comum e, em seguida, haverá uma incompatibilidade entre os dois elementos nesse índice relativo dentro das respectivas matrizes. Se uma matriz for um prefixo adequado da outra, nos intervalos especificados, o índice relativo retornado será o comprimento do intervalo menor e o índice relativo será válido apenas para a matriz com o intervalo maior. Caso contrário, não há nenhuma incompatibilidade.

Duas matrizes nãonull- e b com intervalos especificados [aFromIndex, aToIndex) e [bFromIndex, bToIndex) respectivamente, compartilham um prefixo comum de comprimento pl se a expressão a seguir for a verdadeira:

{@code
                pl >= 0 &&
                pl < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex) &&
                Arrays.equals(a, aFromIndex, aFromIndex + pl, b, bFromIndex, bFromIndex + pl) &&
                Float.compare(a[aFromIndex + pl], b[bFromIndex + pl]) != 0
            }

Observe que um tamanho de 0 prefixo comum indica que os primeiros elementos de cada matriz são incompatíveis.

Duas matrizes a nãonull- e b com intervalos especificados [aFromIndex, aToIndex) e [bFromIndex, bToIndex) respectivamente, compartilham um prefixo adequado se a expressão a seguir for verdadeira:

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

Adicionado em 9.

Documentação Java para java.util.Arrays.mismatch(.*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("mismatch", "([JII[JII)I", "", ApiSince=33)]
public static int Mismatch(long[] a, int aFromIndex, int aToIndex, long[] b, int bFromIndex, int bToIndex);

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

Parâmetros

Retornos

o índice relativo da primeira incompatibilidade entre as duas matrizes nos intervalos especificados, caso contrário -1.

Atributos

RegisterAttribute

Comentários

Localiza e retorna o índice relativo da primeira incompatibilidade entre duas long matrizes nos intervalos especificados; caso contrário, retorne -1 se nenhuma incompatibilidade for encontrada. O índice estará no intervalo de 0 (inclusivo) até o comprimento (inclusivo) do intervalo menor.

Se as duas matrizes, nos intervalos especificados, compartilharem um prefixo comum, o índice relativo retornado será o comprimento do prefixo comum e, em seguida, haverá uma incompatibilidade entre os dois elementos nesse índice relativo dentro das respectivas matrizes. Se uma matriz for um prefixo adequado da outra, nos intervalos especificados, o índice relativo retornado será o comprimento do intervalo menor e o índice relativo será válido apenas para a matriz com o intervalo maior. Caso contrário, não há nenhuma incompatibilidade.

Duas matrizes nãonull- e b com intervalos especificados [aFromIndex, aToIndex) e [bFromIndex, bToIndex) respectivamente, compartilham um prefixo comum de comprimento pl se a expressão a seguir for a verdadeira:

{@code
                pl >= 0 &&
                pl < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex) &&
                Arrays.equals(a, aFromIndex, aFromIndex + pl, b, bFromIndex, bFromIndex + pl) &&
                a[aFromIndex + pl] != b[bFromIndex + pl]
            }

Observe que um tamanho de 0 prefixo comum indica que os primeiros elementos de cada matriz são incompatíveis.

Duas matrizes a nãonull- e b com intervalos especificados [aFromIndex, aToIndex) e [bFromIndex, bToIndex) respectivamente, compartilham um prefixo adequado se a expressão a seguir for verdadeira:

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

Adicionado em 9.

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

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.

[Android.Runtime.Register("mismatch", "([III[III)I", "", ApiSince=33)]
public static int Mismatch(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex);

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

Parâmetros

Retornos

o índice relativo da primeira incompatibilidade entre as duas matrizes nos intervalos especificados, caso contrário -1.

Atributos

RegisterAttribute

Comentários

Localiza e retorna o índice relativo da primeira incompatibilidade entre duas int matrizes nos intervalos especificados; caso contrário, retorne -1 se nenhuma incompatibilidade for encontrada. O índice estará no intervalo de 0 (inclusivo) até o comprimento (inclusivo) do intervalo menor.

Se as duas matrizes, nos intervalos especificados, compartilharem um prefixo comum, o índice relativo retornado será o comprimento do prefixo comum e, em seguida, haverá uma incompatibilidade entre os dois elementos nesse índice relativo dentro das respectivas matrizes. Se uma matriz for um prefixo adequado da outra, nos intervalos especificados, o índice relativo retornado será o comprimento do intervalo menor e o índice relativo será válido apenas para a matriz com o intervalo maior. Caso contrário, não há nenhuma incompatibilidade.

Duas matrizes nãonull- e b com intervalos especificados [aFromIndex, aToIndex) e [bFromIndex, bToIndex) respectivamente, compartilham um prefixo comum de comprimento pl se a expressão a seguir for a verdadeira:

{@code
                pl >= 0 &&
                pl < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex) &&
                Arrays.equals(a, aFromIndex, aFromIndex + pl, b, bFromIndex, bFromIndex + pl) &&
                a[aFromIndex + pl] != b[bFromIndex + pl]
            }

Observe que um tamanho de 0 prefixo comum indica que os primeiros elementos de cada matriz são incompatíveis.

Duas matrizes a nãonull- e b com intervalos especificados [aFromIndex, aToIndex) e [bFromIndex, bToIndex) respectivamente, compartilham um prefixo adequado se a expressão a seguir for verdadeira:

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

Adicionado em 9.

Documentação Java para java.util.Arrays.mismatch(.*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("mismatch", "([SII[SII)I", "", ApiSince=33)]
public static int Mismatch(short[] a, int aFromIndex, int aToIndex, short[] b, int bFromIndex, int bToIndex);

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

Parâmetros

Retornos

o índice relativo da primeira incompatibilidade entre as duas matrizes nos intervalos especificados, caso contrário -1.

Atributos

RegisterAttribute

Comentários

Localiza e retorna o índice relativo da primeira incompatibilidade entre duas short matrizes nos intervalos especificados; caso contrário, retorne -1 se nenhuma incompatibilidade for encontrada. O índice estará no intervalo de 0 (inclusivo) até o comprimento (inclusivo) do intervalo menor.

Se as duas matrizes, nos intervalos especificados, compartilharem um prefixo comum, o índice relativo retornado será o comprimento do prefixo comum e, em seguida, haverá uma incompatibilidade entre os dois elementos nesse índice relativo dentro das respectivas matrizes. Se uma matriz for um prefixo adequado da outra, nos intervalos especificados, o índice relativo retornado será o comprimento do intervalo menor e o índice relativo será válido apenas para a matriz com o intervalo maior. Caso contrário, não há nenhuma incompatibilidade.

Duas matrizes nãonull- e b com intervalos especificados [aFromIndex, aToIndex) e [bFromIndex, bToIndex) respectivamente, compartilham um prefixo comum de comprimento pl se a expressão a seguir for a verdadeira:

{@code
                pl >= 0 &&
                pl < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex) &&
                Arrays.equals(a, aFromIndex, aFromIndex + pl, b, bFromIndex, bFromIndex + pl) &&
                a[aFromIndex + pl] != b[bFromIndex + pl]
            }

Observe que um tamanho de 0 prefixo comum indica que os primeiros elementos de cada matriz são incompatíveis.

Duas matrizes a nãonull- e b com intervalos especificados [aFromIndex, aToIndex) e [bFromIndex, bToIndex) respectivamente, compartilham um prefixo adequado se a expressão a seguir for verdadeira:

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

Adicionado em 9.

Documentação Java para java.util.Arrays.mismatch(.*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("mismatch", "([DII[DII)I", "", ApiSince=33)]
public static int Mismatch(double[] a, int aFromIndex, int aToIndex, double[] b, int bFromIndex, int bToIndex);

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

Parâmetros

Retornos

o índice relativo da primeira incompatibilidade entre as duas matrizes nos intervalos especificados, caso contrário -1.

Atributos

RegisterAttribute

Comentários

Localiza e retorna o índice relativo da primeira incompatibilidade entre duas double matrizes nos intervalos especificados; caso contrário, retorne -1 se nenhuma incompatibilidade for encontrada. O índice estará no intervalo de 0 (inclusivo) até o comprimento (inclusivo) do intervalo menor.

Se as duas matrizes, nos intervalos especificados, compartilharem um prefixo comum, o índice relativo retornado será o comprimento do prefixo comum e, em seguida, haverá uma incompatibilidade entre os dois elementos nesse índice relativo dentro das respectivas matrizes. Se uma matriz for um prefixo adequado da outra, nos intervalos especificados, o índice relativo retornado será o comprimento do intervalo menor e o índice relativo será válido apenas para a matriz com o intervalo maior. Caso contrário, não há nenhuma incompatibilidade.

Duas matrizes nãonull- e b com intervalos especificados [aFromIndex, aToIndex) e [bFromIndex, bToIndex) respectivamente, compartilham um prefixo comum de comprimento pl se a expressão a seguir for a verdadeira:

{@code
                pl >= 0 &&
                pl < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex) &&
                Arrays.equals(a, aFromIndex, aFromIndex + pl, b, bFromIndex, bFromIndex + pl) &&
                Double.compare(a[aFromIndex + pl], b[bFromIndex + pl]) != 0
            }

Observe que um tamanho de 0 prefixo comum indica que os primeiros elementos de cada matriz são incompatíveis.

Duas matrizes a nãonull- e b com intervalos especificados [aFromIndex, aToIndex) e [bFromIndex, bToIndex) respectivamente, compartilham um prefixo adequado se a expressão a seguir for verdadeira:

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

Adicionado em 9.

Documentação Java para java.util.Arrays.mismatch(.*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("mismatch", "([CII[CII)I", "", ApiSince=33)]
public static int Mismatch(char[] a, int aFromIndex, int aToIndex, char[] b, int bFromIndex, int bToIndex);

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

Parâmetros

Retornos

o índice relativo da primeira incompatibilidade entre as duas matrizes nos intervalos especificados, caso contrário -1.

Atributos

RegisterAttribute

Comentários

Localiza e retorna o índice relativo da primeira incompatibilidade entre duas char matrizes nos intervalos especificados; caso contrário, retorne -1 se nenhuma incompatibilidade for encontrada. O índice estará no intervalo de 0 (inclusivo) até o comprimento (inclusivo) do intervalo menor.

Se as duas matrizes, nos intervalos especificados, compartilharem um prefixo comum, o índice relativo retornado será o comprimento do prefixo comum e, em seguida, haverá uma incompatibilidade entre os dois elementos nesse índice relativo dentro das respectivas matrizes. Se uma matriz for um prefixo adequado da outra, nos intervalos especificados, o índice relativo retornado será o comprimento do intervalo menor e o índice relativo será válido apenas para a matriz com o intervalo maior. Caso contrário, não há nenhuma incompatibilidade.

Duas matrizes nãonull- e b com intervalos especificados [aFromIndex, aToIndex) e [bFromIndex, bToIndex) respectivamente, compartilham um prefixo comum de comprimento pl se a expressão a seguir for a verdadeira:

{@code
                pl >= 0 &&
                pl < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex) &&
                Arrays.equals(a, aFromIndex, aFromIndex + pl, b, bFromIndex, bFromIndex + pl) &&
                a[aFromIndex + pl] != b[bFromIndex + pl]
            }

Observe que um tamanho de 0 prefixo comum indica que os primeiros elementos de cada matriz são incompatíveis.

Duas matrizes a nãonull- e b com intervalos especificados [aFromIndex, aToIndex) e [bFromIndex, bToIndex) respectivamente, compartilham um prefixo adequado se a expressão a seguir for verdadeira:

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

Adicionado em 9.

Documentação Java para java.util.Arrays.mismatch(.*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("mismatch", "([BII[BII)I", "", ApiSince=33)]
public static int Mismatch(byte[]? a, int aFromIndex, int aToIndex, byte[]? b, int bFromIndex, int bToIndex);

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

Parâmetros

Retornos

o índice relativo da primeira incompatibilidade entre as duas matrizes nos intervalos especificados, caso contrário -1.

Atributos

RegisterAttribute

Comentários

Localiza e retorna o índice relativo da primeira incompatibilidade entre duas byte matrizes nos intervalos especificados; caso contrário, retorne -1 se nenhuma incompatibilidade for encontrada. O índice estará no intervalo de 0 (inclusivo) até o comprimento (inclusivo) do intervalo menor.

Se as duas matrizes, nos intervalos especificados, compartilharem um prefixo comum, o índice relativo retornado será o comprimento do prefixo comum e, em seguida, haverá uma incompatibilidade entre os dois elementos nesse índice relativo dentro das respectivas matrizes. Se uma matriz for um prefixo adequado da outra, nos intervalos especificados, o índice relativo retornado será o comprimento do intervalo menor e o índice relativo será válido apenas para a matriz com o intervalo maior. Caso contrário, não há nenhuma incompatibilidade.

Duas matrizes nãonull- e b com intervalos especificados [aFromIndex, aToIndex) e [bFromIndex, bToIndex) respectivamente, compartilham um prefixo comum de comprimento pl se a expressão a seguir for a verdadeira:

{@code
                pl >= 0 &&
                pl < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex) &&
                Arrays.equals(a, aFromIndex, aFromIndex + pl, b, bFromIndex, bFromIndex + pl) &&
                a[aFromIndex + pl] != b[bFromIndex + pl]
            }

Observe que um tamanho de 0 prefixo comum indica que os primeiros elementos de cada matriz são incompatíveis.

Duas matrizes a nãonull- e b com intervalos especificados [aFromIndex, aToIndex) e [bFromIndex, bToIndex) respectivamente, compartilham um prefixo adequado se a expressão a seguir for verdadeira:

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

Adicionado em 9.

Documentação Java para java.util.Arrays.mismatch(.*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("mismatch", "([ZII[ZII)I", "", ApiSince=33)]
public static int Mismatch(bool[] a, int aFromIndex, int aToIndex, bool[] b, int bFromIndex, int bToIndex);

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

Parâmetros

Retornos

o índice relativo da primeira incompatibilidade entre as duas matrizes nos intervalos especificados, caso contrário -1.

Atributos

RegisterAttribute

Comentários

Localiza e retorna o índice relativo da primeira incompatibilidade entre duas boolean matrizes nos intervalos especificados; caso contrário, retorne -1 se nenhuma incompatibilidade for encontrada. O índice estará no intervalo de 0 (inclusivo) até o comprimento (inclusivo) do intervalo menor.

Se as duas matrizes, nos intervalos especificados, compartilharem um prefixo comum, o índice relativo retornado será o comprimento do prefixo comum e, em seguida, haverá uma incompatibilidade entre os dois elementos nesse índice relativo dentro das respectivas matrizes. Se uma matriz for um prefixo adequado da outra, nos intervalos especificados, o índice relativo retornado será o comprimento do intervalo menor e o índice relativo será válido apenas para a matriz com o intervalo maior. Caso contrário, não há nenhuma incompatibilidade.

Duas matrizes nãonull- e b com intervalos especificados [aFromIndex, aToIndex) e [bFromIndex, bToIndex) respectivamente, compartilham um prefixo comum de comprimento pl se a expressão a seguir for a verdadeira:

{@code
                pl >= 0 &&
                pl < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex) &&
                Arrays.equals(a, aFromIndex, aFromIndex + pl, b, bFromIndex, bFromIndex + pl) &&
                a[aFromIndex + pl] != b[bFromIndex + pl]
            }

Observe que um tamanho de 0 prefixo comum indica que os primeiros elementos de cada matriz são incompatíveis.

Duas matrizes a nãonull- e b com intervalos especificados [aFromIndex, aToIndex) e [bFromIndex, bToIndex) respectivamente, compartilham um prefixo adequado se a expressão a seguir for verdadeira:

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

Adicionado em 9.

Documentação Java para java.util.Arrays.mismatch(.*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("mismatch", "([Ljava/lang/Object;II[Ljava/lang/Object;II)I", "", ApiSince=33)]
public static int Mismatch(Java.Lang.Object[] a, int aFromIndex, int aToIndex, Java.Lang.Object[] b, int bFromIndex, int bToIndex);

[<Android.Runtime.Register("mismatch", "([Ljava/lang/Object;II[Ljava/lang/Object;II)I", "", ApiSince=33)>]
static member Mismatch : Java.Lang.Object[] * int * int * Java.Lang.Object[] * int * int -> int

Parâmetros

Retornos

o índice relativo da primeira incompatibilidade entre as duas matrizes nos intervalos especificados, caso contrário -1.

Atributos

RegisterAttribute

Comentários

Localiza e retorna o índice relativo da primeira incompatibilidade entre duas Object matrizes nos intervalos especificados; caso contrário, retorne -1 se nenhuma incompatibilidade for encontrada. O índice estará no intervalo de 0 (inclusivo) até o comprimento (inclusivo) do intervalo menor.

Se as duas matrizes, nos intervalos especificados, compartilharem um prefixo comum, o índice relativo retornado será o comprimento do prefixo comum e, em seguida, haverá uma incompatibilidade entre os dois elementos nesse índice relativo dentro das respectivas matrizes. Se uma matriz for um prefixo adequado da outra, nos intervalos especificados, o índice relativo retornado será o comprimento do intervalo menor e o índice relativo será válido apenas para a matriz com o intervalo maior. Caso contrário, não há nenhuma incompatibilidade.

Duas matrizes nãonull- e b com intervalos especificados [aFromIndex, atoIndex) e [bFromIndex, btoIndex) respectivamente, compartilham um prefixo comum de comprimento pl se a expressão a seguir for a verdadeira:

{@code
                pl >= 0 &&
                pl < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex) &&
                Arrays.equals(a, aFromIndex, aFromIndex + pl, b, bFromIndex, bFromIndex + pl) &&
                !Objects.equals(a[aFromIndex + pl], b[bFromIndex + pl])
            }

Observe que um tamanho de 0 prefixo comum indica que os primeiros elementos de cada matriz são incompatíveis.

Duas matrizes a nãonull- e b com intervalos especificados [aFromIndex, atoIndex) e [bFromIndex, btoIndex) respectivamente, compartilham um prefixo adequado se a expressão a seguir for verdadeira:

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

Adicionado em 9.

Documentação Java para java.util.Arrays.mismatch(java.lang.Object[], int, int, java.lang.Object[], 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("mismatch", "([F[F)I", "", ApiSince=33)]
public static int Mismatch(float[] a, float[] b);

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

Parâmetros

Retornos

o índice da primeira incompatibilidade entre as duas matrizes, caso contrário -1.

Atributos

RegisterAttribute

Comentários

Localiza e retorna o índice da primeira incompatibilidade entre duas float matrizes, caso contrário, retorne -1 se nenhuma incompatibilidade for encontrada. O índice estará no intervalo de 0 (inclusive) até o comprimento (inclusive) da matriz menor.

Se as duas matrizes compartilharem um prefixo comum, o índice retornado será o comprimento do prefixo comum e, a seguir, haverá uma incompatibilidade entre os dois elementos nesse índice dentro das respectivas matrizes. Se uma matriz for um prefixo adequado da outra, o índice retornado será o comprimento da matriz menor e o índice será válido apenas para a matriz maior. Caso contrário, não há nenhuma incompatibilidade.

Duas matrizes que nãonull são e bcompartilham um prefixo comum de comprimento pl se a expressão a seguir for a verdadeira:

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

Observe que um tamanho de 0 prefixo comum indica que os primeiros elementos de cada matriz são incompatíveis.

Duas matrizes que nãonull são e bcompartilham um prefixo adequado se a expressão a seguir for a verdadeira:

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

Adicionado em 9.

Documentação Java para java.util.Arrays.mismatch(.*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("mismatch", "([J[J)I", "", ApiSince=33)]
public static int Mismatch(long[] a, long[] b);

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

Parâmetros

Retornos

o índice da primeira incompatibilidade entre as duas matrizes, caso contrário -1.

Atributos

RegisterAttribute

Comentários

Localiza e retorna o índice da primeira incompatibilidade entre duas long matrizes, caso contrário, retorne -1 se nenhuma incompatibilidade for encontrada. O índice estará no intervalo de 0 (inclusive) até o comprimento (inclusive) da matriz menor.

Se as duas matrizes compartilharem um prefixo comum, o índice retornado será o comprimento do prefixo comum e, a seguir, haverá uma incompatibilidade entre os dois elementos nesse índice dentro das respectivas matrizes. Se uma matriz for um prefixo adequado da outra, o índice retornado será o comprimento da matriz menor e o índice será válido apenas para a matriz maior. Caso contrário, não há nenhuma incompatibilidade.

Duas matrizes que nãonull são e bcompartilham um prefixo comum de comprimento pl se a expressão a seguir for a verdadeira:

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

Observe que um tamanho de 0 prefixo comum indica que os primeiros elementos de cada matriz são incompatíveis.

Duas matrizes que nãonull são e bcompartilham um prefixo adequado se a expressão a seguir for a verdadeira:

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

Adicionado em 9.

Documentação Java para java.util.Arrays.mismatch(.*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("mismatch", "([I[I)I", "", ApiSince=33)]
public static int Mismatch(int[] a, int[] b);

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

Parâmetros

Retornos

o índice da primeira incompatibilidade entre as duas matrizes, caso contrário -1.

Atributos

RegisterAttribute

Comentários

Localiza e retorna o índice da primeira incompatibilidade entre duas int matrizes, caso contrário, retorne -1 se nenhuma incompatibilidade for encontrada. O índice estará no intervalo de 0 (inclusive) até o comprimento (inclusive) da matriz menor.

Se as duas matrizes compartilharem um prefixo comum, o índice retornado será o comprimento do prefixo comum e, a seguir, haverá uma incompatibilidade entre os dois elementos nesse índice dentro das respectivas matrizes. Se uma matriz for um prefixo adequado da outra, o índice retornado será o comprimento da matriz menor e o índice será válido apenas para a matriz maior. Caso contrário, não há nenhuma incompatibilidade.

Duas matrizes que nãonull são e bcompartilham um prefixo comum de comprimento pl se a expressão a seguir for a verdadeira:

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

Observe que um tamanho de 0 prefixo comum indica que os primeiros elementos de cada matriz são incompatíveis.

Duas matrizes que nãonull são e bcompartilham um prefixo adequado se a expressão a seguir for a verdadeira:

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

Adicionado em 9.

Documentação Java para java.util.Arrays.mismatch(.*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("mismatch", "([S[S)I", "", ApiSince=33)]
public static int Mismatch(short[] a, short[] b);

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

Parâmetros

Retornos

o índice da primeira incompatibilidade entre as duas matrizes, caso contrário -1.

Atributos

RegisterAttribute

Comentários

Localiza e retorna o índice da primeira incompatibilidade entre duas short matrizes, caso contrário, retorne -1 se nenhuma incompatibilidade for encontrada. O índice estará no intervalo de 0 (inclusive) até o comprimento (inclusive) da matriz menor.

Se as duas matrizes compartilharem um prefixo comum, o índice retornado será o comprimento do prefixo comum e, a seguir, haverá uma incompatibilidade entre os dois elementos nesse índice dentro das respectivas matrizes. Se uma matriz for um prefixo adequado da outra, o índice retornado será o comprimento da matriz menor e o índice será válido apenas para a matriz maior. Caso contrário, não há nenhuma incompatibilidade.

Duas matrizes que nãonull são e bcompartilham um prefixo comum de comprimento pl se a expressão a seguir for a verdadeira:

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

Observe que um tamanho de 0 prefixo comum indica que os primeiros elementos de cada matriz são incompatíveis.

Duas matrizes que nãonull são e bcompartilham um prefixo adequado se a expressão a seguir for a verdadeira:

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

Adicionado em 9.

Documentação Java para java.util.Arrays.mismatch(.*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("mismatch", "([D[D)I", "", ApiSince=33)]
public static int Mismatch(double[] a, double[] b);

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

Parâmetros

Retornos

o índice da primeira incompatibilidade entre as duas matrizes, caso contrário -1.

Atributos

RegisterAttribute

Comentários

Localiza e retorna o índice da primeira incompatibilidade entre duas double matrizes, caso contrário, retorne -1 se nenhuma incompatibilidade for encontrada. O índice estará no intervalo de 0 (inclusive) até o comprimento (inclusive) da matriz menor.

Se as duas matrizes compartilharem um prefixo comum, o índice retornado será o comprimento do prefixo comum e, a seguir, haverá uma incompatibilidade entre os dois elementos nesse índice dentro das respectivas matrizes. Se uma matriz for um prefixo adequado da outra, o índice retornado será o comprimento da matriz menor e o índice será válido apenas para a matriz maior. Caso contrário, não há nenhuma incompatibilidade.

Duas matrizes que nãonull são e bcompartilham um prefixo comum de comprimento pl se a expressão a seguir for a verdadeira:

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

Observe que um tamanho de 0 prefixo comum indica que os primeiros elementos de cada matriz são incompatíveis.

Duas matrizes que nãonull são e bcompartilham um prefixo adequado se a expressão a seguir for a verdadeira:

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

Adicionado em 9.

Documentação Java para java.util.Arrays.mismatch(.*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("mismatch", "([C[C)I", "", ApiSince=33)]
public static int Mismatch(char[] a, char[] b);

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

Parâmetros

Retornos

o índice da primeira incompatibilidade entre as duas matrizes, caso contrário -1.

Atributos

RegisterAttribute

Comentários

Localiza e retorna o índice da primeira incompatibilidade entre duas char matrizes, caso contrário, retorne -1 se nenhuma incompatibilidade for encontrada. O índice estará no intervalo de 0 (inclusive) até o comprimento (inclusive) da matriz menor.

Se as duas matrizes compartilharem um prefixo comum, o índice retornado será o comprimento do prefixo comum e, a seguir, haverá uma incompatibilidade entre os dois elementos nesse índice dentro das respectivas matrizes. Se uma matriz for um prefixo adequado da outra, o índice retornado será o comprimento da matriz menor e o índice será válido apenas para a matriz maior. Caso contrário, não há nenhuma incompatibilidade.

Duas matrizes que nãonull são e bcompartilham um prefixo comum de comprimento pl se a expressão a seguir for a verdadeira:

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

Observe que um tamanho de 0 prefixo comum indica que os primeiros elementos de cada matriz são incompatíveis.

Duas matrizes que nãonull são e bcompartilham um prefixo adequado se a expressão a seguir for a verdadeira:

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

Adicionado em 9.

Documentação Java para java.util.Arrays.mismatch(.*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("mismatch", "([B[B)I", "", ApiSince=33)]
public static int Mismatch(byte[] a, byte[] b);

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

Parâmetros

Retornos

o índice da primeira incompatibilidade entre as duas matrizes, caso contrário -1.

Atributos

RegisterAttribute

Comentários

Localiza e retorna o índice da primeira incompatibilidade entre duas byte matrizes, caso contrário, retorne -1 se nenhuma incompatibilidade for encontrada. O índice estará no intervalo de 0 (inclusive) até o comprimento (inclusive) da matriz menor.

Se as duas matrizes compartilharem um prefixo comum, o índice retornado será o comprimento do prefixo comum e, a seguir, haverá uma incompatibilidade entre os dois elementos nesse índice dentro das respectivas matrizes. Se uma matriz for um prefixo adequado da outra, o índice retornado será o comprimento da matriz menor e o índice será válido apenas para a matriz maior. Caso contrário, não há nenhuma incompatibilidade.

Duas matrizes que nãonull são e bcompartilham um prefixo comum de comprimento pl se a expressão a seguir for a verdadeira:

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

Observe que um tamanho de 0 prefixo comum indica que os primeiros elementos de cada matriz são incompatíveis.

Duas matrizes que nãonull são e bcompartilham um prefixo adequado se a expressão a seguir for a verdadeira:

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

Adicionado em 9.

Documentação Java para java.util.Arrays.mismatch(.*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("mismatch", "([Z[Z)I", "", ApiSince=33)]
public static int Mismatch(bool[] a, bool[] b);

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

Parâmetros

Retornos

o índice da primeira incompatibilidade entre as duas matrizes, caso contrário -1.

Atributos

RegisterAttribute

Comentários

Localiza e retorna o índice da primeira incompatibilidade entre duas boolean matrizes, caso contrário, retorne -1 se nenhuma incompatibilidade for encontrada. O índice estará no intervalo de 0 (inclusive) até o comprimento (inclusive) da matriz menor.

Se as duas matrizes compartilharem um prefixo comum, o índice retornado será o comprimento do prefixo comum e, a seguir, haverá uma incompatibilidade entre os dois elementos nesse índice dentro das respectivas matrizes. Se uma matriz for um prefixo adequado da outra, o índice retornado será o comprimento da matriz menor e o índice será válido apenas para a matriz maior. Caso contrário, não há nenhuma incompatibilidade.

Duas matrizes que nãonull são e bcompartilham um prefixo comum de comprimento pl se a expressão a seguir for a verdadeira:

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

Observe que um tamanho de 0 prefixo comum indica que os primeiros elementos de cada matriz são incompatíveis.

Duas matrizes que nãonull são e bcompartilham um prefixo adequado se a expressão a seguir for a verdadeira:

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

Adicionado em 9.

Documentação Java para java.util.Arrays.mismatch(.*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("mismatch", "([Ljava/lang/Object;[Ljava/lang/Object;)I", "", ApiSince=33)]
public static int Mismatch(Java.Lang.Object[] a, Java.Lang.Object[] b);

[<Android.Runtime.Register("mismatch", "([Ljava/lang/Object;[Ljava/lang/Object;)I", "", ApiSince=33)>]
static member Mismatch : Java.Lang.Object[] * Java.Lang.Object[] -> int

Parâmetros

Retornos

o índice da primeira incompatibilidade entre as duas matrizes, caso contrário -1.

Atributos

RegisterAttribute

Comentários

Localiza e retorna o índice da primeira incompatibilidade entre duas Object matrizes, caso contrário, retorne -1 se nenhuma incompatibilidade for encontrada. O índice estará no intervalo de 0 (inclusive) até o comprimento (inclusive) da matriz menor.

Se as duas matrizes compartilharem um prefixo comum, o índice retornado será o comprimento do prefixo comum e, a seguir, haverá uma incompatibilidade entre os dois elementos nesse índice dentro das respectivas matrizes. Se uma matriz for um prefixo adequado da outra, o índice retornado será o comprimento da matriz menor e o índice será válido apenas para a matriz maior. Caso contrário, não há nenhuma incompatibilidade.

Duas matrizes que nãonull são e bcompartilham um prefixo comum de comprimento pl se a expressão a seguir for a verdadeira:

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

Observe que um tamanho de 0 prefixo comum indica que os primeiros elementos de cada matriz são incompatíveis.

Duas matrizes que nãonull são e bcompartilham um prefixo adequado se a expressão a seguir for a verdadeira:

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

Adicionado em 9.

Documentação Java para java.util.Arrays.mismatch(java.lang.Object[], java.lang.Object[]).

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

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

Parâmetros

Retornos

o índice da primeira incompatibilidade entre as duas matrizes, caso contrário -1.

Atributos

RegisterAttribute JavaTypeParametersAttribute

Comentários

Localiza e retorna o índice da primeira incompatibilidade entre duas Object matrizes, caso contrário, retorne -1 se nenhuma incompatibilidade for encontrada. O índice estará no intervalo de 0 (inclusive) até o comprimento (inclusive) da matriz menor.

O comparador especificado é usado para determinar se dois elementos de matriz de cada matriz não são iguais.

Se as duas matrizes compartilharem um prefixo comum, o índice retornado será o comprimento do prefixo comum e, a seguir, haverá uma incompatibilidade entre os dois elementos nesse índice dentro das respectivas matrizes. Se uma matriz for um prefixo adequado da outra, o índice retornado será o comprimento da matriz menor e o índice será válido apenas para a matriz maior. Caso contrário, não há nenhuma incompatibilidade.

Duas matrizes que nãonull são e bcompartilham um prefixo comum de comprimento pl se a expressão a seguir for a verdadeira:

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

Observe que um tamanho de 0 prefixo comum indica que os primeiros elementos de cada matriz são incompatíveis.

Duas matrizes que nãonull são e bcompartilham um prefixo adequado se a expressão a seguir for a verdadeira:

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

Adicionado em 9.

Documentação Java para java.util.Arrays.mismatch(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.