Arrays.Compare Methode

[Android.Runtime.Register("compare", "([BII[BII)I", "", ApiSince=33)]
public static int Compare(byte[] a, int aFromIndex, int aToIndex, byte[] b, int bFromIndex, int bToIndex);

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

Parameter

Gibt zurück

der Wert 0 , wenn über den angegebenen Bereichen das erste und das zweite Array gleich sind und die gleichen Elemente in derselben Reihenfolge enthalten; ein Wert kleiner als 0 wenn, über die angegebenen Bereiche, das erste Array lexikalisch kleiner als das zweite Array ist; und ein Wert größer als 0 wenn, über die angegebenen Bereiche, ist das erste Array lexikalisch größer als das zweite Array.

Attribute

RegisterAttribute

Hinweise

Vergleicht zwei byte Arrays lexikalisch über den angegebenen Bereichen.

Wenn die beiden Arrays über den angegebenen Bereichen ein gemeinsames Präfix aufweisen, ist der lexikographische Vergleich das Ergebnis des Vergleichens zweier Elemente, wie durch Byte#compare(byte, byte), bei einem relativen Index innerhalb der jeweiligen Arrays, die die Länge des Präfixes ist. Andernfalls ist ein Array ein richtiges Präfix des anderen und lexikographische Vergleich ist das Ergebnis des Vergleichens der beiden Bereichslängen. (Siehe #mismatch(byte[], int, int, byte[], int, int) definition eines allgemeinen und richtigen Präfixes.)

Der Vergleich entspricht #equals(byte[], int, int, byte[], int, int) equals, genauer gesagt die folgenden Haltebereiche für Arrays a und b mit angegebenen Bereichen [aFromIndex, aToIndex) bzw. [bFromIndex, bToIndex):

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

Hinzugefügt in 9.

Java Dokumentation für java.util.Arrays.compare(.*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("compare", "([CII[CII)I", "", ApiSince=33)]
public static int Compare(char[] a, int aFromIndex, int aToIndex, char[] b, int bFromIndex, int bToIndex);

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

Parameter

Gibt zurück

der Wert 0 , wenn über den angegebenen Bereichen das erste und das zweite Array gleich sind und die gleichen Elemente in derselben Reihenfolge enthalten; ein Wert kleiner als 0 wenn, über die angegebenen Bereiche, das erste Array lexikalisch kleiner als das zweite Array ist; und ein Wert größer als 0 wenn, über die angegebenen Bereiche, ist das erste Array lexikalisch größer als das zweite Array.

Attribute

RegisterAttribute

Hinweise

Vergleicht zwei char Arrays lexikalisch über den angegebenen Bereichen.

Wenn die beiden Arrays über den angegebenen Bereichen ein gemeinsames Präfix aufweisen, ist der lexikographische Vergleich das Ergebnis des Vergleichens zweier Elemente, wie durch Character#compare(char, char), bei einem relativen Index innerhalb der jeweiligen Arrays, die die Länge des Präfixes ist. Andernfalls ist ein Array ein richtiges Präfix des anderen und lexikographische Vergleich ist das Ergebnis des Vergleichens der beiden Bereichslängen. (Siehe #mismatch(char[], int, int, char[], int, int) definition eines allgemeinen und richtigen Präfixes.)

Der Vergleich entspricht #equals(char[], int, int, char[], int, int) equals, genauer gesagt die folgenden Haltebereiche für Arrays a und b mit angegebenen Bereichen [aFromIndex, aToIndex) bzw. [bFromIndex, bToIndex):

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

Hinzugefügt in 9.

Java Dokumentation für java.util.Arrays.compare(.*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("compare", "([DII[DII)I", "", ApiSince=33)]
public static int Compare(double[] a, int aFromIndex, int aToIndex, double[] b, int bFromIndex, int bToIndex);

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

Parameter

Gibt zurück

der Wert 0 , wenn über den angegebenen Bereichen das erste und das zweite Array gleich sind und die gleichen Elemente in derselben Reihenfolge enthalten; ein Wert kleiner als 0 wenn, über die angegebenen Bereiche, das erste Array lexikalisch kleiner als das zweite Array ist; und ein Wert größer als 0 wenn, über die angegebenen Bereiche, ist das erste Array lexikalisch größer als das zweite Array.

Attribute

RegisterAttribute

