Arrays.CompareUnsigned Method

Definition

Namespace:

Java.Util

Assembly:

Mono.Android.dll

Overloads

CompareUnsigned(Int64[], Int32, Int32, Int64[], Int32, Int32)	Compares two long arrays lexicographically over the specified ranges, numerically treating elements as unsigned.
CompareUnsigned(Int32[], Int32, Int32, Int32[], Int32, Int32)	Compares two int arrays lexicographically over the specified ranges, numerically treating elements as unsigned.
CompareUnsigned(Int16[], Int32, Int32, Int16[], Int32, Int32)	Compares two short arrays lexicographically over the specified ranges, numerically treating elements as unsigned.
CompareUnsigned(Byte[], Int32, Int32, Byte[], Int32, Int32)	Compares two byte arrays lexicographically over the specified ranges, numerically treating elements as unsigned.
CompareUnsigned(Int16[], Int16[])	Compares two short arrays lexicographically, numerically treating elements as unsigned.
CompareUnsigned(Int32[], Int32[])	Compares two int arrays lexicographically, numerically treating elements as unsigned.
CompareUnsigned(Byte[], Byte[])	Compares two byte arrays lexicographically, numerically treating elements as unsigned.
CompareUnsigned(Int64[], Int64[])	Compares two long arrays lexicographically, numerically treating elements as unsigned.

CompareUnsigned(Int64[], Int32, Int32, Int64[], Int32, Int32)

Compares two long arrays lexicographically over the specified ranges, numerically treating elements as unsigned.

[Android.Runtime.Register("compareUnsigned", "([JII[JII)I", "", ApiSince=33)]
public static int CompareUnsigned (long[] a, int aFromIndex, int aToIndex, long[] b, int bFromIndex, int bToIndex);

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

Parameters

a

Int64[]

the first array to compare

aFromIndex

Int32

the index (inclusive) of the first element in the first array to be compared

aToIndex

Int32

the index (exclusive) of the last element in the first array to be compared

b

Int64[]

the second array to compare

bFromIndex

Int32

the index (inclusive) of the first element in the second array to be compared

bToIndex

Int32

the index (exclusive) of the last element in the second array to be compared

Returns

Int32

the value 0 if, over the specified ranges, the first and second array are equal and contain the same elements in the same order; a value less than 0 if, over the specified ranges, the first array is lexicographically less than the second array; and a value greater than 0 if, over the specified ranges, the first array is lexicographically greater than the second array

Attributes

RegisterAttribute

Remarks

Compares two long arrays lexicographically over the specified ranges, numerically treating elements as unsigned.

If the two arrays, over the specified ranges, share a common prefix then the lexicographic comparison is the result of comparing two elements, as if by Long#compareUnsigned(long, long), at a relative index within the respective arrays that is the length of the prefix. Otherwise, one array is a proper prefix of the other and, lexicographic comparison is the result of comparing the two range lengths. (See #mismatch(long[], int, int, long[], int, int) for the definition of a common and proper prefix.)

Added in 9.

Java documentation for java.util.Arrays.compareUnsigned(long[], int, int, long[], int, int).

Portions of this page are modifications based on work created and shared by the Android Open Source Project and used according to terms described in the Creative Commons 2.5 Attribution License.

CompareUnsigned(Int32[], Int32, Int32, Int32[], Int32, Int32)

Compares two int arrays lexicographically over the specified ranges, numerically treating elements as unsigned.

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

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

Parameters

a

Int32[]

the first array to compare

aFromIndex

Int32

the index (inclusive) of the first element in the first array to be compared

aToIndex

Int32

the index (exclusive) of the last element in the first array to be compared

b

Int32[]

the second array to compare

bFromIndex

Int32

the index (inclusive) of the first element in the second array to be compared

bToIndex

Int32

the index (exclusive) of the last element in the second array to be compared

Returns

Int32

the value 0 if, over the specified ranges, the first and second array are equal and contain the same elements in the same order; a value less than 0 if, over the specified ranges, the first array is lexicographically less than the second array; and a value greater than 0 if, over the specified ranges, the first array is lexicographically greater than the second array

Attributes

RegisterAttribute

Remarks

Compares two int arrays lexicographically over the specified ranges, numerically treating elements as unsigned.

If the two arrays, over the specified ranges, share a common prefix then the lexicographic comparison is the result of comparing two elements, as if by Integer#compareUnsigned(int, int), at a relative index within the respective arrays that is the length of the prefix. Otherwise, one array is a proper prefix of the other and, lexicographic comparison is the result of comparing the two range lengths. (See #mismatch(int[], int, int, int[], int, int) for the definition of a common and proper prefix.)

Added in 9.

