Class Vector
 All Implemented Interfaces:
Iterable<Number>
,Collection<Number>
,List<Number>
,RandomAccess
Vector
can be a wrapper around an array of Java primitive type
(typically float[]
or double[]
), or it may be a function calculating values on the fly.
Often the two abovecited cases are used together, for example in a time series where:
 x[i] is a linear function of i (e.g. the sampling time of measurements performed at a fixed time interval)
 y[i] is the measurement of a phenomenon at time x[i].
Instantiation
Instances ofVector
are usually created by calls to the create(Object, boolean)
static method.
The supplied array is not cloned – changes to the primitive array are reflected in the vector, and viceversa.
Vectors can be a view over a subsection of the given array, or can provide a view of the elements in reverse order,
etc. The example below creates a view over a subsection:
float[] array = new float[100]; Vector v = Vector.create(array, false).subList(20, 40) // At this point, v.doubleValue(0) is equivalent to (double) array[20].
Usage
The methods that are most often used afterVector
creation are size()
and doubleValue(int)
or intValue(int)
. Those methods make abstraction of the underlying data type. For example if the vector is
backed by an array of type int[]
, then calls to doubleValue(index)
will:
 Convert the
int[index]
value to adouble
value.  If
isUnsigned()
istrue
, apply the necessary bitmask before conversion.
short
to long
) are always allowed.
Narrowing conversions are allowed if the result can be represented at least approximately by the target type.
For example conversions from double
to float
are always allowed (values that are too large for
the float
type are represented by positive of negative infinity), but conversions from long
to
short
are allowed only if the value is between Short.MIN_VALUE
and Short.MAX_VALUE
inclusive.
ByteBuffer
in standard Java, but they actually serve different purposes. The ByteBuffer
getter methods
(for example getShort(int)
, getLong(int)
, etc.) allow to decode a sequence of
bytes in a way determined by the type of the value to decode (2 bytes for a short
, 8 bytes
for a long
, etc.) – the type of the stored value must be known before to read it.
By contrast, this Vector
class is used in situations where the decoding has already been done
by the code that create a Vector
object, but the data type may not be known
by the code that will use the Vector
object.
For example a method performing a numerical calculation may want to see the data as double
values
without concern about whether the data were really stored as double
or as float
values.
For the situations where a Buffer
is needed, interoperability is provided by the buffer()
method and by accepting buffer in the create(Object, boolean)
method. Since:
 0.8
 See Also:
Defined in the sisutility
module

Field Summary
Fields inherited from class AbstractList
modCount

Constructor Summary

