|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | |||||||||
java.lang.Objectcom.google.common.primitives.Longs
@GwtCompatible(emulated=true) public final class Longs
Static utility methods pertaining to long primitives, that are not
already found in either Long or Arrays.
| Field Summary | |
|---|---|
static int |
BYTES
The number of bytes required to represent a primitive long
value. |
static long |
MAX_POWER_OF_TWO
The largest power of two that can be represented as a long. |
| Method Summary | |
|---|---|
static List<Long> |
asList(long... backingArray)
Returns a fixed-size list backed by the specified array, similar to Arrays.asList(Object[]). |
static int |
compare(long a,
long b)
Compares the two specified long values. |
static long[] |
concat(long[]... arrays)
Returns the values from each provided array combined into a single array. |
static boolean |
contains(long[] array,
long target)
Returns true if target is present as an element anywhere in
array. |
static long[] |
ensureCapacity(long[] array,
int minLength,
int padding)
Returns an array containing the same values as array, but
guaranteed to be of a specified minimum length. |
static long |
fromByteArray(byte[] bytes)
Returns the long value whose big-endian representation is
stored in the first 8 bytes of bytes; equivalent to ByteBuffer.wrap(bytes).getLong(). |
static long |
fromBytes(byte b1,
byte b2,
byte b3,
byte b4,
byte b5,
byte b6,
byte b7,
byte b8)
Returns the long value whose byte representation is the given 8
bytes, in big-endian order; equivalent to Longs.fromByteArray(new
byte[] {b1, b2, b3, b4, b5, b6, b7, b8}). |
static int |
hashCode(long value)
Returns a hash code for value; equal to the result of invoking
((Long) value).hashCode(). |
static int |
indexOf(long[] array,
long target)
Returns the index of the first appearance of the value target in
array. |
static int |
indexOf(long[] array,
long[] target)
Returns the start position of the first occurrence of the specified target within array, or -1 if there is no such occurrence. |
static String |
join(String separator,
long... array)
Returns a string containing the supplied long values separated
by separator. |
static int |
lastIndexOf(long[] array,
long target)
Returns the index of the last appearance of the value target in
array. |
static Comparator<long[]> |
lexicographicalComparator()
Returns a comparator that compares two long arrays
lexicographically. |
static long |
max(long... array)
Returns the greatest value present in array. |
static long |
min(long... array)
Returns the least value present in array. |
static long[] |
toArray(Collection<Long> collection)
Copies a collection of Long instances into a new array of
primitive long values. |
static byte[] |
toByteArray(long value)
Returns a big-endian representation of value in an 8-element byte
array; equivalent to ByteBuffer.allocate(8).putLong(value).array(). |
| Methods inherited from class java.lang.Object |
|---|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
| Field Detail |
|---|
public static final int BYTES
long
value.
public static final long MAX_POWER_OF_TWO
long.
| Method Detail |
|---|
public static int hashCode(long value)
value; equal to the result of invoking
((Long) value).hashCode().
This method always return the value specified by Long.hashCode() in java, which might be different from
((Long) value).hashCode() in GWT because Long.hashCode()
in GWT does not obey the JRE contract.
value - a primitive long value
public static int compare(long a,
long b)
long values. The sign of the value
returned is the same as that of ((Long) a).compareTo(b).
a - the first long to compareb - the second long to compare
a is less than b; a positive
value if a is greater than b; or zero if they are equal
public static boolean contains(long[] array,
long target)
true if target is present as an element anywhere in
array.
array - an array of long values, possibly emptytarget - a primitive long value
true if array[i] == target for some value of i
public static int indexOf(long[] array,
long target)
target in
array.
array - an array of long values, possibly emptytarget - a primitive long value
i for which array[i] == target, or
-1 if no such index exists.
public static int indexOf(long[] array,
long[] target)
target within array, or -1 if there is no such occurrence.
More formally, returns the lowest index i such that java.util.Arrays.copyOfRange(array, i, i + target.length) contains exactly
the same elements as target.
array - the array to search for the sequence targettarget - the array to search for as a sub-sequence of array
public static int lastIndexOf(long[] array,
long target)
target in
array.
array - an array of long values, possibly emptytarget - a primitive long value
i for which array[i] == target,
or -1 if no such index exists.public static long min(long... array)
array.
array - a nonempty array of long values
array that is less than or equal to
every other value in the array
IllegalArgumentException - if array is emptypublic static long max(long... array)
array.
array - a nonempty array of long values
array that is greater than or equal to
every other value in the array
IllegalArgumentException - if array is emptypublic static long[] concat(long[]... arrays)
concat(new long[] {a, b}, new long[] {}, new
long[] {c} returns the array {a, b, c}.
arrays - zero or more long arrays
@GwtIncompatible(value="doesn\'t work") public static byte[] toByteArray(long value)
value in an 8-element byte
array; equivalent to ByteBuffer.allocate(8).putLong(value).array().
For example, the input value 0x1213141516171819L would yield the
byte array {0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19}.
If you need to convert and concatenate several values (possibly even of
different types), use a shared ByteBuffer instance, or use
ByteStreams.newDataOutput() to get a growable
buffer.
@GwtIncompatible(value="doesn\'t work") public static long fromByteArray(byte[] bytes)
long value whose big-endian representation is
stored in the first 8 bytes of bytes; equivalent to ByteBuffer.wrap(bytes).getLong(). For example, the input byte array
{0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19} would yield the
long value 0x1213141516171819L.
Arguably, it's preferable to use ByteBuffer; that
library exposes much more flexibility at little cost in readability.
IllegalArgumentException - if bytes has fewer than 8
elements
@GwtIncompatible(value="doesn\'t work")
public static long fromBytes(byte b1,
byte b2,
byte b3,
byte b4,
byte b5,
byte b6,
byte b7,
byte b8)
long value whose byte representation is the given 8
bytes, in big-endian order; equivalent to Longs.fromByteArray(new
byte[] {b1, b2, b3, b4, b5, b6, b7, b8}).
public static long[] ensureCapacity(long[] array,
int minLength,
int padding)
array, but
guaranteed to be of a specified minimum length. If array already
has a length of at least minLength, it is returned directly.
Otherwise, a new array of size minLength + padding is returned,
containing the values of array, and zeroes in the remaining places.
array - the source arrayminLength - the minimum length the returned array must guaranteepadding - an extra amount to "grow" the array by if growth is
necessary
array, with guaranteed
minimum length minLength
IllegalArgumentException - if minLength or padding is
negative
public static String join(String separator,
long... array)
long values separated
by separator. For example, join("-", 1L, 2L, 3L) returns
the string "1-2-3".
separator - the text that should appear between consecutive values in
the resulting string (but not at the start or end)array - an array of long values, possibly emptypublic static Comparator<long[]> lexicographicalComparator()
long arrays
lexicographically. That is, it compares, using compare(long, long)), the first pair of values that follow any
common prefix, or when one array is a prefix of the other, treats the
shorter array as the lesser. For example,
[] < [1L] < [1L, 2L] < [2L].
The returned comparator is inconsistent with Object.equals(Object) (since arrays support only identity equality), but
it is consistent with Arrays.equals(long[], long[]).
public static long[] toArray(Collection<Long> collection)
Long instances into a new array of
primitive long values.
Elements are copied from the argument collection as if by collection.toArray(). Calling this method is as thread-safe as calling
that method.
collection - a collection of Long objects
collection, in the
same order, converted to primitives
NullPointerException - if collection or any of its elements
is nullpublic static List<Long> asList(long... backingArray)
Arrays.asList(Object[]). The list supports List.set(int, Object),
but any attempt to set a value to null will result in a NullPointerException.
The returned list maintains the values, but not the identities, of
Long objects written to or read from it. For example, whether
list.get(0) == list.get(0) is true for the returned list is
unspecified.
backingArray - the array to back the list
|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | |||||||||