|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | |||||||||
java.lang.Objectcom.google.common.primitives.Shorts
@GwtCompatible(emulated=true) public final class Shorts
Static utility methods pertaining to short primitives, that are not
already found in either Short or Arrays.
| Field Summary | |
|---|---|
static int |
BYTES
The number of bytes required to represent a primitive short
value. |
static short |
MAX_POWER_OF_TWO
The largest power of two that can be represented as a short. |
| Method Summary | |
|---|---|
static List<Short> |
asList(short... backingArray)
Returns a fixed-size list backed by the specified array, similar to Arrays.asList(Object[]). |
static short |
checkedCast(long value)
Returns the short value that is equal to value, if
possible. |
static int |
compare(short a,
short b)
Compares the two specified short values. |
static short[] |
concat(short[]... arrays)
Returns the values from each provided array combined into a single array. |
static boolean |
contains(short[] array,
short target)
Returns true if target is present as an element anywhere in
array. |
static short[] |
ensureCapacity(short[] array,
int minLength,
int padding)
Returns an array containing the same values as array, but
guaranteed to be of a specified minimum length. |
static short |
fromByteArray(byte[] bytes)
Returns the short value whose big-endian representation is
stored in the first 2 bytes of bytes; equivalent to ByteBuffer.wrap(bytes).getShort(). |
static short |
fromBytes(byte b1,
byte b2)
Returns the short value whose byte representation is the given 2
bytes, in big-endian order; equivalent to Shorts.fromByteArray(new
byte[] {b1, b2}). |
static int |
hashCode(short value)
Returns a hash code for value; equal to the result of invoking
((Short) value).hashCode(). |
static int |
indexOf(short[] array,
short target)
Returns the index of the first appearance of the value target in
array. |
static int |
indexOf(short[] array,
short[] 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,
short... array)
Returns a string containing the supplied short values separated
by separator. |
static int |
lastIndexOf(short[] array,
short target)
Returns the index of the last appearance of the value target in
array. |
static Comparator<short[]> |
lexicographicalComparator()
Returns a comparator that compares two short arrays
lexicographically. |
static short |
max(short... array)
Returns the greatest value present in array. |
static short |
min(short... array)
Returns the least value present in array. |
static short |
saturatedCast(long value)
Returns the short nearest in value to value. |
static short[] |
toArray(Collection<Short> collection)
Copies a collection of Short instances into a new array of
primitive short values. |
static byte[] |
toByteArray(short value)
Returns a big-endian representation of value in a 2-element byte
array; equivalent to ByteBuffer.allocate(2).putShort(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
short
value.
public static final short MAX_POWER_OF_TWO
short.
| Method Detail |
|---|
public static int hashCode(short value)
value; equal to the result of invoking
((Short) value).hashCode().
value - a primitive short value
public static short checkedCast(long value)
short value that is equal to value, if
possible.
value - any value in the range of the short type
short value that equals value
IllegalArgumentException - if value is greater than Short.MAX_VALUE or less than Short.MIN_VALUEpublic static short saturatedCast(long value)
short nearest in value to value.
value - any long value
short if it is in the range of the
short type, Short.MAX_VALUE if it is too large,
or Short.MIN_VALUE if it is too small
public static int compare(short a,
short b)
short values. The sign of the value
returned is the same as that of ((Short) a).compareTo(b).
a - the first short to compareb - the second short 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(short[] array,
short target)
true if target is present as an element anywhere in
array.
array - an array of short values, possibly emptytarget - a primitive short value
true if array[i] == target for some value of i
public static int indexOf(short[] array,
short target)
target in
array.
array - an array of short values, possibly emptytarget - a primitive short value
i for which array[i] == target, or
-1 if no such index exists.
public static int indexOf(short[] array,
short[] 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(short[] array,
short target)
target in
array.
array - an array of short values, possibly emptytarget - a primitive short value
i for which array[i] == target,
or -1 if no such index exists.public static short min(short... array)
array.
array - a nonempty array of short values
array that is less than or equal to
every other value in the array
IllegalArgumentException - if array is emptypublic static short max(short... array)
array.
array - a nonempty array of short values
array that is greater than or equal to
every other value in the array
IllegalArgumentException - if array is emptypublic static short[] concat(short[]... arrays)
concat(new short[] {a, b}, new short[] {}, new
short[] {c} returns the array {a, b, c}.
arrays - zero or more short arrays
@GwtIncompatible(value="doesn\'t work") public static byte[] toByteArray(short value)
value in a 2-element byte
array; equivalent to ByteBuffer.allocate(2).putShort(value).array(). For example, the input
value (short) 0x1234 would yield the byte array {0x12,
0x34}.
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 short fromByteArray(byte[] bytes)
short value whose big-endian representation is
stored in the first 2 bytes of bytes; equivalent to ByteBuffer.wrap(bytes).getShort(). For example, the input byte array
{0x54, 0x32} would yield the short value 0x5432.
Arguably, it's preferable to use ByteBuffer; that
library exposes much more flexibility at little cost in readability.
IllegalArgumentException - if bytes has fewer than 2
elements
@GwtIncompatible(value="doesn\'t work")
public static short fromBytes(byte b1,
byte b2)
short value whose byte representation is the given 2
bytes, in big-endian order; equivalent to Shorts.fromByteArray(new
byte[] {b1, b2}).
public static short[] ensureCapacity(short[] 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,
short... array)
short values separated
by separator. For example, join("-", (short) 1, (short) 2,
(short) 3) 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 short values, possibly emptypublic static Comparator<short[]> lexicographicalComparator()
short arrays
lexicographically. That is, it compares, using compare(short, short)), 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, [] < [(short) 1] <
[(short) 1, (short) 2] < [(short) 2].
The returned comparator is inconsistent with Object.equals(Object) (since arrays support only identity equality), but
it is consistent with Arrays.equals(short[], short[]).
public static short[] toArray(Collection<Short> collection)
Short instances into a new array of
primitive short 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 Short objects
collection, in the
same order, converted to primitives
NullPointerException - if collection or any of its elements
is nullpublic static List<Short> asList(short... 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
Short 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 | |||||||||