Method Summary
Modifier and TypeMethodDescriptionbuffer()
Returns the vector data as ajava.nio
buffer.byte
byteValue
(int index) Returns the value at the given index as abyte
.compress
(double tolerance) Returns a vector with the same data than this vector but encoded in a more compact way, orthis
if this method can not do better than currentVector
instance.concatenate
(Vector toAppend) Returns the concatenation of this vector with the given one.static Vector
create
(double[] array) Wraps the given array of floating point values.static Vector
Wraps the given object in a vector.static Vector
createForDecimal
(float[] array) Wraps the givenfloat[]
array in a vector that preserve the string representations in base 10.static Vector
createSequence
(Number first, Number increment, int length) Creates a sequence of numbers in a given range of values using the given increment.abstract double
doubleValue
(int index) Returns the value at the given index as adouble
.double[]
Copies all values in an array of double precision floating point numbers.boolean
Returnstrue
if the given object is a vector containing the same values than this vector.void
Sets a range of elements to the given number.float
floatValue
(int index) Returns the value at the given index as afloat
.float[]
Copies all values in an array of single precision floating point numbers.abstract Number
get
(int index) Returns the number at the given index, ornull
if none.Returns the type of elements in this vector.int
Returns a hash code for the values in this vector.increment
(double tolerance) Returns the increment between all consecutive values if this increment is constant, ornull
otherwise.int
intValue
(int index) Returns the value at the given index as anint
.boolean
Returnstrue
if this vector is empty or contains onlyNaN
values.boolean
Returnstrue
if this vector contains only integer values.abstract boolean
isNaN
(int index) Returnstrue
if the value at the given index isnull
orNaN
.boolean
Returnstrue
if values in this vector can be casted to singleprecision floating point numbers (float
) without precision lost.boolean
Returnstrue
if integer values shall be interpreted as unsigned values.long
longValue
(int index) Returns the value at the given index as along
.pick
(int... indices) Returns a view which contains the values of this vector at the given indexes.NumberRange<?>
range()
Returns the minimal and maximal values found in this vector.repeat
(boolean eachValue, int count) Returns a vector whose value is the content of this vector repeated count times.int[]
repetitions
(int... candidates) Detects repetition patterns in the values contained in this vector.final Vector
reverse()
Returns a view which contains the values of this vector in reverse order.abstract Number
Sets the number at the given index.short
shortValue
(int index) Returns the value at the given index as ashort
.abstract int
size()
Returns the number of elements in this vector.abstract String
stringValue
(int index) Returns a string representation of the value at the given index.final Vector
subList
(int lower, int upper) Returns a view which contain the values of this vector in the given index range.subSampling
(int first, int step, int length) Returns a view which contain the values of this vector in a given index range.Returns a string representation of this vector.transform
(double scale, double offset) Returns a view of this vector with all values transformed by the given linear equation.Methods inherited from class AbstractList
add, add, addAll, clear, indexOf, iterator, lastIndexOf, listIterator, listIterator, remove, removeRange
Methods inherited from class AbstractCollection
addAll, contains, containsAll, isEmpty, remove, removeAll, retainAll, toArray, toArray
Methods inherited from class Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait
Methods inherited from interface Collection
parallelStream, removeIf, stream, toArray
Methods inherited from interface List
addAll, contains, containsAll, isEmpty, remove, removeAll, replaceAll, retainAll, sort, spliterator, toArray, toArray

Constructor Details

Vector
protected Vector()For subclasses constructor.


Method Details

create
Wraps the given object in a vector. The argument should be one of the following: An array of a primitive type, like
float[]
.  A
Number[]
array.  A
String[]
array (not recommended, but happen with some file formats).  A
Vector
, in which case it is returned unchanged.  A
Buffer
backed by an array.  The
null
value, in which casenull
is returned.
Unsigned integers
Java has no primitive support for unsigned integers. But some file formats use unsigned integers, which can be simulated in Java by the use of bit masks or methods likeInteger.toUnsignedLong(int)
. ThisVector
class applies automatically those masks (unless otherwise noticed in method Javadoc) if theisUnsigned
argument istrue
. That argument applies only tobyte[]
,short[]
,int[]
orlong[]
arrays and is ignored for all other kind of arrays. Parameters:
array
 the object to wrap in a vector, ornull
.isUnsigned
true
if integer types should be interpreted as unsigned integers. Returns:
 the given object wrapped in a vector, or
null
if the argument wasnull
.  Throws:
IllegalArgumentException
 if the type of the given object is not recognized by the method.
 An array of a primitive type, like

create
Wraps the given array of floating point values. This method does not clone the array: changes in the given array will be reflected in the returned vector and viceversa. This method is equivalent to
but potentially faster.create
(array, false) Parameters:
array
 the array of floating point values to wrap in a vector, ornull
. Returns:
 the given array wrapped in a vector, or
null
if the argument wasnull
.  Since:
 1.0

createForDecimal
Wraps the givenfloat[]
array in a vector that preserve the string representations in base 10. For example the 0.1float
value casted todouble
normally produces 0.10000000149011612 because of the way IEEE 754 arithmetic represents numbers (in base 2 instead of base 10). But the vector returned by this method will convert the 0.1float
value into the 0.1double
value. Note that despite the appearance, this is not more accurate than the normal cast, because base 10 is not more privileged in nature than base 2.When to use
This method can be used when there is good reasons to think that thefloat
numbers were parsed from decimal representations, for example an ASCII file. There is usually no reason to use this method if the values are the result of some numerical computations. Parameters:
array
 the array of floating point values to wrap in a vector, ornull
