com.force.i18n.commons.util.collection

Class ExpandableArray<E>

java.lang.Object

com.force.i18n.commons.util.collection.ExpandableArray<E>

All Implemented Interfaces:

Serializable, Comparable<ExpandableArray>, Iterable<E>

@Beta
public class ExpandableArray<E>
extends Object
implements Serializable, Iterable<E>, Comparable<ExpandableArray>

An array of Objects that expands as needed to hold new data.

How does this differ from ArrayList, you ask? Well, it behaves like an array and not a list (and thus does not implement List). While an ArrayList will shift values right to fit new values, an ExpandableArray will simply overwrite values. And while if you try to set at a value past the end of an array list, you'll get an ArrayIndexOutOfBounds exception, if you do it on an ExpandableArray, it will happily set it for you. This is fairly similar to an IntHashMap, but more lightweight. Examples:

    arrayList.set(0, two);
    arrayList.set(0, one);
    arrayList.set(0, zero);
    arrayList.get(0) == zero
    arrayList.get(1) == one
    arrayList.get(2) == two

 

but:

    expandableArray.set(0, two);
    expandableArray.set(0, one);
    expandableArray.set(0, zero);
    expandableArray.get(0) == zero
    expandableArray.get(1) == null
    expandableArray.get(2) == null

 

and:

    arrayList.set(99, ninetyNine);    // throws ArrayIndexOutOfBounds

 

but:

    expandableArray.set(99, ninetyNine);
    expandableArray.get(99) == ninetyNine

 

Beta class. Classes under com.force.i18n.commons package will be moved into a dedicated project.

Author:

shansma

See Also:

Serialized Form

Constructor Summary

Constructors

Constructor and Description
ExpandableArray()
ExpandableArray(E[] m)
ExpandableArray(ExpandableArray<? extends E> m)
ExpandableArray(int initialSize)
ExpandableArray(int initialSize, float factor)

Method Summary

Modifier and Type	Method and Description
void	clear()
int	compareTo(ExpandableArray other)
static <V> ExpandableArray<V>	create(int initialSize)
boolean	equals(Object other)
E	get(int index)
int	hashCode()
Iterator<E>	iterator()
void	makeUnmodifiable() Makes the expandable array immutable.
static <T> T[]	resizeArray(T[] array, int size) Helper to resize any array.
void	set(int index, E value)
int	size() Returns 1 + the index of the highest non-null value.
static <T> T[]	subArray(T[] array, int start, int end) Helper to get the sub-array of any array.
Object[]	toArray() Returns an array containing all of the elements in this list in the correct order.
<T> T[]	toArray(Class<T> clazz) Returns an array containing all of the elements in this list in the correct order.
<T> T[]	toArray(T[] a) Returns an array containing all of the elements in this list in the correct order; the runtime type of the returned array is that of the specified array.
String	toString()
void	trimToSize() Trims the capacity of this ExpandableArray instance to be the arrays's current size.

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface java.lang.Iterable

forEach, spliterator

Constructor Detail

ExpandableArray

public ExpandableArray()

ExpandableArray

public ExpandableArray(int initialSize)

ExpandableArray

public ExpandableArray(int initialSize,
                       float factor)

ExpandableArray

public ExpandableArray(ExpandableArray<? extends E> m)

ExpandableArray

public ExpandableArray(E[] m)

Method Detail

create

public static <V> ExpandableArray<V> create(int initialSize)

makeUnmodifiable

public void makeUnmodifiable()

Makes the expandable array immutable. After setting this flag, you can't un-set it, because then it wouldn't be very immutable, would it? This is basically because I'm too lazy to make an interface that this implements and then make an UnmodifiableExpandableArray.

get

public E get(int index)

set

public void set(int index,
                E value)

trimToSize

public void trimToSize()

Trims the capacity of this ExpandableArray instance to be the arrays's current size. An application can use this operation to minimize the storage of an ExpandableArray instance.

size

public int size()

Returns 1 + the index of the highest non-null value. This is useful as an upper bound in a for loop to iterate through the values in this ExpandableArray.

clear

public void clear()

toArray

public Object[] toArray()

Returns an array containing all of the elements in this list in the correct order.

Returns:

an array containing all of the elements in this list in the correct order.

toArray

public <T> T[] toArray(T[] a)

Returns an array containing all of the elements in this list in the correct order; the runtime type of the returned array is that of the specified array. If the list fits in the specified array, it is returned therein. Otherwise, a new array is allocated with the runtime type of the specified array and the size of this list.

If the list fits in the specified array with room to spare (i.e., the array has more elements than the list), the element in the array immediately following the end of the collection is set to null. This is useful in determining the length of the list only if the caller knows that the list does not contain any null elements.

Parameters:

a - the array into which the elements of the list are to be stored, if it is big enough; otherwise, a new array of the same runtime type is allocated for this purpose.

Returns:

an array containing the elements of the list.

Throws:

ArrayStoreException - if the runtime type of a is not a supertype of the runtime type of every element in this list.

toArray

public <T> T[] toArray(Class<T> clazz)

Returns an array containing all of the elements in this list in the correct order.

Parameters:

clazz - the class of the array that should be constructed to hold the element.

Returns:

an array containing all of the elements in this list in the correct order.

toString

public String toString()

Overrides:

toString in class Object

iterator

public Iterator<E> iterator()

Specified by:

iterator in interface Iterable<E>

resizeArray

public static <T> T[] resizeArray(T[] array,
                                  int size)

Helper to resize any array. If size is exactly the length of array, it returns array. Otherwise, it will return a new array. Returns an array of size size containing the first size elements in array. If size is greater than the length of array, the remaining elements in the resulting array will be null.

subArray

public static <T> T[] subArray(T[] array,
                               int start,
                               int end)

Helper to get the sub-array of any array. If start is 0 and end is length of array, it returns array. Otherwise, it will return a new array. Returns an array containing the elements from start inclusive to end exclusive. The resulting array will be of size end - start. If end is greater than the size of the array, it will create a result array with nulls in those spots.

equals

public boolean equals(Object other)

Overrides:

equals in class Object

hashCode

public int hashCode()

Overrides:

hashCode in class Object

compareTo

public int compareTo(ExpandableArray other)

Specified by:

compareTo in interface Comparable<ExpandableArray>