Java documentation for java.util.Arrays.compareUnsigned(int[], int, int, int[], int, int).

Portions of this page are modifications based on work created and shared by the Android Open Source Project and used according to terms described in the Creative Commons 2.5 Attribution License.

CompareUnsigned(Int16[], Int32, Int32, Int16[], Int32, Int32)

Compares two short arrays lexicographically over the specified ranges, numerically treating elements as unsigned.

[Android.Runtime.Register("compareUnsigned", "([SII[SII)I", "", ApiSince=33)]
public static int CompareUnsigned (short[] a, int aFromIndex, int aToIndex, short[] b, int bFromIndex, int bToIndex);

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

Parameters

a

Int16[]

the first array to compare

aFromIndex

Int32

the index (inclusive) of the first element in the first array to be compared

aToIndex

Int32

the index (exclusive) of the last element in the first array to be compared

b

Int16[]

the second array to compare

bFromIndex

Int32

the index (inclusive) of the first element in the second array to be compared

bToIndex

Int32

the index (exclusive) of the last element in the second array to be compared

Returns

Int32

the value 0 if, over the specified ranges, the first and second array are equal and contain the same elements in the same order; a value less than 0 if, over the specified ranges, the first array is lexicographically less than the second array; and a value greater than 0 if, over the specified ranges, the first array is lexicographically greater than the second array

Attributes

RegisterAttribute

Remarks

Compares two short arrays lexicographically over the specified ranges, numerically treating elements as unsigned.

If the two arrays, over the specified ranges, share a common prefix then the lexicographic comparison is the result of comparing two elements, as if by Short#compareUnsigned(short, short), at a relative index within the respective arrays that is the length of the prefix. Otherwise, one array is a proper prefix of the other and, lexicographic comparison is the result of comparing the two range lengths. (See #mismatch(short[], int, int, short[], int, int) for the definition of a common and proper prefix.)

Added in 9.

Java documentation for java.util.Arrays.compareUnsigned(short[], int, int, short[], int, int).

Portions of this page are modifications based on work created and shared by the Android Open Source Project and used according to terms described in the Creative Commons 2.5 Attribution License.

CompareUnsigned(Byte[], Int32, Int32, Byte[], Int32, Int32)

Compares two byte arrays lexicographically over the specified ranges, numerically treating elements as unsigned.

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

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

Parameters

a

Byte[]

the first array to compare

aFromIndex

Int32

the index (inclusive) of the first element in the first array to be compared

aToIndex

Int32

the index (exclusive) of the last element in the first array to be compared

b

Byte[]

the second array to compare

bFromIndex

Int32

the index (inclusive) of the first element in the second array to be compared

bToIndex

Int32

the index (exclusive) of the last element in the second array to be compared

Returns

Int32

the value 0 if, over the specified ranges, the first and second array are equal and contain the same elements in the same order; a value less than 0 if, over the specified ranges, the first array is lexicographically less than the second array; and a value greater than 0 if, over the specified ranges, the first array is lexicographically greater than the second array

Attributes

RegisterAttribute

Remarks

Compares two byte arrays lexicographically over the specified ranges, numerically treating elements as unsigned.

If the two arrays, over the specified ranges, share a common prefix then the lexicographic comparison is the result of comparing two elements, as if by Byte#compareUnsigned(byte, byte), at a relative index within the respective arrays that is the length of the prefix. Otherwise, one array is a proper prefix of the other and, lexicographic comparison is the result of comparing the two range lengths. (See #mismatch(byte[], int, int, byte[], int, int) for the definition of a common and proper prefix.)

Added in 9.

Java documentation for java.util.Arrays.compareUnsigned(byte[], int, int, byte[], int, int).

Portions of this page are modifications based on work created and shared by the Android Open Source Project and used according to terms described in the Creative Commons 2.5 Attribution License.

CompareUnsigned(Int16[], Int16[])

Compares two short arrays lexicographically, numerically treating elements as unsigned.

[Android.Runtime.Register("compareUnsigned", "([S[S)I", "", ApiSince=33)]
public static int CompareUnsigned (short[]? a, short[]? b);

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

Parameters

a

Int16[]

the first array to compare

b

Int16[]

the second array to compare

Returns

Int32

the value 0 if the first and second array are equal and contain the same elements in the same order; a value less than 0 if the first array is lexicographically less than the second array; and a value greater than 0 if the first array is lexicographically greater than the second array

Attributes

RegisterAttribute

Remarks

Compares two short arrays lexicographically, numerically treating elements as unsigned.