. Returns:
 the given array wrapped in a vector, or
null
if the argument wasnull
.  See Also:

createSequence
Creates a sequence of numbers in a given range of values using the given increment. The range of values will befirst
inclusive to(first + increment*length)
exclusive. Note that the value given by thefirst
argument is equivalent to a "lowest" or "minimum" value only if the given increment is positive.The element type will be inferred from the type of the given
Number
instances. If will typically beInteger.class
for the [100:1:120] range andDouble.class
for the [0:0.1:1] range. Parameters:
first
 the first value, inclusive.increment
 the difference between the values at two adjacent indexes.length
 the length of the desired vector. Returns:
 the given sequence as a vector.

getElementType
Returns the type of elements in this vector. If this vector is backed by an array of a primitive type, then this method returns the wrapper class, not the primitive type. For example if this vector is backed by an array of typefloat[]
, then this method returnsFloat.class
, notFloat.TYPE
.The information returned by this method is only indicative; it is not guaranteed to specify accurately this kind of objects returned by the
get(int)
method. There is various situations where the types may not match: If this vector is unsigned, then the values returned by
get(int)
may be instances of a type wider than the type used by this vector for storing the values.  If this vector has been created for decimal numbers,
then the values returned by
get(int)
will use doubleprecision even if this vector stores the values as singleprecision floating point numbers.  If this vector has been compressed, then the type returned by this method does not describe accurately the range of values that this vector can store.
Users of the
doubleValue(int)
method do not need to care about this information sinceVector
will perform automatically the type conversion. Users of other methods may want to verify this information for avoidingArithmeticException
. Returns:
 the type of elements in this vector.
 See Also:
 If this vector is unsigned, then the values returned by

isSinglePrecision
public boolean isSinglePrecision()Returnstrue
if values in this vector can be casted to singleprecision floating point numbers (float
) without precision lost. In case of doubt, this method conservatively returnsfalse
. Returns:
 whether values in this vector can be casted to
float
primitive type.  Since:
 1.1
 See Also:

isInteger
public boolean isInteger()Returnstrue
if this vector contains only integer values. This method may iterate over all values for performing this verification. Returns:
true
if this vector contains only integer values.

isUnsigned
public boolean isUnsigned()Returnstrue
if integer values shall be interpreted as unsigned values. This method may returntrue
for data stored inbyte[]
,short[]
,int[]
orlong[]
arrays, but never for data stored infloat[]
anddouble[]
arrays. The default implementation returnsfalse
.Unless otherwise noticed in Javadoc, users do not need to care about this information since
Vector
methods will perform automatically the operations needed for unsigned integers. Returns:
true
if the integer values shall be interpreted as unsigned values.

size
public abstract int size()Returns the number of elements in this vector. Specified by:
size
in interfaceCollection<Number>
 Specified by:
size
in interfaceList<Number>
 Specified by:
size
in classAbstractCollection<Number>
 Returns:
 the number of elements in this vector.

isEmptyOrNaN
public boolean isEmptyOrNaN()Returnstrue
if this vector is empty or contains onlyNaN
values. Returns:
 whether this vector is empty or contains only
NaN
values.  Since:
 1.1

isNaN
public abstract boolean isNaN(int index) Returnstrue
if the value at the given index isnull
orNaN
. Parameters:
index
 the index in the [0 … size1] range. Returns:
true
if the value at the given index isNaN
. Throws:
IndexOutOfBoundsException
 if the given index is out of bounds.

doubleValue
public abstract double doubleValue(int index) Returns the value at the given index as adouble
. This is the safest method since all primitive types supported byVector
are convertible to thedouble
type. Parameters:
index
 the index in the [0 … size1] range. Returns:
 the value at the given index.
 Throws:
IndexOutOfBoundsException
 if the given index is out of bounds.NullPointerException
 if the value isnull
