Arrays.Mismatch Methode

[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

Parameter

Gibt zurück

der relative Index des ersten Konflikts zwischen den beiden Arrays über den angegebenen Bereichen, andernfalls -1.

Attribute

RegisterAttribute JavaTypeParametersAttribute

Hinweise

Sucht und gibt den relativen Index der ersten Übereinstimmung zwischen zwei Object Arrays über den angegebenen Bereichen zurück, andernfalls wird -1 zurückgegeben, wenn keine Übereinstimmung gefunden wird. Der Index befindet sich im Bereich von 0 (einschließlich) bis zur Länge (einschließlich) des kleineren Bereichs.

Wenn die beiden Arrays über den angegebenen Bereichen ein gemeinsames Präfix gemeinsam verwenden, ist der zurückgegebene relative Index die Länge des gemeinsamen Präfixes und es folgt, dass zwischen den beiden Elementen in diesem relativen Index innerhalb der jeweiligen Arrays ein Konflikt besteht. Wenn ein Array ein richtiges Präfix des anderen ist, über die angegebenen Bereiche, ist der zurückgegebene relative Index die Länge des kleineren Bereichs und es folgt, dass der relative Index nur für das Array mit dem größeren Bereich gültig ist. Andernfalls gibt es keine Übereinstimmung.

Zwei Nicht-Arraysnull und b mit angegebenen Bereichen [aFromIndex, atoIndex) bzw. [bFromIndex, btoIndex) teilen ein gemeinsames a Präfix der Längepl, wenn der folgende Ausdruck wahr ist:

{@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
            }

Beachten Sie, dass eine allgemeine Präfixlänge 0 angibt, dass die ersten Elemente aus den einzelnen Arrays nicht übereinstimmen.

Zwei Nicht-Arraysnull und b mit angegebenen Bereichen [aFromIndex, atoIndex) bzw. [bFromIndex, btoIndex) geben ein richtiges a Präfix frei, wenn der folgende Ausdruck wahr ist:

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

Hinzugefügt in 9.

Java Dokumentation für java.util.Arrays.mismatch(T[], int, int, T[], int, int, java.util.Comparator<? super T>).

Teile dieser Seite sind Änderungen auf der Grundlage von Arbeiten, die von der Android Open Source Project erstellt und gemeinsam verwendet und gemäß den in der 2.5 Attribution License beschriebenen Begriffen verwendet werden.

[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

Parameter

Gibt zurück

der relative Index des ersten Konflikts zwischen den beiden Arrays über den angegebenen Bereichen, andernfalls -1.

Attribute

RegisterAttribute

Hinweise

Sucht und gibt den relativen Index der ersten Übereinstimmung zwischen zwei float Arrays über den angegebenen Bereichen zurück, andernfalls wird -1 zurückgegeben, wenn keine Übereinstimmung gefunden wird. Der Index befindet sich im Bereich von 0 (einschließlich) bis zur Länge (einschließlich) des kleineren Bereichs.

Wenn die beiden Arrays über den angegebenen Bereichen ein gemeinsames Präfix gemeinsam verwenden, ist der zurückgegebene relative Index die Länge des gemeinsamen Präfixes und es folgt, dass zwischen den beiden Elementen in diesem relativen Index innerhalb der jeweiligen Arrays ein Konflikt besteht. Wenn ein Array ein richtiges Präfix des anderen ist, über die angegebenen Bereiche, ist der zurückgegebene relative Index die Länge des kleineren Bereichs und es folgt, dass der relative Index nur für das Array mit dem größeren Bereich gültig ist. Andernfalls gibt es keine Übereinstimmung.

Zwei Nicht-Arraysnull und b mit angegebenen Bereichen [aFromIndex, aToIndex) bzw. [bFromIndex, bToIndex) teilen ein gemeinsames a Präfix der Längepl, wenn der folgende Ausdruck wahr ist:

{@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
            }

Beachten Sie, dass eine allgemeine Präfixlänge 0 angibt, dass die ersten Elemente aus den einzelnen Arrays nicht übereinstimmen.

Zwei Nicht-Arraysnull und b mit angegebenen Bereichen [aFromIndex, aToIndex) bzw. [bFromIndex, bToIndex) geben ein richtiges a Präfix frei, wenn der folgende Ausdruck wahr ist:

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

Hinzugefügt in 9.

Java Dokumentation für java.util.Arrays.mismatch(.*float[], .*int, .*int, .*float[], .*int, .*int).

Teile dieser Seite sind Änderungen auf der Grundlage von Arbeiten, die von der Android Open Source Project erstellt und gemeinsam verwendet und gemäß den in der 2.5 Attribution License beschriebenen Begriffen verwendet werden.

[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

Parameter

Gibt zurück

der relative Index des ersten Konflikts zwischen den beiden Arrays über den angegebenen Bereichen, andernfalls -1.

Attribute

RegisterAttribute

Hinweise

Sucht und gibt den relativen Index der ersten Übereinstimmung zwischen zwei long Arrays über den angegebenen Bereichen zurück, andernfalls wird -1 zurückgegeben, wenn keine Übereinstimmung gefunden wird. Der Index befindet sich im Bereich von 0 (einschließlich) bis zur Länge (einschließlich) des kleineren Bereichs.

Wenn die beiden Arrays über den angegebenen Bereichen ein gemeinsames Präfix gemeinsam verwenden, ist der zurückgegebene relative Index die Länge des gemeinsamen Präfixes und es folgt, dass zwischen den beiden Elementen in diesem relativen Index innerhalb der jeweiligen Arrays ein Konflikt besteht. Wenn ein Array ein richtiges Präfix des anderen ist, über die angegebenen Bereiche, ist der zurückgegebene relative Index die Länge des kleineren Bereichs und es folgt, dass der relative Index nur für das Array mit dem größeren Bereich gültig ist. Andernfalls gibt es keine Übereinstimmung.

Zwei Nicht-Arraysnull und b mit angegebenen Bereichen [aFromIndex, aToIndex) bzw. [bFromIndex, bToIndex) teilen ein gemeinsames a Präfix der Längepl, wenn der folgende Ausdruck wahr ist:

{@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]
            }

Beachten Sie, dass eine allgemeine Präfixlänge 0 angibt, dass die ersten Elemente aus den einzelnen Arrays nicht übereinstimmen.

Zwei Nicht-Arraysnull und b mit angegebenen Bereichen [aFromIndex, aToIndex) bzw. [bFromIndex, bToIndex) geben ein richtiges a Präfix frei, wenn der folgende Ausdruck wahr ist:

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

Hinzugefügt in 9.

Java Dokumentation für java.util.Arrays.mismatch(.*long[], .*int, .*int, .*long[], .*int, .*int).

Teile dieser Seite sind Änderungen auf der Grundlage von Arbeiten, die von der Android Open Source Project erstellt und gemeinsam verwendet und gemäß den in der 2.5 Attribution License beschriebenen Begriffen verwendet werden.

[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

Parameter

Gibt zurück

der relative Index des ersten Konflikts zwischen den beiden Arrays über den angegebenen Bereichen, andernfalls -1.

Attribute

RegisterAttribute

Hinweise

Sucht und gibt den relativen Index der ersten Übereinstimmung zwischen zwei int Arrays über den angegebenen Bereichen zurück, andernfalls wird -1 zurückgegeben, wenn keine Übereinstimmung gefunden wird. Der Index befindet sich im Bereich von 0 (einschließlich) bis zur Länge (einschließlich) des kleineren Bereichs.

Wenn die beiden Arrays über den angegebenen Bereichen ein gemeinsames Präfix gemeinsam verwenden, ist der zurückgegebene relative Index die Länge des gemeinsamen Präfixes und es folgt, dass zwischen den beiden Elementen in diesem relativen Index innerhalb der jeweiligen Arrays ein Konflikt besteht. Wenn ein Array ein richtiges Präfix des anderen ist, über die angegebenen Bereiche, ist der zurückgegebene relative Index die Länge des kleineren Bereichs und es folgt, dass der relative Index nur für das Array mit dem größeren Bereich gültig ist. Andernfalls gibt es keine Übereinstimmung.

Zwei Nicht-Arraysnull und b mit angegebenen Bereichen [aFromIndex, aToIndex) bzw. [bFromIndex, bToIndex) teilen ein gemeinsames a Präfix der Längepl, wenn der folgende Ausdruck wahr ist:

{@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]
            }

Beachten Sie, dass eine allgemeine Präfixlänge 0 angibt, dass die ersten Elemente aus den einzelnen Arrays nicht übereinstimmen.

Zwei Nicht-Arraysnull und b mit angegebenen Bereichen [aFromIndex, aToIndex) bzw. [bFromIndex, bToIndex) geben ein richtiges a Präfix frei, wenn der folgende Ausdruck wahr ist:

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

Hinzugefügt in 9.

Java Dokumentation für java.util.Arrays.mismatch(.*int[], .*int, .*int, .*int[], .*int, .*int).

Teile dieser Seite sind Änderungen auf der Grundlage von Arbeiten, die von der Android Open Source Project erstellt und gemeinsam verwendet und gemäß den in der 2.5 Attribution License beschriebenen Begriffen verwendet werden.

[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

Parameter

Gibt zurück

der relative Index des ersten Konflikts zwischen den beiden Arrays über den angegebenen Bereichen, andernfalls -1.

Attribute

RegisterAttribute

Hinweise

Sucht und gibt den relativen Index der ersten Übereinstimmung zwischen zwei short Arrays über den angegebenen Bereichen zurück, andernfalls wird -1 zurückgegeben, wenn keine Übereinstimmung gefunden wird. Der Index befindet sich im Bereich von 0 (einschließlich) bis zur Länge (einschließlich) des kleineren Bereichs.

Wenn die beiden Arrays über den angegebenen Bereichen ein gemeinsames Präfix gemeinsam verwenden, ist der zurückgegebene relative Index die Länge des gemeinsamen Präfixes und es folgt, dass zwischen den beiden Elementen in diesem relativen Index innerhalb der jeweiligen Arrays ein Konflikt besteht. Wenn ein Array ein richtiges Präfix des anderen ist, über die angegebenen Bereiche, ist der zurückgegebene relative Index die Länge des kleineren Bereichs und es folgt, dass der relative Index nur für das Array mit dem größeren Bereich gültig ist. Andernfalls gibt es keine Übereinstimmung.

Zwei Nicht-Arraysnull und b mit angegebenen Bereichen [aFromIndex, aToIndex) bzw. [bFromIndex, bToIndex) teilen ein gemeinsames a Präfix der Längepl, wenn der folgende Ausdruck wahr ist:

{@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]
            }

Beachten Sie, dass eine allgemeine Präfixlänge 0 angibt, dass die ersten Elemente aus den einzelnen Arrays nicht übereinstimmen.

Zwei Nicht-Arraysnull und b mit angegebenen Bereichen [aFromIndex, aToIndex) bzw. [bFromIndex, bToIndex) geben ein richtiges a Präfix frei, wenn der folgende Ausdruck wahr ist:

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

Hinzugefügt in 9.

Java Dokumentation für java.util.Arrays.mismatch(.*short[], .*int, .*int, .*short[], .*int, .*int).

Teile dieser Seite sind Änderungen auf der Grundlage von Arbeiten, die von der Android Open Source Project erstellt und gemeinsam verwendet und gemäß den in der 2.5 Attribution License beschriebenen Begriffen verwendet werden.

[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

Parameter

Gibt zurück

der relative Index des ersten Konflikts zwischen den beiden Arrays über den angegebenen Bereichen, andernfalls -1.

Attribute

RegisterAttribute

Hinweise

Sucht und gibt den relativen Index der ersten Übereinstimmung zwischen zwei double Arrays über den angegebenen Bereichen zurück, andernfalls wird -1 zurückgegeben, wenn keine Übereinstimmung gefunden wird. Der Index befindet sich im Bereich von 0 (einschließlich) bis zur Länge (einschließlich) des kleineren Bereichs.

Wenn die beiden Arrays über den angegebenen Bereichen ein gemeinsames Präfix gemeinsam verwenden, ist der zurückgegebene relative Index die Länge des gemeinsamen Präfixes und es folgt, dass zwischen den beiden Elementen in diesem relativen Index innerhalb der jeweiligen Arrays ein Konflikt besteht. Wenn ein Array ein richtiges Präfix des anderen ist, über die angegebenen Bereiche, ist der zurückgegebene relative Index die Länge des kleineren Bereichs und es folgt, dass der relative Index nur für das Array mit dem größeren Bereich gültig ist. Andernfalls gibt es keine Übereinstimmung.

Zwei Nicht-Arraysnull und b mit angegebenen Bereichen [aFromIndex, aToIndex) bzw. [bFromIndex, bToIndex) teilen ein gemeinsames a Präfix der Längepl, wenn der folgende Ausdruck wahr ist:

{@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
            }

Beachten Sie, dass eine allgemeine Präfixlänge 0 angibt, dass die ersten Elemente aus den einzelnen Arrays nicht übereinstimmen.

Zwei Nicht-Arraysnull und b mit angegebenen Bereichen [aFromIndex, aToIndex) bzw. [bFromIndex, bToIndex) geben ein richtiges a Präfix frei, wenn der folgende Ausdruck wahr ist:

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

Hinzugefügt in 9.

Java Dokumentation für java.util.Arrays.mismatch(.*double[], .*int, .*int, .*double[], .*int, .*int).

Teile dieser Seite sind Änderungen auf der Grundlage von Arbeiten, die von der Android Open Source Project erstellt und gemeinsam verwendet und gemäß den in der 2.5 Attribution License beschriebenen Begriffen verwendet werden.

[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

Parameter

Gibt zurück

der relative Index des ersten Konflikts zwischen den beiden Arrays über den angegebenen Bereichen, andernfalls -1.

Attribute

RegisterAttribute

Hinweise

Sucht und gibt den relativen Index der ersten Übereinstimmung zwischen zwei char Arrays über den angegebenen Bereichen zurück, andernfalls wird -1 zurückgegeben, wenn keine Übereinstimmung gefunden wird. Der Index befindet sich im Bereich von 0 (einschließlich) bis zur Länge (einschließlich) des kleineren Bereichs.

Wenn die beiden Arrays über den angegebenen Bereichen ein gemeinsames Präfix gemeinsam verwenden, ist der zurückgegebene relative Index die Länge des gemeinsamen Präfixes und es folgt, dass zwischen den beiden Elementen in diesem relativen Index innerhalb der jeweiligen Arrays ein Konflikt besteht. Wenn ein Array ein richtiges Präfix des anderen ist, über die angegebenen Bereiche, ist der zurückgegebene relative Index die Länge des kleineren Bereichs und es folgt, dass der relative Index nur für das Array mit dem größeren Bereich gültig ist. Andernfalls gibt es keine Übereinstimmung.

Zwei Nicht-Arraysnull und b mit angegebenen Bereichen [aFromIndex, aToIndex) bzw. [bFromIndex, bToIndex) teilen ein gemeinsames a Präfix der Längepl, wenn der folgende Ausdruck wahr ist:

{@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]
            }

Beachten Sie, dass eine allgemeine Präfixlänge 0 angibt, dass die ersten Elemente aus den einzelnen Arrays nicht übereinstimmen.

Zwei Nicht-Arraysnull und b mit angegebenen Bereichen [aFromIndex, aToIndex) bzw. [bFromIndex, bToIndex) geben ein richtiges a Präfix frei, wenn der folgende Ausdruck wahr ist:

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

Hinzugefügt in 9.

Java Dokumentation für java.util.Arrays.mismatch(.*char[], .*int, .*int, .*char[], .*int, .*int).

Teile dieser Seite sind Änderungen auf der Grundlage von Arbeiten, die von der Android Open Source Project erstellt und gemeinsam verwendet und gemäß den in der 2.5 Attribution License beschriebenen Begriffen verwendet werden.

[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

Parameter

Gibt zurück

der relative Index des ersten Konflikts zwischen den beiden Arrays über den angegebenen Bereichen, andernfalls -1.

Attribute

RegisterAttribute

Hinweise

Sucht und gibt den relativen Index der ersten Übereinstimmung zwischen zwei byte Arrays über den angegebenen Bereichen zurück, andernfalls wird -1 zurückgegeben, wenn keine Übereinstimmung gefunden wird. Der Index befindet sich im Bereich von 0 (einschließlich) bis zur Länge (einschließlich) des kleineren Bereichs.

Wenn die beiden Arrays über den angegebenen Bereichen ein gemeinsames Präfix gemeinsam verwenden, ist der zurückgegebene relative Index die Länge des gemeinsamen Präfixes und es folgt, dass zwischen den beiden Elementen in diesem relativen Index innerhalb der jeweiligen Arrays ein Konflikt besteht. Wenn ein Array ein richtiges Präfix des anderen ist, über die angegebenen Bereiche, ist der zurückgegebene relative Index die Länge des kleineren Bereichs und es folgt, dass der relative Index nur für das Array mit dem größeren Bereich gültig ist. Andernfalls gibt es keine Übereinstimmung.

Zwei Nicht-Arraysnull und b mit angegebenen Bereichen [aFromIndex, aToIndex) bzw. [bFromIndex, bToIndex) teilen ein gemeinsames a Präfix der Längepl, wenn der folgende Ausdruck wahr ist:

{@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]
            }

Beachten Sie, dass eine allgemeine Präfixlänge 0 angibt, dass die ersten Elemente aus den einzelnen Arrays nicht übereinstimmen.

Zwei Nicht-Arraysnull und b mit angegebenen Bereichen [aFromIndex, aToIndex) bzw. [bFromIndex, bToIndex) geben ein richtiges a Präfix frei, wenn der folgende Ausdruck wahr ist:

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

Hinzugefügt in 9.

Java Dokumentation für java.util.Arrays.mismatch(.*byte[], .*int, .*int, .*byte[], .*int, .*int).

Teile dieser Seite sind Änderungen auf der Grundlage von Arbeiten, die von der Android Open Source Project erstellt und gemeinsam verwendet und gemäß den in der 2.5 Attribution License beschriebenen Begriffen verwendet werden.

[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

Parameter

Gibt zurück

der relative Index des ersten Konflikts zwischen den beiden Arrays über den angegebenen Bereichen, andernfalls -1.

Attribute

RegisterAttribute

Hinweise

Sucht und gibt den relativen Index der ersten Übereinstimmung zwischen zwei boolean Arrays über den angegebenen Bereichen zurück, andernfalls wird -1 zurückgegeben, wenn keine Übereinstimmung gefunden wird. Der Index befindet sich im Bereich von 0 (einschließlich) bis zur Länge (einschließlich) des kleineren Bereichs.

Wenn die beiden Arrays über den angegebenen Bereichen ein gemeinsames Präfix gemeinsam verwenden, ist der zurückgegebene relative Index die Länge des gemeinsamen Präfixes und es folgt, dass zwischen den beiden Elementen in diesem relativen Index innerhalb der jeweiligen Arrays ein Konflikt besteht. Wenn ein Array ein richtiges Präfix des anderen ist, über die angegebenen Bereiche, ist der zurückgegebene relative Index die Länge des kleineren Bereichs und es folgt, dass der relative Index nur für das Array mit dem größeren Bereich gültig ist. Andernfalls gibt es keine Übereinstimmung.

Zwei Nicht-Arraysnull und b mit angegebenen Bereichen [aFromIndex, aToIndex) bzw. [bFromIndex, bToIndex) teilen ein gemeinsames a Präfix der Längepl, wenn der folgende Ausdruck wahr ist:

{@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]
            }

Beachten Sie, dass eine allgemeine Präfixlänge 0 angibt, dass die ersten Elemente aus den einzelnen Arrays nicht übereinstimmen.

Zwei Nicht-Arraysnull und b mit angegebenen Bereichen [aFromIndex, aToIndex) bzw. [bFromIndex, bToIndex) geben ein richtiges a Präfix frei, wenn der folgende Ausdruck wahr ist:

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

Hinzugefügt in 9.

Java Dokumentation für java.util.Arrays.mismatch(.*boolean[], .*int, .*int, .*boolean[], .*int, .*int).

Teile dieser Seite sind Änderungen auf der Grundlage von Arbeiten, die von der Android Open Source Project erstellt und gemeinsam verwendet und gemäß den in der 2.5 Attribution License beschriebenen Begriffen verwendet werden.

[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

Parameter

Gibt zurück

der relative Index des ersten Konflikts zwischen den beiden Arrays über den angegebenen Bereichen, andernfalls -1.

Attribute

RegisterAttribute

Hinweise

Sucht und gibt den relativen Index der ersten Übereinstimmung zwischen zwei Object Arrays über den angegebenen Bereichen zurück, andernfalls wird -1 zurückgegeben, wenn keine Übereinstimmung gefunden wird. Der Index befindet sich im Bereich von 0 (einschließlich) bis zur Länge (einschließlich) des kleineren Bereichs.

Wenn die beiden Arrays über den angegebenen Bereichen ein gemeinsames Präfix gemeinsam verwenden, ist der zurückgegebene relative Index die Länge des gemeinsamen Präfixes und es folgt, dass zwischen den beiden Elementen in diesem relativen Index innerhalb der jeweiligen Arrays ein Konflikt besteht. Wenn ein Array ein richtiges Präfix des anderen ist, über die angegebenen Bereiche, ist der zurückgegebene relative Index die Länge des kleineren Bereichs und es folgt, dass der relative Index nur für das Array mit dem größeren Bereich gültig ist. Andernfalls gibt es keine Übereinstimmung.

Zwei Nicht-Arraysnull und b mit angegebenen Bereichen [aFromIndex, atoIndex) bzw. [bFromIndex, btoIndex) teilen ein gemeinsames a Präfix der Längepl, wenn der folgende Ausdruck wahr ist:

{@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])
            }

Beachten Sie, dass eine allgemeine Präfixlänge 0 angibt, dass die ersten Elemente aus den einzelnen Arrays nicht übereinstimmen.

Zwei Nicht-Arraysnull und b mit angegebenen Bereichen [aFromIndex, atoIndex) bzw. [bFromIndex, btoIndex) geben ein richtiges a Präfix frei, wenn der folgende Ausdruck wahr ist:

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

Hinzugefügt in 9.

Java Dokumentation für java.util.Arrays.mismatch(java.lang.Object[], int, int, java.lang.Object[], int, int).

Teile dieser Seite sind Änderungen auf der Grundlage von Arbeiten, die von der Android Open Source Project erstellt und gemeinsam verwendet und gemäß den in der 2.5 Attribution License beschriebenen Begriffen verwendet werden.

[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

Parameter

Gibt zurück

der Index des ersten Konflikts zwischen den beiden Arrays, andernfalls -1.

Attribute

RegisterAttribute

Hinweise

Sucht und gibt den Index des ersten Konflikts zwischen zwei float Arrays zurück, andernfalls wird -1 zurückgegeben, wenn keine Übereinstimmung gefunden wird. Der Index befindet sich im Bereich von 0 (einschließlich) bis zur Länge (einschließlich) des kleineren Arrays.

Wenn die beiden Arrays ein gemeinsames Präfix verwenden, ist der zurückgegebene Index die Länge des gemeinsamen Präfixes, und es folgt, dass zwischen den beiden Elementen in diesem Index innerhalb der jeweiligen Arrays ein Konflikt besteht. Wenn ein Array ein richtiges Präfix des anderen ist, ist der zurückgegebene Index die Länge des kleineren Arrays und es folgt, dass der Index nur für das größere Array gültig ist. Andernfalls gibt es keine Übereinstimmung.

Zwei Nicht-Arraysnull und b, teilen ein gemeinsames a Präfix der Längepl, wenn der folgende Ausdruck wahr ist:

{@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
            }

Beachten Sie, dass eine allgemeine Präfixlänge 0 angibt, dass die ersten Elemente aus den einzelnen Arrays nicht übereinstimmen.

Zwei Nicht-Arraysnull und b, geben ein richtiges Präfix frei, a wenn der folgende Ausdruck wahr ist:

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

Hinzugefügt in 9.

Java Dokumentation für java.util.Arrays.mismatch(.*float[], .*float[]).

Teile dieser Seite sind Änderungen auf der Grundlage von Arbeiten, die von der Android Open Source Project erstellt und gemeinsam verwendet und gemäß den in der 2.5 Attribution License beschriebenen Begriffen verwendet werden.

[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

Parameter

Gibt zurück

der Index des ersten Konflikts zwischen den beiden Arrays, andernfalls -1.

Attribute

RegisterAttribute

Hinweise

Sucht und gibt den Index des ersten Konflikts zwischen zwei long Arrays zurück, andernfalls wird -1 zurückgegeben, wenn keine Übereinstimmung gefunden wird. Der Index befindet sich im Bereich von 0 (einschließlich) bis zur Länge (einschließlich) des kleineren Arrays.

Wenn die beiden Arrays ein gemeinsames Präfix verwenden, ist der zurückgegebene Index die Länge des gemeinsamen Präfixes, und es folgt, dass zwischen den beiden Elementen in diesem Index innerhalb der jeweiligen Arrays ein Konflikt besteht. Wenn ein Array ein richtiges Präfix des anderen ist, ist der zurückgegebene Index die Länge des kleineren Arrays und es folgt, dass der Index nur für das größere Array gültig ist. Andernfalls gibt es keine Übereinstimmung.

Zwei Nicht-Arraysnull und b, teilen ein gemeinsames a Präfix der Längepl, wenn der folgende Ausdruck wahr ist:

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

Beachten Sie, dass eine allgemeine Präfixlänge 0 angibt, dass die ersten Elemente aus den einzelnen Arrays nicht übereinstimmen.

Zwei Nicht-Arraysnull und b, geben ein richtiges Präfix frei, a wenn der folgende Ausdruck wahr ist:

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

Hinzugefügt in 9.

Java Dokumentation für java.util.Arrays.mismatch(.*long[], .*long[]).

Teile dieser Seite sind Änderungen auf der Grundlage von Arbeiten, die von der Android Open Source Project erstellt und gemeinsam verwendet und gemäß den in der 2.5 Attribution License beschriebenen Begriffen verwendet werden.

[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

Parameter

Gibt zurück

der Index des ersten Konflikts zwischen den beiden Arrays, andernfalls -1.

Attribute

RegisterAttribute

Hinweise

Sucht und gibt den Index des ersten Konflikts zwischen zwei int Arrays zurück, andernfalls wird -1 zurückgegeben, wenn keine Übereinstimmung gefunden wird. Der Index befindet sich im Bereich von 0 (einschließlich) bis zur Länge (einschließlich) des kleineren Arrays.

Wenn die beiden Arrays ein gemeinsames Präfix verwenden, ist der zurückgegebene Index die Länge des gemeinsamen Präfixes, und es folgt, dass zwischen den beiden Elementen in diesem Index innerhalb der jeweiligen Arrays ein Konflikt besteht. Wenn ein Array ein richtiges Präfix des anderen ist, ist der zurückgegebene Index die Länge des kleineren Arrays und es folgt, dass der Index nur für das größere Array gültig ist. Andernfalls gibt es keine Übereinstimmung.

Zwei Nicht-Arraysnull und b, teilen ein gemeinsames a Präfix der Längepl, wenn der folgende Ausdruck wahr ist:

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

Beachten Sie, dass eine allgemeine Präfixlänge 0 angibt, dass die ersten Elemente aus den einzelnen Arrays nicht übereinstimmen.

Zwei Nicht-Arraysnull und b, geben ein richtiges Präfix frei, a wenn der folgende Ausdruck wahr ist:

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

Hinzugefügt in 9.

Java Dokumentation für java.util.Arrays.mismatch(.*int[], .*int[]).

Teile dieser Seite sind Änderungen auf der Grundlage von Arbeiten, die von der Android Open Source Project erstellt und gemeinsam verwendet und gemäß den in der 2.5 Attribution License beschriebenen Begriffen verwendet werden.

[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

Parameter

Gibt zurück

der Index des ersten Konflikts zwischen den beiden Arrays, andernfalls -1.

Attribute

RegisterAttribute

Hinweise

Sucht und gibt den Index des ersten Konflikts zwischen zwei short Arrays zurück, andernfalls wird -1 zurückgegeben, wenn keine Übereinstimmung gefunden wird. Der Index befindet sich im Bereich von 0 (einschließlich) bis zur Länge (einschließlich) des kleineren Arrays.

Wenn die beiden Arrays ein gemeinsames Präfix verwenden, ist der zurückgegebene Index die Länge des gemeinsamen Präfixes, und es folgt, dass zwischen den beiden Elementen in diesem Index innerhalb der jeweiligen Arrays ein Konflikt besteht. Wenn ein Array ein richtiges Präfix des anderen ist, ist der zurückgegebene Index die Länge des kleineren Arrays und es folgt, dass der Index nur für das größere Array gültig ist. Andernfalls gibt es keine Übereinstimmung.

Zwei Nicht-Arraysnull und b, teilen ein gemeinsames a Präfix der Längepl, wenn der folgende Ausdruck wahr ist:

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

Beachten Sie, dass eine allgemeine Präfixlänge 0 angibt, dass die ersten Elemente aus den einzelnen Arrays nicht übereinstimmen.

Zwei Nicht-Arraysnull und b, geben ein richtiges Präfix frei, a wenn der folgende Ausdruck wahr ist:

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

Hinzugefügt in 9.

Java Dokumentation für java.util.Arrays.mismatch(.*short[], .*short[]).

Teile dieser Seite sind Änderungen auf der Grundlage von Arbeiten, die von der Android Open Source Project erstellt und gemeinsam verwendet und gemäß den in der 2.5 Attribution License beschriebenen Begriffen verwendet werden.

[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

Parameter

Gibt zurück

der Index des ersten Konflikts zwischen den beiden Arrays, andernfalls -1.

Attribute

RegisterAttribute

Hinweise

Sucht und gibt den Index des ersten Konflikts zwischen zwei double Arrays zurück, andernfalls wird -1 zurückgegeben, wenn keine Übereinstimmung gefunden wird. Der Index befindet sich im Bereich von 0 (einschließlich) bis zur Länge (einschließlich) des kleineren Arrays.

Wenn die beiden Arrays ein gemeinsames Präfix verwenden, ist der zurückgegebene Index die Länge des gemeinsamen Präfixes, und es folgt, dass zwischen den beiden Elementen in diesem Index innerhalb der jeweiligen Arrays ein Konflikt besteht. Wenn ein Array ein richtiges Präfix des anderen ist, ist der zurückgegebene Index die Länge des kleineren Arrays und es folgt, dass der Index nur für das größere Array gültig ist. Andernfalls gibt es keine Übereinstimmung.

Zwei Nicht-Arraysnull und b, teilen ein gemeinsames a Präfix der Längepl, wenn der folgende Ausdruck wahr ist:

{@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
            }

Beachten Sie, dass eine allgemeine Präfixlänge 0 angibt, dass die ersten Elemente aus den einzelnen Arrays nicht übereinstimmen.

Zwei Nicht-Arraysnull und b, geben ein richtiges Präfix frei, a wenn der folgende Ausdruck wahr ist:

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

Hinzugefügt in 9.

Java Dokumentation für java.util.Arrays.mismatch(.*double[], .*double[]).

Teile dieser Seite sind Änderungen auf der Grundlage von Arbeiten, die von der Android Open Source Project erstellt und gemeinsam verwendet und gemäß den in der 2.5 Attribution License beschriebenen Begriffen verwendet werden.

[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

Parameter

Gibt zurück

der Index des ersten Konflikts zwischen den beiden Arrays, andernfalls -1.

Attribute

RegisterAttribute

Hinweise

Sucht und gibt den Index des ersten Konflikts zwischen zwei char Arrays zurück, andernfalls wird -1 zurückgegeben, wenn keine Übereinstimmung gefunden wird. Der Index befindet sich im Bereich von 0 (einschließlich) bis zur Länge (einschließlich) des kleineren Arrays.

Wenn die beiden Arrays ein gemeinsames Präfix verwenden, ist der zurückgegebene Index die Länge des gemeinsamen Präfixes, und es folgt, dass zwischen den beiden Elementen in diesem Index innerhalb der jeweiligen Arrays ein Konflikt besteht. Wenn ein Array ein richtiges Präfix des anderen ist, ist der zurückgegebene Index die Länge des kleineren Arrays und es folgt, dass der Index nur für das größere Array gültig ist. Andernfalls gibt es keine Übereinstimmung.

Zwei Nicht-Arraysnull und b, teilen ein gemeinsames a Präfix der Längepl, wenn der folgende Ausdruck wahr ist:

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

Beachten Sie, dass eine allgemeine Präfixlänge 0 angibt, dass die ersten Elemente aus den einzelnen Arrays nicht übereinstimmen.

Zwei Nicht-Arraysnull und b, geben ein richtiges Präfix frei, a wenn der folgende Ausdruck wahr ist:

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

Hinzugefügt in 9.

Java Dokumentation für java.util.Arrays.mismatch(.*char[], .*char[]).

Teile dieser Seite sind Änderungen auf der Grundlage von Arbeiten, die von der Android Open Source Project erstellt und gemeinsam verwendet und gemäß den in der 2.5 Attribution License beschriebenen Begriffen verwendet werden.

[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

Parameter

Gibt zurück

der Index des ersten Konflikts zwischen den beiden Arrays, andernfalls -1.

Attribute

RegisterAttribute

Hinweise

Sucht und gibt den Index des ersten Konflikts zwischen zwei byte Arrays zurück, andernfalls wird -1 zurückgegeben, wenn keine Übereinstimmung gefunden wird. Der Index befindet sich im Bereich von 0 (einschließlich) bis zur Länge (einschließlich) des kleineren Arrays.

Wenn die beiden Arrays ein gemeinsames Präfix verwenden, ist der zurückgegebene Index die Länge des gemeinsamen Präfixes, und es folgt, dass zwischen den beiden Elementen in diesem Index innerhalb der jeweiligen Arrays ein Konflikt besteht. Wenn ein Array ein richtiges Präfix des anderen ist, ist der zurückgegebene Index die Länge des kleineren Arrays und es folgt, dass der Index nur für das größere Array gültig ist. Andernfalls gibt es keine Übereinstimmung.

Zwei Nicht-Arraysnull und b, teilen ein gemeinsames a Präfix der Längepl, wenn der folgende Ausdruck wahr ist:

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

Beachten Sie, dass eine allgemeine Präfixlänge 0 angibt, dass die ersten Elemente aus den einzelnen Arrays nicht übereinstimmen.

Zwei Nicht-Arraysnull und b, geben ein richtiges Präfix frei, a wenn der folgende Ausdruck wahr ist:

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

Hinzugefügt in 9.

Java Dokumentation für java.util.Arrays.mismatch(.*byte[], .*byte[]).

Teile dieser Seite sind Änderungen auf der Grundlage von Arbeiten, die von der Android Open Source Project erstellt und gemeinsam verwendet und gemäß den in der 2.5 Attribution License beschriebenen Begriffen verwendet werden.

[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

Parameter

Gibt zurück

der Index des ersten Konflikts zwischen den beiden Arrays, andernfalls -1.

Attribute

RegisterAttribute

Hinweise

Sucht und gibt den Index des ersten Konflikts zwischen zwei boolean Arrays zurück, andernfalls wird -1 zurückgegeben, wenn keine Übereinstimmung gefunden wird. Der Index befindet sich im Bereich von 0 (einschließlich) bis zur Länge (einschließlich) des kleineren Arrays.

Wenn die beiden Arrays ein gemeinsames Präfix verwenden, ist der zurückgegebene Index die Länge des gemeinsamen Präfixes, und es folgt, dass zwischen den beiden Elementen in diesem Index innerhalb der jeweiligen Arrays ein Konflikt besteht. Wenn ein Array ein richtiges Präfix des anderen ist, ist der zurückgegebene Index die Länge des kleineren Arrays und es folgt, dass der Index nur für das größere Array gültig ist. Andernfalls gibt es keine Übereinstimmung.

Zwei Nicht-Arraysnull und b, teilen ein gemeinsames a Präfix der Längepl, wenn der folgende Ausdruck wahr ist:

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

Beachten Sie, dass eine allgemeine Präfixlänge 0 angibt, dass die ersten Elemente aus den einzelnen Arrays nicht übereinstimmen.

Zwei Nicht-Arraysnull und b, geben ein richtiges Präfix frei, a wenn der folgende Ausdruck wahr ist:

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

Hinzugefügt in 9.

Java Dokumentation für java.util.Arrays.mismatch(.*boolean[], .*boolean[]).

Teile dieser Seite sind Änderungen auf der Grundlage von Arbeiten, die von der Android Open Source Project erstellt und gemeinsam verwendet und gemäß den in der 2.5 Attribution License beschriebenen Begriffen verwendet werden.

[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

Parameter

Gibt zurück

der Index des ersten Konflikts zwischen den beiden Arrays, andernfalls -1.

Attribute

RegisterAttribute

Hinweise

Sucht und gibt den Index des ersten Konflikts zwischen zwei Object Arrays zurück, andernfalls wird -1 zurückgegeben, wenn keine Übereinstimmung gefunden wird. Der Index befindet sich im Bereich von 0 (einschließlich) bis zur Länge (einschließlich) des kleineren Arrays.

Wenn die beiden Arrays ein gemeinsames Präfix verwenden, ist der zurückgegebene Index die Länge des gemeinsamen Präfixes, und es folgt, dass zwischen den beiden Elementen in diesem Index innerhalb der jeweiligen Arrays ein Konflikt besteht. Wenn ein Array ein richtiges Präfix des anderen ist, ist der zurückgegebene Index die Länge des kleineren Arrays und es folgt, dass der Index nur für das größere Array gültig ist. Andernfalls gibt es keine Übereinstimmung.

Zwei Nicht-Arraysnull und b, teilen ein gemeinsames a Präfix der Längepl, wenn der folgende Ausdruck wahr ist:

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

Beachten Sie, dass eine allgemeine Präfixlänge 0 angibt, dass die ersten Elemente aus den einzelnen Arrays nicht übereinstimmen.

Zwei Nicht-Arraysnull und b, geben ein richtiges Präfix frei, a wenn der folgende Ausdruck wahr ist:

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

Hinzugefügt in 9.

Java Dokumentation für java.util.Arrays.mismatch(java.lang.Object[], java.lang.Object[]).

Teile dieser Seite sind Änderungen auf der Grundlage von Arbeiten, die von der Android Open Source Project erstellt und gemeinsam verwendet und gemäß den in der 2.5 Attribution License beschriebenen Begriffen verwendet werden.

[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

Parameter

Gibt zurück

der Index des ersten Konflikts zwischen den beiden Arrays, andernfalls -1.

Attribute

RegisterAttribute JavaTypeParametersAttribute

Hinweise

Sucht und gibt den Index des ersten Konflikts zwischen zwei Object Arrays zurück, andernfalls wird -1 zurückgegeben, wenn keine Übereinstimmung gefunden wird. Der Index befindet sich im Bereich von 0 (einschließlich) bis zur Länge (einschließlich) des kleineren Arrays.

Der angegebene Vergleich wird verwendet, um zu bestimmen, ob zwei Arrayelemente aus den einzelnen Arrays nicht gleich sind.

Wenn die beiden Arrays ein gemeinsames Präfix verwenden, ist der zurückgegebene Index die Länge des gemeinsamen Präfixes, und es folgt, dass zwischen den beiden Elementen in diesem Index innerhalb der jeweiligen Arrays ein Konflikt besteht. Wenn ein Array ein richtiges Präfix des anderen ist, ist der zurückgegebene Index die Länge des kleineren Arrays und es folgt, dass der Index nur für das größere Array gültig ist. Andernfalls gibt es keine Übereinstimmung.

Zwei Nicht-Arraysnull und b, teilen ein gemeinsames a Präfix der Längepl, wenn der folgende Ausdruck wahr ist:

{@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
            }

Beachten Sie, dass eine allgemeine Präfixlänge 0 angibt, dass die ersten Elemente aus den einzelnen Arrays nicht übereinstimmen.

Zwei Nicht-Arraysnull und b, geben ein richtiges Präfix frei, a wenn der folgende Ausdruck wahr ist:

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

Hinzugefügt in 9.

Java Dokumentation für java.util.Arrays.mismatch(T[], T[], java.util.Comparator<? super T>).

Teile dieser Seite sind Änderungen auf der Grundlage von Arbeiten, die von der Android Open Source Project erstellt und gemeinsam verwendet und gemäß den in der 2.5 Attribution License beschriebenen Begriffen verwendet werden.