Hinweise

Vergleicht zwei double Arrays lexikalisch über den angegebenen Bereichen.

Wenn die beiden Arrays über den angegebenen Bereichen ein gemeinsames Präfix aufweisen, ist der lexikographische Vergleich das Ergebnis des Vergleichens zweier Elemente, wie durch Double#compare(double, double), bei einem relativen Index innerhalb der jeweiligen Arrays, die die Länge des Präfixes ist. Andernfalls ist ein Array ein richtiges Präfix des anderen und lexikographische Vergleich ist das Ergebnis des Vergleichens der beiden Bereichslängen. (Siehe #mismatch(double[], int, int, double[], int, int) definition eines allgemeinen und richtigen Präfixes.)

Der Vergleich entspricht #equals(double[], int, int, double[], int, int) equals, genauer gesagt die folgenden Haltebereiche für Arrays a und b mit angegebenen Bereichen [aFromIndex, aToIndex) bzw. [bFromIndex, bToIndex):

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

Hinzugefügt in 9.

Java Dokumentation für java.util.Arrays.compare(.*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("compare", "([SII[SII)I", "", ApiSince=33)]
public static int Compare(short[] a, int aFromIndex, int aToIndex, short[] b, int bFromIndex, int bToIndex);

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

Parameter

Gibt zurück

der Wert 0 , wenn über den angegebenen Bereichen das erste und das zweite Array gleich sind und die gleichen Elemente in derselben Reihenfolge enthalten; ein Wert kleiner als 0 wenn, über die angegebenen Bereiche, das erste Array lexikalisch kleiner als das zweite Array ist; und ein Wert größer als 0 wenn, über die angegebenen Bereiche, ist das erste Array lexikalisch größer als das zweite Array.

Attribute

RegisterAttribute

Hinweise

Vergleicht zwei short Arrays lexikalisch über den angegebenen Bereichen.

Wenn die beiden Arrays über den angegebenen Bereichen ein gemeinsames Präfix aufweisen, ist der lexikographische Vergleich das Ergebnis des Vergleichens zweier Elemente, wie durch Short#compare(short, short), bei einem relativen Index innerhalb der jeweiligen Arrays, die die Länge des Präfixes ist. Andernfalls ist ein Array ein richtiges Präfix des anderen und lexikographische Vergleich ist das Ergebnis des Vergleichens der beiden Bereichslängen. (Siehe #mismatch(short[], int, int, short[], int, int) definition eines allgemeinen und richtigen Präfixes.)

Der Vergleich entspricht #equals(short[], int, int, short[], int, int) equals, genauer gesagt die folgenden Haltebereiche für Arrays a und b mit angegebenen Bereichen [aFromIndex, aToIndex) bzw. [bFromIndex, bToIndex):

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

Hinzugefügt in 9.

Java Dokumentation für java.util.Arrays.compare(.*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("compare", "([Ljava/lang/Object;II[Ljava/lang/Object;IILjava/util/Comparator;)I", "", ApiSince=33)]
[Java.Interop.JavaTypeParameters(new System.String[] { "T" })]
public static int Compare(Java.Lang.Object[] a, int aFromIndex, int aToIndex, Java.Lang.Object[] b, int bFromIndex, int bToIndex, Java.Util.IComparator cmp);

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

Parameter

Gibt zurück

der Wert 0 , wenn über den angegebenen Bereichen das erste und das zweite Array gleich sind und die gleichen Elemente in derselben Reihenfolge enthalten; ein Wert kleiner als 0 wenn, über die angegebenen Bereiche, das erste Array lexikalisch kleiner als das zweite Array ist; und ein Wert größer als 0 wenn, über die angegebenen Bereiche, ist das erste Array lexikalisch größer als das zweite Array.

Attribute

RegisterAttribute JavaTypeParametersAttribute

Hinweise

Vergleicht zwei Object Arrays lexikalisch über den angegebenen Bereichen.