(never happen if this vector wraps an array of primitive type).NumberFormatException
 if the value is stored as aString
and can not be parsed. See Also:

floatValue
public float floatValue(int index) Returns the value at the given index as afloat
. This method may result in a lost of precision if this vector stores or computes its values with thedouble
type.The default implementation delegates to
doubleValue(int)
and cast the result tofloat
. Parameters:
index
 the index in the [0 … size1] range. Returns:
 the value at the given index.
 Throws:
IndexOutOfBoundsException
 if the given index is out of bounds.NullPointerException
 if the value isnull
(never happen if this vector wraps an array of primitive type).NumberFormatException
 if the value is stored as aString
and can not be parsed. See Also:

longValue
public long longValue(int index) Returns the value at the given index as along
. If this vector uses floating point values, the value is rounded to the nearest integer.The default implementation delegates to
doubleValue(int)
and verifies if the result can be rounded to along
with an error not greater than 0.5. Subclasses that store or compute their values with an integer type should override this method. Parameters:
index
 the index in the [0 … size1] range. Returns:
 the value at the given index.
 Throws:
IndexOutOfBoundsException
 if the given index is out of bounds.NullPointerException
 if the value isnull
(never happen if this vector wraps an array of primitive type).NumberFormatException
 if the value is stored as aString
and can not be parsed.ArithmeticException
 if the value is too large for the capacity of thelong
type.

intValue
public int intValue(int index) Returns the value at the given index as anint
. If this vector uses floating point values, the value is rounded to the nearest integer.The default implementation delegates to
longValue(int)
and verifies if the result fits in theint
type. Subclasses that store or compute their values with theint
,short
orbyte
type should override this method. Parameters:
index
 the index in the [0 … size1] range. Returns:
 the value at the given index.
 Throws:
IndexOutOfBoundsException
 if the given index is out of bounds.NullPointerException
 if the value isnull
(never happen if this vector wraps an array of primitive type).NumberFormatException
 if the value is stored as aString
and can not be parsed.ArithmeticException
 if the value is too large for the capacity of theint
type.

shortValue
public short shortValue(int index) Returns the value at the given index as ashort
. If this vector uses floating point values, the value is rounded to the nearest integer.The default implementation delegates to
longValue(int)
and verifies if the result fits in theshort
type. Subclasses that store or compute their values with theshort
orbyte
type should override this method. Parameters:
index
 the index in the [0 … size1] range. Returns:
 the value at the given index.
 Throws:
IndexOutOfBoundsException
 if the given index is out of bounds.NullPointerException
 if the value isnull
(never happen if this vector wraps an array of primitive type).NumberFormatException
 if the value is stored as aString
and can not be parsed.ArithmeticException
 if the value is too large for the capacity of theshort
type.

byteValue
public byte byteValue(int index) Returns the value at the given index as abyte
. If this vector uses floating point values, the value is rounded to the nearest integer.The default implementation delegates to
longValue(int)
and verifies if the result fits in thebyte
type. Subclasses that store or compute their values with thebyte
type should override this method. Parameters:
index
 the index in the [0 … size1] range. Returns:
 the value at the given index.
 Throws:
IndexOutOfBoundsException
 if the given index is out of bounds.NullPointerException
 if the value isnull
(never happen if this vector wraps an array of primitive type).NumberFormatException
 if the value is stored as aString
and can not be parsed.ArithmeticException
 if the value is too large for the capacity of thebyte
type.

stringValue
Returns a string representation of the value at the given index. Invoking this method is generally equivalent to invokingString.valueOf(get(index))
except if the values are unsigned integers. Parameters:
index
 the index in the [0 … size1] range. Returns:
 a string representation of the value at the given index (may be
null
).  Throws:
IndexOutOfBoundsException
 if the given index is out of bounds. See Also:

get
Returns the number at the given index, ornull
if none. The object returned by this method is usually an instance of the class returned bygetElementType()
, but may also be an instance of a wider type if this is necessary for representing the values.Example: ifgetElementType()
returnsByte.class
butisUnsigned()
returnstrue
, then this method may return instances ofShort
since that type is the smallest Java primitive type capable to hold byte values in the [0 … 255] range. Specified by:
get
in interfaceList<Number>
 Specified by:
get
in classAbstractList<Number>
 Parameters:
index
 the index in the [0 … size1] range. Returns:
 the value at the given index (may be
null
).  Throws:
IndexOutOfBoundsException
 if the given index is out of bounds.NumberFormatException
 if the value is stored as aString
and can not be parsed.

set
Sets the number at the given index. The given number should be an instance of the same type than the number returned byget(int)
. If not, the stored value may lost precision as a result of the cast. Specified by:
set
in interfaceList<Number>
 Overrides:
set
in classAbstractList<Number>
 Parameters:
index
 the index in the [0 … size1] range.value
 the value to set at the given index. Returns:
 the value previously stored at the given index.
 Throws:
UnsupportedOperationException
 if this vector is readonly.IndexOutOfBoundsException
 if the given index is out of bounds.NumberFormatException
 if the previous value was stored as aString
and can not be parsed.IllegalArgumentException
 if this vector uses some compression technic and the given value is out of range for that compression.

fill
Sets a range of elements to the given number. Invoking this method is equivalent to invokingset(int, Number)
in a loop, but potentially much more efficient. Parameters:
fromIndex
 index of the first element (inclusive) to be filled with the specified value.toIndex
 index of the last element (exclusive) to be filled with the specified value.value
 the value to be stored in elements of the vector. Since:
 1.1

repetitions
public int[] repetitions(int... candidates) Detects repetition patterns in the values contained in this vector. The repetitions detected by this method are patterns that at repeated at a regular interval on the whole vector; this method does not search for repetitions occurring at irregular intervals. This method returns an array of typically 0, 1 or 2 elements where zero element means that no repetition has been found, one element describes a repetition (see the example below), and two elements describes a repetition of the repetitions (examples below). More elements (deeper recursivity) are theoretically possible but not yet implemented.If the values in this vector are of the form (x, x, …, x, y, y, …, y, z, z, …, z, …), then the first integer in the returned array is the number of consecutive x values before the y values. That number of occurrences must be the same than the number of consecutive y values before the z values, the number of consecutive z values before the next values, and so on until the end of the vector.
Examples: in the following vector, each value is repeated 3 times. So the array returned by this method would beFor the next level (the second integer in the returned array), this method represents above repetitions by single entities then reapplies the same repetition detection. This method processes has if the (x, x, …, x, y, y, …, y, z, z, …, z, …) vector was replaced by a new (x, y, z, …) vector, then the same detection algorithm was applied recursively.{4}
, meaning that the first number appears 4 times, followed by a new number appearing 4 times, followed by a new number appearing 4 times, and so on until the end of the vector.10, 10, 10, 10, 12, 12, 12, 12, 15, 15, 15, 15
Examples: in the following vector, each value is repeated 2 times, then the sequence of 12 values is itself repeated 2 times. So the array returned by this method would be{3,4}
, meaning that the first number appears 3 times, followed by a new number appearing 3 times, etc. until we counted 4 groups of 3 numbers. Then the whole sequence is repeated until the end of the vector.10, 10, 10, 12, 12, 12, 15, 15, 15, 18, 18, 18, 10, 10, 10, 12, 12, 12, 15, 15, 15, 18, 18, 18, 10, 10, 10, 12, 12, 12, 15, 15, 15, 18, 18, 18
This method is useful for analyzing the localization grid provided by some files (for example in netCDF format). Those grids sometime have constant longitude for the same column index, or constant latitude for the same row index. This method can detect such regularity, which allows more efficient handling of the grid to CRS transform.
 Parameters:
candidates
 probable values, ornull
