com.google.common.primitives.Floats
|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | |||||||||
java.lang.Object
@GwtCompatible public final class Floats
Static utility methods pertaining to float primitives, that are not
already found in either Float or Arrays.
| Method Summary | |
|---|---|
static List<Float> |
asList(float... backingArray)
Returns a fixed-size list backed by the specified array, similar to Arrays.asList(Object[]). |
static int |
compare(float a,
float b)
Compares the two specified float values using Float.compare(float, float). |
static float[] |
concat(float[]... arrays)
Returns the values from each provided array combined into a single array. |
static boolean |
contains(float[] array,
float target)
Returns true if target is present as an element anywhere in
array. |
static float[] |
ensureCapacity(float[] array,
int minLength,
int padding)
Returns an array containing the same values as array, but
guaranteed to be of a specified minimum length. |
static int |
hashCode(float value)
Returns a hash code for value; equal to the result of invoking
((Float) value).hashCode(). |
static int |
indexOf(float[] array,
float target)
Returns the index of the first appearance of the value target in
array. |
static int |
indexOf(float[] array,
float[] 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,
float... array)
Returns a string containing the supplied float values, converted
to strings as specified by Float.toString(float), and separated by
separator. |
static int |
lastIndexOf(float[] array,
float target)
Returns the index of the last appearance of the value target in
array. |
static Comparator<float[]> |
lexicographicalComparator()
Returns a comparator that compares two float arrays
lexicographically. |
static float |
max(float... array)
Returns the greatest value present in array, using the same rules
of comparison as Math.min(float, float). |
static float |
min(float... array)
Returns the least value present in array, using the same rules of
comparison as Math.min(float, float). |
static float[] |
toArray(Collection<Float> collection)
Copies a collection of Float instances into a new array of
primitive float values. |
| Methods inherited from class java.lang.Object |
|---|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
| Method Detail |
|---|
public static int hashCode(float value)
value; equal to the result of invoking
((Float) value).hashCode().
value - a primitive float value
public static int compare(float a,
float b)
float values using Float.compare(float, float). You may prefer to invoke that method
directly; this method exists only for consistency with the other utilities
in this package.
a - the first float to compareb - the second float to compare
Float.compare(float, float)
public static boolean contains(float[] array,
float target)
true if target is present as an element anywhere in
array. Note that this always returns false when target is NaN.
array - an array of float values, possibly emptytarget - a primitive float value
true if array[i] == target for some value of i
public static int indexOf(float[] array,
float target)
target in
array. Note that this always returns -1 when target
is NaN.
array - an array of float values, possibly emptytarget - a primitive float value
i for which array[i] == target, or
-1 if no such index exists.
public static int indexOf(float[] array,
float[] 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.
Note that this always returns -1 when target contains
NaN.
array - the array to search for the sequence targettarget - the array to search for as a sub-sequence of array
public static int lastIndexOf(float[] array,
float target)
target in
array. Note that this always returns -1 when target
is NaN.
array - an array of float values, possibly emptytarget - a primitive float value
i for which array[i] == target,
or -1 if no such index exists.public static float min(float... array)
array, using the same rules of
comparison as Math.min(float, float).
array - a nonempty array of float values
array that is less than or equal to
every other value in the array
IllegalArgumentException - if array is emptypublic static float max(float... array)
array, using the same rules
of comparison as Math.min(float, float).
array - a nonempty array of float values
array that is greater than or equal to
every other value in the array
IllegalArgumentException - if array is emptypublic static float[] concat(float[]... arrays)
concat(new float[] {a, b}, new float[] {}, new
float[] {c} returns the array {a, b, c}.
arrays - zero or more float arrays
public static float[] ensureCapacity(float[] 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,
float... array)
float values, converted
to strings as specified by Float.toString(float), and separated by
separator. For example, join("-", 1.0f, 2.0f, 3.0f)
returns the string "1.0-2.0-3.0".
separator - the text that should appear between consecutive values in
the resulting string (but not at the start or end)array - an array of float values, possibly emptypublic static Comparator<float[]> lexicographicalComparator()
float arrays
lexicographically. That is, it compares, using compare(float, float)), 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, [] < [1.0f] < [1.0f, 2.0f]
< [2.0f].
The returned comparator is inconsistent with Object.equals(Object) (since arrays support only identity equality), but
it is consistent with Arrays.equals(float[], float[]).
public static float[] toArray(Collection<Float> collection)
Float instances into a new array of
primitive float 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 Float objects
collection, in the
same order, converted to primitives
NullPointerException - if collection or any of its elements
is nullpublic static List<Float> asList(float... 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
Float objects written to or read from it. For example, whether
list.get(0) == list.get(0) is true for the returned list is
unspecified.
The returned list may have unexpected behavior if it contains NaN, or if NaN is used as a parameter to any of its methods.
backingArray - the array to back the list
|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | |||||||||