Wenn die beiden Arrays über den angegebenen Bereichen ein gemeinsames Präfix aufweisen, ist der lexikographische Vergleich das Ergebnis des Vergleichs mit dem angegebenen Vergleichselement zwei Elemente an einem relativen Index innerhalb der jeweiligen Arrays, die die Präfixlänge darstellt. Andernfalls ist ein Array ein richtiges Präfix des anderen und lexikographische Vergleich ist das Ergebnis des Vergleichens der beiden Bereichslängen. (Siehe #mismatch(Object[], int, int, Object[], int, int) definition eines allgemeinen und richtigen Präfixes.)

Hinzugefügt in 9.

Java Dokumentation für java.util.Arrays.compare(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("compare", "([JII[JII)I", "", ApiSince=33)]
public static int Compare(long[] a, int aFromIndex, int aToIndex, long[] b, int bFromIndex, int bToIndex);

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

Parameter

Gibt zurück

der Wert 0 , wenn über den angegebenen Bereichen das erste und das zweite Array gleich sind und die gleichen Elemente in derselben Reihenfolge enthalten; ein Wert kleiner als 0 wenn, über die angegebenen Bereiche, das erste Array lexikalisch kleiner als das zweite Array ist; und ein Wert größer als 0 wenn, über die angegebenen Bereiche, ist das erste Array lexikalisch größer als das zweite Array.

Attribute

RegisterAttribute

Hinweise

Vergleicht zwei long Arrays lexikalisch über den angegebenen Bereichen.

Wenn die beiden Arrays über den angegebenen Bereichen ein gemeinsames Präfix aufweisen, ist der lexikographische Vergleich das Ergebnis des Vergleichens zweier Elemente, wie durch Long#compare(long, long), bei einem relativen Index innerhalb der jeweiligen Arrays, die die Länge des Präfixes ist. Andernfalls ist ein Array ein richtiges Präfix des anderen und lexikographische Vergleich ist das Ergebnis des Vergleichens der beiden Bereichslängen. (Siehe #mismatch(long[], int, int, long[], int, int) definition eines allgemeinen und richtigen Präfixes.)

Der Vergleich entspricht #equals(long[], int, int, long[], int, int) equals, genauer gesagt die folgenden Haltebereiche für Arrays a und b mit angegebenen Bereichen [aFromIndex, aToIndex) bzw. [bFromIndex, bToIndex):

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

Hinzugefügt in 9.

Java Dokumentation für java.util.Arrays.compare(.*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("compare", "([FII[FII)I", "", ApiSince=33)]
public static int Compare(float[] a, int aFromIndex, int aToIndex, float[] b, int bFromIndex, int bToIndex);

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

Parameter

Gibt zurück

der Wert 0 , wenn über den angegebenen Bereichen das erste und das zweite Array gleich sind und die gleichen Elemente in derselben Reihenfolge enthalten; ein Wert kleiner als 0 wenn, über die angegebenen Bereiche, das erste Array lexikalisch kleiner als das zweite Array ist; und ein Wert größer als 0 wenn, über die angegebenen Bereiche, ist das erste Array lexikalisch größer als das zweite Array.

Attribute

RegisterAttribute

Hinweise

Vergleicht zwei float Arrays lexikalisch über den angegebenen Bereichen.

Wenn die beiden Arrays über den angegebenen Bereichen ein gemeinsames Präfix aufweisen, ist der lexikographische Vergleich das Ergebnis des Vergleichens zweier Elemente, wie durch Float#compare(float, float), bei einem relativen Index innerhalb der jeweiligen Arrays, die die Länge des Präfixes ist. Andernfalls ist ein Array ein richtiges Präfix des anderen und lexikographische Vergleich ist das Ergebnis des Vergleichens der beiden Bereichslängen. (Siehe #mismatch(float[], int, int, float[], int, int) definition eines allgemeinen und richtigen Präfixes.)

Der Vergleich entspricht #equals(float[], int, int, float[], int, int) equals, genauer gesagt die folgenden Haltebereiche für Arrays a und b mit angegebenen Bereichen [aFromIndex, aToIndex) bzw. [bFromIndex, bToIndex):

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

Hinzugefügt in 9.

Java Dokumentation für java.util.Arrays.compare(.*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("compare", "([ZII[ZII)I", "", ApiSince=33)]
public static int Compare(bool[] a, int aFromIndex, int aToIndex, bool[] b, int bFromIndex, int bToIndex);

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

Parameter

Gibt zurück

der Wert 0 , wenn über den angegebenen Bereichen das erste und das zweite Array gleich sind und die gleichen Elemente in derselben Reihenfolge enthalten; ein Wert kleiner als 0 wenn, über die angegebenen Bereiche, das erste Array lexikalisch kleiner als das zweite Array ist; und ein Wert größer als 0 wenn, über die angegebenen Bereiche, ist das erste Array lexikalisch größer als das zweite Array.

Attribute

RegisterAttribute

Hinweise

Vergleicht zwei boolean Arrays lexikalisch über den angegebenen Bereichen.

Wenn die beiden Arrays über den angegebenen Bereichen ein gemeinsames Präfix aufweisen, ist der lexikographische Vergleich das Ergebnis des Vergleichens zweier Elemente, wie durch Boolean#compare(boolean, boolean), bei einem relativen Index innerhalb der jeweiligen Arrays, die die Länge des Präfixes ist. Andernfalls ist ein Array ein richtiges Präfix des anderen und lexikographische Vergleich ist das Ergebnis des Vergleichens der beiden Bereichslängen. (Siehe #mismatch(boolean[], int, int, boolean[], int, int) definition eines allgemeinen und richtigen Präfixes.)

Der Vergleich entspricht #equals(boolean[], int, int, boolean[], int, int) equals, genauer gesagt die folgenden Haltebereiche für Arrays a und b mit angegebenen Bereichen [aFromIndex, aToIndex) bzw. [bFromIndex, bToIndex):

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

Hinzugefügt in 9.

Java Dokumentation für java.util.Arrays.compare(.*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("compare", "([III[III)I", "", ApiSince=33)]
public static int Compare(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex);

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

Parameter

Gibt zurück

der Wert 0 , wenn über den angegebenen Bereichen das erste und das zweite Array gleich sind und die gleichen Elemente in derselben Reihenfolge enthalten; ein Wert kleiner als 0 wenn, über die angegebenen Bereiche, das erste Array lexikalisch kleiner als das zweite Array ist; und ein Wert größer als 0 wenn, über die angegebenen Bereiche, ist das erste Array lexikalisch größer als das zweite Array.

Attribute

RegisterAttribute

Hinweise

Vergleicht zwei int Arrays lexikalisch über den angegebenen Bereichen.

Wenn die beiden Arrays über den angegebenen Bereichen ein gemeinsames Präfix aufweisen, ist der lexikographische Vergleich das Ergebnis des Vergleichens zweier Elemente, wie durch Integer#compare(int, int), bei einem relativen Index innerhalb der jeweiligen Arrays, die die Länge des Präfixes ist. Andernfalls ist ein Array ein richtiges Präfix des anderen und lexikographische Vergleich ist das Ergebnis des Vergleichens der beiden Bereichslängen. (Siehe #mismatch(int[], int, int, int[], int, int) definition eines allgemeinen und richtigen Präfixes.)

Der Vergleich entspricht #equals(int[], int, int, int[], int, int) equals, genauer gesagt die folgenden Haltebereiche für Arrays a und b mit angegebenen Bereichen [aFromIndex, aToIndex) bzw. [bFromIndex, bToIndex):

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

Hinzugefügt in 9.

Java Dokumentation für java.util.Arrays.compare(.*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("compare", "([Ljava/lang/Comparable;II[Ljava/lang/Comparable;II)I", "", ApiSince=33)]
[Java.Interop.JavaTypeParameters(new System.String[] { "T extends java.lang.Comparable<? super T>" })]
public static int Compare(Java.Lang.Object[] a, int aFromIndex, int aToIndex, Java.Lang.Object[] b, int bFromIndex, int bToIndex);

[<Android.Runtime.Register("compare", "([Ljava/lang/Comparable;II[Ljava/lang/Comparable;II)I", "", ApiSince=33)>]
[<Java.Interop.JavaTypeParameters(new System.String[] { "T extends java.lang.Comparable<? super T>" })>]
static member Compare : Java.Lang.Object[] * int * int * Java.Lang.Object[] * int * int -> int

Parameter

Gibt zurück

der Wert 0 , wenn über den angegebenen Bereichen das erste und das zweite Array gleich sind und die gleichen Elemente in derselben Reihenfolge enthalten; ein Wert kleiner als 0 wenn, über die angegebenen Bereiche, das erste Array lexikalisch kleiner als das zweite Array ist; und ein Wert größer als 0 wenn, über die angegebenen Bereiche, ist das erste Array lexikalisch größer als das zweite Array.

Attribute

RegisterAttribute JavaTypeParametersAttribute

Hinweise

Vergleicht zwei Object Arrays lexikalisch über den angegebenen Bereichen.

Wenn die beiden Arrays über den angegebenen Bereichen ein gemeinsames Präfix aufweisen, ist der lexikographische Vergleich das Ergebnis des Vergleichs von zwei Elementen des Typs T in einem relativen Index i innerhalb der jeweiligen Arrays, die die Präfixlänge ist, wie durch:

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

Andernfalls ist ein Array ein richtiges Präfix des anderen und lexikographische Vergleich ist das Ergebnis des Vergleichens der beiden Bereichslängen. (Siehe #mismatch(Object[], int, int, Object[], int, int) definition eines allgemeinen und richtigen Präfixes.)

Der Vergleich entspricht #equals(Object[], int, int, Object[], int, int) equals, genauer gesagt die folgenden Haltebereiche für Arrays a und b mit angegebenen Bereichen [aFromIndex, atoIndex) bzw. [bFromIndex, btoIndex):

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

Hinzugefügt in 9.

Java Dokumentation für java.util.Arrays.compare(T[], int, int, T[], 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("compare", "([I[I)I", "", ApiSince=33)]
public static int Compare(int[]? a, int[]? b);

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

Parameter

Gibt zurück

der Wert 0 , wenn das erste und das zweite Array gleich sind und dieselben Elemente in derselben Reihenfolge enthalten; ein Wert kleiner als 0 wenn das erste Array lexikalisch kleiner als das zweite Array ist; und ein Wert größer als 0 wenn das erste Array lexikalisch größer als das zweite Array ist.

Attribute

RegisterAttribute

Hinweise

Vergleicht zwei int Arrays lexikalisch.

Wenn die beiden Arrays ein gemeinsames Präfix gemeinsam verwenden, ist der lexikographische Vergleich das Ergebnis des Vergleichens zweier Elemente, wie bei Integer#compare(int, int)einem Index innerhalb der jeweiligen Arrays, die die Präfixlänge ist. Andernfalls ist ein Array ein richtiges Präfix des anderen und lexikographische Vergleich ist das Ergebnis des Vergleichens der beiden Arraylängen. (Siehe #mismatch(int[], int[]) definition eines allgemeinen und richtigen Präfixes.)

Ein null Arrayverweis gilt als lexikalisch kleiner als ein Nicht-Array-Bezugnull . Zwei null Arrayverweise gelten als gleich.

Der Vergleich entspricht #equals(int[], int[]) equals, genauer gesagt die folgenden Haltebereiche für Arrays a und b:

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

Hinzugefügt in 9.

Java Dokumentation für java.util.Arrays.compare(.*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("compare", "([F[F)I", "", ApiSince=33)]
public static int Compare(float[]? a, float[]? b);

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

Parameter

Gibt zurück

der Wert 0 , wenn das erste und das zweite Array gleich sind und dieselben Elemente in derselben Reihenfolge enthalten; ein Wert kleiner als 0 wenn das erste Array lexikalisch kleiner als das zweite Array ist; und ein Wert größer als 0 wenn das erste Array lexikalisch größer als das zweite Array ist.

Attribute

RegisterAttribute

Hinweise

Vergleicht zwei float Arrays lexikalisch.

Wenn die beiden Arrays ein gemeinsames Präfix gemeinsam verwenden, ist der lexikographische Vergleich das Ergebnis des Vergleichens zweier Elemente, wie bei Float#compare(float, float)einem Index innerhalb der jeweiligen Arrays, die die Präfixlänge ist. Andernfalls ist ein Array ein richtiges Präfix des anderen und lexikographische Vergleich ist das Ergebnis des Vergleichens der beiden Arraylängen. (Siehe #mismatch(float[], float[]) definition eines allgemeinen und richtigen Präfixes.)

Ein null Arrayverweis gilt als lexikalisch kleiner als ein Nicht-Array-Bezugnull . Zwei null Arrayverweise gelten als gleich.

Der Vergleich entspricht #equals(float[], float[]) equals, genauer gesagt die folgenden Haltebereiche für Arrays a und b:

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

Hinzugefügt in 9.

Java Dokumentation für java.util.Arrays.compare(.*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("compare", "([J[J)I", "", ApiSince=33)]
public static int Compare(long[]? a, long[]? b);

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

Parameter

Gibt zurück

der Wert 0 , wenn das erste und das zweite Array gleich sind und dieselben Elemente in derselben Reihenfolge enthalten; ein Wert kleiner als 0 wenn das erste Array lexikalisch kleiner als das zweite Array ist; und ein Wert größer als 0 wenn das erste Array lexikalisch größer als das zweite Array ist.

Attribute

RegisterAttribute

Hinweise

Vergleicht zwei long Arrays lexikalisch.

Wenn die beiden Arrays ein gemeinsames Präfix gemeinsam verwenden, ist der lexikographische Vergleich das Ergebnis des Vergleichens zweier Elemente, wie bei Long#compare(long, long)einem Index innerhalb der jeweiligen Arrays, die die Präfixlänge ist. Andernfalls ist ein Array ein richtiges Präfix des anderen und lexikographische Vergleich ist das Ergebnis des Vergleichens der beiden Arraylängen. (Siehe #mismatch(long[], long[]) definition eines allgemeinen und richtigen Präfixes.)

Ein null Arrayverweis gilt als lexikalisch kleiner als ein Nicht-Array-Bezugnull . Zwei null Arrayverweise gelten als gleich.

Der Vergleich entspricht #equals(long[], long[]) equals, genauer gesagt die folgenden Haltebereiche für Arrays a und b:

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

Hinzugefügt in 9.

Java Dokumentation für java.util.Arrays.compare(.*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("compare", "([S[S)I", "", ApiSince=33)]
public static int Compare(short[]? a, short[]? b);

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

Parameter

Gibt zurück

der Wert 0 , wenn das erste und das zweite Array gleich sind und dieselben Elemente in derselben Reihenfolge enthalten; ein Wert kleiner als 0 wenn das erste Array lexikalisch kleiner als das zweite Array ist; und ein Wert größer als 0 wenn das erste Array lexikalisch größer als das zweite Array ist.

Attribute

RegisterAttribute

Hinweise

Vergleicht zwei short Arrays lexikalisch.

Wenn die beiden Arrays ein gemeinsames Präfix gemeinsam verwenden, ist der lexikographische Vergleich das Ergebnis des Vergleichens zweier Elemente, wie bei Short#compare(short, short)einem Index innerhalb der jeweiligen Arrays, die die Präfixlänge ist. Andernfalls ist ein Array ein richtiges Präfix des anderen und lexikographische Vergleich ist das Ergebnis des Vergleichens der beiden Arraylängen. (Siehe #mismatch(short[], short[]) definition eines allgemeinen und richtigen Präfixes.)

Ein null Arrayverweis gilt als lexikalisch kleiner als ein Nicht-Array-Bezugnull . Zwei null Arrayverweise gelten als gleich.

Der Vergleich entspricht #equals(short[], short[]) equals, genauer gesagt die folgenden Haltebereiche für Arrays a und b:

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

Hinzugefügt in 9.

Java Dokumentation für java.util.Arrays.compare(.*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("compare", "([D[D)I", "", ApiSince=33)]
public static int Compare(double[]? a, double[]? b);

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

Parameter

Gibt zurück

der Wert 0 , wenn das erste und das zweite Array gleich sind und dieselben Elemente in derselben Reihenfolge enthalten; ein Wert kleiner als 0 wenn das erste Array lexikalisch kleiner als das zweite Array ist; und ein Wert größer als 0 wenn das erste Array lexikalisch größer als das zweite Array ist.

Attribute

RegisterAttribute

Hinweise

Vergleicht zwei double Arrays lexikalisch.

Wenn die beiden Arrays ein gemeinsames Präfix gemeinsam verwenden, ist der lexikographische Vergleich das Ergebnis des Vergleichens zweier Elemente, wie bei Double#compare(double, double)einem Index innerhalb der jeweiligen Arrays, die die Präfixlänge ist. Andernfalls ist ein Array ein richtiges Präfix des anderen und lexikographische Vergleich ist das Ergebnis des Vergleichens der beiden Arraylängen. (Siehe #mismatch(double[], double[]) definition eines allgemeinen und richtigen Präfixes.)

Ein null Arrayverweis gilt als lexikalisch kleiner als ein Nicht-Array-Bezugnull . Zwei null Arrayverweise gelten als gleich.

Der Vergleich entspricht #equals(double[], double[]) equals, genauer gesagt die folgenden Haltebereiche für Arrays a und b:

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

Hinzugefügt in 9.

Java Dokumentation für java.util.Arrays.compare(.*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("compare", "([C[C)I", "", ApiSince=33)]
public static int Compare(char[]? a, char[]? b);

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

Parameter

Gibt zurück

der Wert 0 , wenn das erste und das zweite Array gleich sind und dieselben Elemente in derselben Reihenfolge enthalten; ein Wert kleiner als 0 wenn das erste Array lexikalisch kleiner als das zweite Array ist; und ein Wert größer als 0 wenn das erste Array lexikalisch größer als das zweite Array ist.

Attribute

RegisterAttribute

Hinweise

Vergleicht zwei char Arrays lexikalisch.

Wenn die beiden Arrays ein gemeinsames Präfix gemeinsam verwenden, ist der lexikographische Vergleich das Ergebnis des Vergleichens zweier Elemente, wie bei Character#compare(char, char)einem Index innerhalb der jeweiligen Arrays, die die Präfixlänge ist. Andernfalls ist ein Array ein richtiges Präfix des anderen und lexikographische Vergleich ist das Ergebnis des Vergleichens der beiden Arraylängen. (Siehe #mismatch(char[], char[]) definition eines allgemeinen und richtigen Präfixes.)

Ein null Arrayverweis gilt als lexikalisch kleiner als ein Nicht-Array-Bezugnull . Zwei null Arrayverweise gelten als gleich.

Der Vergleich entspricht #equals(char[], char[]) equals, genauer gesagt die folgenden Haltebereiche für Arrays a und b:

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

Hinzugefügt in 9.

Java Dokumentation für java.util.Arrays.compare(.*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("compare", "([B[B)I", "", ApiSince=33)]
public static int Compare(byte[]? a, byte[]? b);

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

Parameter

Gibt zurück

der Wert 0 , wenn das erste und das zweite Array gleich sind und dieselben Elemente in derselben Reihenfolge enthalten; ein Wert kleiner als 0 wenn das erste Array lexikalisch kleiner als das zweite Array ist; und ein Wert größer als 0 wenn das erste Array lexikalisch größer als das zweite Array ist.

Attribute

RegisterAttribute

Hinweise

Vergleicht zwei byte Arrays lexikalisch.

Wenn die beiden Arrays ein gemeinsames Präfix gemeinsam verwenden, ist der lexikographische Vergleich das Ergebnis des Vergleichens zweier Elemente, wie bei Byte#compare(byte, byte)einem Index innerhalb der jeweiligen Arrays, die die Präfixlänge ist. Andernfalls ist ein Array ein richtiges Präfix des anderen und lexikographische Vergleich ist das Ergebnis des Vergleichens der beiden Arraylängen. (Siehe #mismatch(byte[], byte[]) definition eines allgemeinen und richtigen Präfixes.)

Ein null Arrayverweis gilt als lexikalisch kleiner als ein Nicht-Array-Bezugnull . Zwei null Arrayverweise gelten als gleich.

Der Vergleich entspricht #equals(byte[], byte[]) equals, genauer gesagt die folgenden Haltebereiche für Arrays a und b:

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

Hinzugefügt in 9.

Java Dokumentation für java.util.Arrays.compare(.*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("compare", "([Z[Z)I", "", ApiSince=33)]
public static int Compare(bool[]? a, bool[]? b);

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

Parameter

Gibt zurück

der Wert 0 , wenn das erste und das zweite Array gleich sind und dieselben Elemente in derselben Reihenfolge enthalten; ein Wert kleiner als 0 wenn das erste Array lexikalisch kleiner als das zweite Array ist; und ein Wert größer als 0 wenn das erste Array lexikalisch größer als das zweite Array ist.

Attribute

RegisterAttribute

Hinweise

Vergleicht zwei boolean Arrays lexikalisch.

Wenn die beiden Arrays ein gemeinsames Präfix gemeinsam verwenden, ist der lexikographische Vergleich das Ergebnis des Vergleichens zweier Elemente, wie bei Boolean#compare(boolean, boolean)einem Index innerhalb der jeweiligen Arrays, die die Präfixlänge ist. Andernfalls ist ein Array ein richtiges Präfix des anderen und lexikographische Vergleich ist das Ergebnis des Vergleichens der beiden Arraylängen. (Siehe #mismatch(boolean[], boolean[]) definition eines allgemeinen und richtigen Präfixes.)

Ein null Arrayverweis gilt als lexikalisch kleiner als ein Nicht-Array-Bezugnull . Zwei null Arrayverweise gelten als gleich.

Der Vergleich entspricht #equals(boolean[], boolean[]) equals, genauer gesagt die folgenden Haltebereiche für Arrays a und b:

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

Hinzugefügt in 9.

Java Dokumentation für java.util.Arrays.compare(.*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("compare", "([Ljava/lang/Comparable;[Ljava/lang/Comparable;)I", "", ApiSince=33)]
[Java.Interop.JavaTypeParameters(new System.String[] { "T extends java.lang.Comparable<? super T>" })]
public static int Compare(Java.Lang.Object[]? a, Java.Lang.Object[]? b);

[<Android.Runtime.Register("compare", "([Ljava/lang/Comparable;[Ljava/lang/Comparable;)I", "", ApiSince=33)>]
[<Java.Interop.JavaTypeParameters(new System.String[] { "T extends java.lang.Comparable<? super T>" })>]
static member Compare : Java.Lang.Object[] * Java.Lang.Object[] -> int

Parameter

Gibt zurück

der Wert 0 , wenn das erste und das zweite Array gleich sind und dieselben Elemente in derselben Reihenfolge enthalten; ein Wert kleiner als 0 wenn das erste Array lexikalisch kleiner als das zweite Array ist; und ein Wert größer als 0 wenn das erste Array lexikalisch größer als das zweite Array ist.

Attribute

RegisterAttribute JavaTypeParametersAttribute

Hinweise

Vergleicht zwei Object Arrays innerhalb vergleichbarer Elemente lexikalisch.

Wenn die beiden Arrays ein gemeinsames Präfix aufweisen, ist der lexikographische Vergleich das Ergebnis des Vergleichs von zwei Elementen des Typs T an einem Index i innerhalb der jeweiligen Arrays, die die Präfixlänge darstellt, wie durch:

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

Andernfalls ist ein Array ein richtiges Präfix des anderen und lexikographische Vergleich ist das Ergebnis des Vergleichens der beiden Arraylängen. (Siehe #mismatch(Object[], Object[]) definition eines allgemeinen und richtigen Präfixes.)

Ein null Arrayverweis gilt als lexikalisch kleiner als ein Nicht-Array-Bezugnull . Zwei null Arrayverweise gelten als gleich. Ein null Arrayelement gilt lexikalisch weniger als ein Nicht-Array-Elementnull . Zwei null Arrayelemente gelten als gleich.

Der Vergleich entspricht #equals(Object[], Object[]) equals, genauer gesagt die folgenden Haltebereiche für Arrays a und b:

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

Hinzugefügt in 9.

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

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

Parameter

Gibt zurück

der Wert 0 , wenn das erste und das zweite Array gleich sind und dieselben Elemente in derselben Reihenfolge enthalten; ein Wert kleiner als 0 wenn das erste Array lexikalisch kleiner als das zweite Array ist; und ein Wert größer als 0 wenn das erste Array lexikalisch größer als das zweite Array ist.

Attribute

RegisterAttribute JavaTypeParametersAttribute

Hinweise

Vergleicht zwei Object Arrays lexikalisch unter Verwendung eines angegebenen Vergleichszeichens.

Wenn die beiden Arrays ein gemeinsames Präfix aufweisen, ist der lexikographische Vergleich das Ergebnis des Vergleichs mit dem angegebenen Vergleichselement zwei Elemente an einem Index innerhalb der jeweiligen Arrays, die die Präfixlänge darstellt. Andernfalls ist ein Array ein richtiges Präfix des anderen und lexikographische Vergleich ist das Ergebnis des Vergleichens der beiden Arraylängen. (Siehe #mismatch(Object[], Object[]) definition eines allgemeinen und richtigen Präfixes.)

Ein null Arrayverweis gilt als lexikalisch kleiner als ein Nicht-Array-Bezugnull . Zwei null Arrayverweise gelten als gleich.

Hinzugefügt in 9.

Java Dokumentation für java.util.Arrays.compare(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.