or an empty array if unknown. If nonempty, those values will be used for narrowing the search, which may improve performances. There is no guarantees that the values returned by this method will be among the given candidates. Returns:
 the number of times that entities (numbers, or group of numbers) appears consecutively with identical values. If no such repetition is found, an empty array.
 Since:
 1.0
 See Also:

increment
Returns the increment between all consecutive values if this increment is constant, ornull
otherwise. If the returned value is nonnull, then the following condition shall hold for all values of i in the [0 …size()
 1] range:
The tolerance threshold can be zero if exact matches are desired. The return value (if nonnull) is always a signed value, even if this vector is unsigned.abs(doubleValue(i)  (doubleValue(0) + increment*i)) ≤ tolerance
 Parameters:
tolerance
 the tolerance threshold for verifying if the increment is constant. Returns:
 the increment as a signed value, or
null
if the increment is not constant.

range
Returns the minimal and maximal values found in this vector. Returns:
 minimal and maximal values found in this vector.

subList
Returns a view which contain the values of this vector in the given index range. The returned view will contain the values from indexlower
inclusive toupper
exclusive.Implementation note: this method delegates its worksubSampling(lower, 1, upper  lower)
. This method is declared final in order to force subclasses to overridesubSampling(…)
instead. Specified by:
subList
in interfaceList<Number>
 Overrides:
subList
in classAbstractList<Number>
 Parameters:
lower
 index of the first value to be included in the returned view.upper
 index after the last value to be included in the returned view. Returns:
 a view of this vector containing values in the given index range.
 Throws:
IndexOutOfBoundsException
 if an index is outside the [0 … size1] range.

subSampling
Returns a view which contain the values of this vector in a given index range. The returned view will contain the values from indexfirst
inclusive to(first + step*length)
exclusive with index incremented by the givenstep
value, which can be negative. More specifically the index i in the returned vector will maps the element at index(first + step*i)
in this vector.This method does not copy the values. Consequently any modification to the values of this vector will be reflected in the returned view and viceversa.
 Parameters:
first
 index of the first value in this vector to be included in the returned view.step
 the index increment between values in this vector to be included in the returned view. Can be positive, zero or negative.length
 the length of the view to be returned. Can not be greater than the length of this vector, except if thestep
is zero. Returns:
 a view of this vector containing values in the given index range.
 Throws:
IndexOutOfBoundsException
 iffirst
orfirst + step*(length1)
is outside the [0 … size1] range.

pick
Returns a view which contains the values of this vector at the given indexes. This method does not copy the values, consequently any modification to the values of this vector will be reflected in the returned view and viceversa.The indexes do not need to be in any particular order. The same index can be repeated more than once. Thus it is possible to create a vector larger than the original vector.
 Parameters:
indices
 indexes of the values to be returned. Returns:
 a view of this vector containing values at the given indexes.
 Throws:
IndexOutOfBoundsException
 if at least one index is out of bounds.

concatenate
Returns the concatenation of this vector with the given one. Indexes in the [0 …size
 1] range will map to this vector, while indexes in the [size
…size
+toAppend.size
] range while map to the given vector. Parameters:
toAppend
 the vector to concatenate at the end of this vector. Returns:
 the concatenation of this vector with the given vector.

repeat
Returns a vector whose value is the content of this vector repeated count times. The content can be repeated in two different ways: If
eachValue
istrue
, then each value is repeatedcount
times before to move to the next value.  If
eachValue
isfalse
, then whole vector is repeatedcount
times.
Example: ifThis method returns an empty vector ifvec
contains{1, 2, 3}
, then:vec.repeat(true, 4)
returns{1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3}
.vec.repeat(false, 4)
returns{1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3}
.
count
is zero and returnsthis
ifcount
is one. For other positivecount
values, this method returns an unmodifiable view of this vector: changes in this vector are reflected in the repeated vector. Parameters:
eachValue
 whether to apply the repetition on each value (true
) or on the whole vector (false
).count
 number of repetitions as a positive number (including zero). Returns:
 this vector repeated count time.
 Since:
 1.0
 See Also:
 If