If the two arrays share a common prefix then the lexicographic comparison is the result of comparing two elements, as if by Short#compareUnsigned(short, short), at an index within the respective arrays that is the prefix length. Otherwise, one array is a proper prefix of the other and, lexicographic comparison is the result of comparing the two array lengths. (See #mismatch(short[], short[]) for the definition of a common and proper prefix.)

A null array reference is considered lexicographically less than a non-null array reference. Two null array references are considered equal.

Added in 9.

Java documentation for java.util.Arrays.compareUnsigned(short[], short[]).

Portions of this page are modifications based on work created and shared by the Android Open Source Project and used according to terms described in the Creative Commons 2.5 Attribution License.

CompareUnsigned(Int32[], Int32[])

Compares two int arrays lexicographically, numerically treating elements as unsigned.

[Android.Runtime.Register("compareUnsigned", "([I[I)I", "", ApiSince=33)]
public static int CompareUnsigned (int[]? a, int[]? b);

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

Parameters

a

Int32[]

the first array to compare

b

Int32[]

the second array to compare

Returns

Int32

the value 0 if the first and second array are equal and contain the same elements in the same order; a value less than 0 if the first array is lexicographically less than the second array; and a value greater than 0 if the first array is lexicographically greater than the second array

Attributes

RegisterAttribute

Remarks

Compares two int arrays lexicographically, numerically treating elements as unsigned.

If the two arrays share a common prefix then the lexicographic comparison is the result of comparing two elements, as if by Integer#compareUnsigned(int, int), at an index within the respective arrays that is the prefix length. Otherwise, one array is a proper prefix of the other and, lexicographic comparison is the result of comparing the two array lengths. (See #mismatch(int[], int[]) for the definition of a common and proper prefix.)

A null array reference is considered lexicographically less than a non-null array reference. Two null array references are considered equal.

Added in 9.

Java documentation for java.util.Arrays.compareUnsigned(int[], int[]).

Portions of this page are modifications based on work created and shared by the Android Open Source Project and used according to terms described in the Creative Commons 2.5 Attribution License.

CompareUnsigned(Byte[], Byte[])

Compares two byte arrays lexicographically, numerically treating elements as unsigned.

[Android.Runtime.Register("compareUnsigned", "([B[B)I", "", ApiSince=33)]
public static int CompareUnsigned (byte[]? a, byte[]? b);

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

Parameters

a

Byte[]

the first array to compare

b

Byte[]

the second array to compare

Returns

Int32

the value 0 if the first and second array are equal and contain the same elements in the same order; a value less than 0 if the first array is lexicographically less than the second array; and a value greater than 0 if the first array is lexicographically greater than the second array

Attributes

RegisterAttribute

Remarks

Compares two byte arrays lexicographically, numerically treating elements as unsigned.

If the two arrays share a common prefix then the lexicographic comparison is the result of comparing two elements, as if by Byte#compareUnsigned(byte, byte), at an index within the respective arrays that is the prefix length. Otherwise, one array is a proper prefix of the other and, lexicographic comparison is the result of comparing the two array lengths. (See #mismatch(byte[], byte[]) for the definition of a common and proper prefix.)

A null array reference is considered lexicographically less than a non-null array reference. Two null array references are considered equal.

Added in 9.

Java documentation for java.util.Arrays.compareUnsigned(byte[], byte[]).

Portions of this page are modifications based on work created and shared by the Android Open Source Project and used according to terms described in the Creative Commons 2.5 Attribution License.

CompareUnsigned(Int64[], Int64[])

Compares two long arrays lexicographically, numerically treating elements as unsigned.

[Android.Runtime.Register("compareUnsigned", "([J[J)I", "", ApiSince=33)]
public static int CompareUnsigned (long[]? a, long[]? b);

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

Parameters

a

Int64[]

the first array to compare

b

Int64[]

the second array to compare

Returns

Int32

the value 0 if the first and second array are equal and contain the same elements in the same order; a value less than 0 if the first array is lexicographically less than the second array; and a value greater than 0 if the first array is lexicographically greater than the second array

Attributes

RegisterAttribute

Remarks

Compares two long arrays lexicographically, numerically treating elements as unsigned.

If the two arrays share a common prefix then the lexicographic comparison is the result of comparing two elements, as if by Long#compareUnsigned(long, long), at an index within the respective arrays that is the prefix length. Otherwise, one array is a proper prefix of the other and, lexicographic comparison is the result of comparing the two array lengths. (See #mismatch(long[], long[]) for the definition of a common and proper prefix.)

A null array reference is considered lexicographically less than a non-null array reference. Two null array references are considered equal.

Added in 9.

Java documentation for java.util.Arrays.compareUnsigned(long[], long[]).

Portions of this page are modifications based on work created and shared by the Android Open Source Project and used according to terms described in the Creative Commons 2.5 Attribution License.