reverse
Returns a view which contains the values of this vector in reverse order.Implementation note: this method delegates its work tosubSampling(size1, 1, size)
. This method is declared final in order to force subclasses to overridesubSampling(…)
instead. Returns:
 the vector values in reverse order.

transform
Returns a view of this vector with all values transformed by the given linear equation. Ifscale
= 1 andoffset
= 0, then this method returnsthis
. Otherwise this method returns a vector where each value at index i is computed bydoubleValue(i)
×scale
+offset
. The values are computed onthefly; they are not copied. Parameters:
scale
 the scale factor to apply on each value, or 1 if none.offset
 the offset to apply on each value, or 0 if none. Returns:
 a vector with values computed by
doubleValue(i)
×scale
+offset
.  Throws:
IllegalArgumentException
 if an argument is NaN or infinite. Since:
 1.0

compress
Returns a vector with the same data than this vector but encoded in a more compact way, orthis
if this method can not do better than currentVector
instance. Examples: Vector is backed by an
int[]
array while values could be stored asshort
values.  Vector contains increasing or decreasing values with a constant delta between consecutive values.
create(Object, boolean)
method. Since the returned array may be a copy ofthis
array, caller should not retain reference tothis
or reference to the backing array after this method call (otherwise an unnecessary duplication of data may exist in memory).When to use
It is usually not worth to compress small arrays. Performancecritical arrays may not be compressed neither. This method is best suited for vectors that may potentially be large and for which the cost of fetching values in that vector is small compared to the calculation performed with the values. Parameters:
tolerance
 maximal difference allowed between original and compressed vectors (can be zero). Returns:
 a more compact vector with the same data than this vector, or
this
.
 Vector is backed by an

buffer
Returns the vector data as ajava.nio
buffer. Data are not copied: changes in the buffer are reflected on this vector and viceversa. Date are provided in their "raw" form. For example unsigned integers are given as plainint
elements and it is caller responsibility to useInteger.toUnsignedLong(int)
if needed. Returns:
 the vector data as a buffer. Absent if this vector is not backed by an array or a buffer.
 Since:
 1.0

doubleValues
public double[] doubleValues()Copies all values in an array of double precision floating point numbers. This method is for interoperability with APIs requiring an array of primitive type.The default implementation invokes
doubleValue(int)
for all indices from 0 inclusive tosize()
exclusive. Subclasses may override with more efficient implementation. Returns:
 a copy of all floating point values in this vector.
 See Also:

floatValues
public float[] floatValues()Copies all values in an array of single precision floating point numbers. This method is for interoperability with APIs requiring an array of primitive type.The default implementation invokes
floatValue(int)
for all indices from 0 inclusive tosize()
exclusive. Subclasses may override with more efficient implementation. Returns:
 a copy of all floating point values in this vector.
 See Also:

toString
Returns a string representation of this vector. Overrides:
toString
in classAbstractCollection<Number>
 Returns:
 a string representation of this vector.
 See Also:

hashCode
public int hashCode()Returns a hash code for the values in this vector. The hash code is computed as if this vector was converted to an array ofNumber
s, then theArrays.hashCode(Object[])
method invoked for that array. This contract is defined for compatibility withList.hashCode()
contract. Specified by:
hashCode
in interfaceCollection<Number>
 Specified by:
hashCode
in interfaceList<Number>
 Overrides:
hashCode
in classAbstractList<Number>
 Returns:
 a hash code value for the values in this vector.
 Since:
 1.0

equals
Returnstrue
if the given object is a vector containing the same values than this vector. This method performs the comparison as if the two vectors where converted to arrays ofNumber
s, then theArrays.equals(Object[], Object[])
method invoked for those arrays. Specified by:
equals
in interfaceCollection<Number>
 Specified by:
equals
in interfaceList<Number>
 Overrides:
equals
in classAbstractList<Number>
 Parameters:
object
 the other object to compare with this vector. Returns:
true
if the given object is a vector containing the same values than this vector. Since:
 1.0
