CheapArray (Apache Flex - FlexJS: Compiler: Parent 0.8.0-SNAPSHOT API)

java.lang.Object
- org.apache.flex.utils.CheapArray

```
public class CheapArray
extends Object
```
A set of functions for managing Arrays of Objects in a memory efficient way. This class is a memory-efficient alternative to using ArrayList to manage an array of objects. It is applicable when you have a List that is initially populated with some items, and then lives for a long time without any further changes. Usage: Instead of this ArrayList-based code: // Populate the array List array = new ArrayList(n); array.add(item1); array.add(item2); // Use the data s = array.size(); item = array.get(i); you can use this CheapArray-based code // Populate the array Object array = CheapArray.create(n); CheapArray.add(item1, array); CheapArray.add(item2, array); array = CheapArray.optimize(Object, new MyItemType[0]); // Use the data s = CheapArray.size(array); item = CheapArray.get(i, array); The code for List is cleaner, but there is a benefit to using CheapArray. The difference between CheapArray and ArrayList is this: each time you use ArrayList, you get two java objects: the ArrayList, and the Object[] that it contains. Each ArrayList object occupies 24 bytes of memory. A CheapArray, on the other hand, is typed as Object, and is represented by an ArrayList while the array is being populated, and as an Object[] thereafter. The 24 byte overhead is only incurred transiently, while the array is being populated; the long-term memory cost is for the Object[] only. For convenience, we will use the term "cheapArray" to refer to Objects that are returned by create() and optimize(), even though they are not technically instances of CheapArray. Not keeping the ArrayList object around gives a significant memory usage improvement. As of May 2006, the codemodel tree for a medium size test application (doradoSmall), plus the codemodel tree for the Flex framework (frameworks.swc) had almost 8 megabytes of ArrayList objects. By converting a few key data structures (in NodeBase and its subclasses) to use CheapArray instead of ArrayList, most of that 8 mb of usage has been eliminated.

Method Summary

Methods
Modifier and Type	Method and Description
`static void`	`add(int index, Object item, Object array)` Adds an item to a cheapArray at a specific position.
`static void`	`add(Object item, Object array)` Adds an item to a cheapArray.
`static Object`	`add(Object item, Object array, Object[] emptyArray)` Adds an item to a cheapArray.
`static Object`	`create(int initialCapacity)` Create a new cheapArray.
`static Object`	`get(int i, Object array)` Get a particular item from a cheapArray.
`static Object`	`optimize(Object array, Object[] emptyArray)` Optimize the cheapArray so it uses the minimum possible memory.
`static void`	`remove(Object item, Object array)` Remove an item from a cheapArray.
`static Object`	`remove(Object item, Object array, Object[] emptyArray)` Remove an item from a cheapArray.
`static void`	`replace(int index, Object item, Object array)` Replaces the item at the given index in the passed in array
`static int`	`size(Object array)` Get the number of items of a cheapArray.
`static void`	`sort(Object array, Comparator comparator)` Sorts the given array based on a comparator
`static Object[]`	`toArray(Object array, Object[] emptyArray)` Fetch the contents of a cheapArray.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Method Detail
  - create
```
public static Object create(int initialCapacity)
```
    Create a new cheapArray. Use instead of "new ArrayList(initialCapacity)".
    
    Parameters:
    initialCapacity - the initial capacity of the cheapArray.
    
    Returns:
    a 'cheapArray' Object that you can use as the "array" parameter in calls to other CheapArray functions.
  - toArray
```
public static Object[] toArray(Object array,
               Object[] emptyArray)
```
    Fetch the contents of a cheapArray. Use instead of List.toArray().
    
    Parameters:
    array - a cheapArray
    emptyArray - a zero-length array. The array returned by this function will be the same runtime type as this parameter.
    
    Returns:
    an array containing all the items of the cheapArray.
  - size
```
public static int size(Object array)
```
    Get the number of items of a cheapArray. Use instead of List.size().
    
    Parameters:
    array - a cheapArray
    
    Returns:
    the number of items
  - get
```
public static Object get(int i,
         Object array)
```
    Get a particular item from a cheapArray. Use instead of List.get().
    
    Parameters:
    i - the item's index
    array - a cheapArray
    
    Returns:
    the specified item
  - add
```
public static void add(Object item,
       Object array)
```
    Adds an item to a cheapArray. This is only allowed before the array is optimized. Use instead of List.add().
    
    Parameters:
    item - the item to add
    array - a cheapArray
  - sort
```
public static void sort(Object array,
        Comparator comparator)
```
    Sorts the given array based on a comparator
    
    Parameters:
    array - the array to sort
    comparator - a comparator
  - add
```
public static Object add(Object item,
         Object array,
         Object[] emptyArray)
```
    Adds an item to a cheapArray. This can be used either before or after the array is optimized. Use instead of List.add().
    
    Parameters:
    item - the item to add
    array - a cheapArray
    
    Returns:
    a new 'cheapArray' Object that replaces the old instance
  - add
```
public static void add(int index,
       Object item,
       Object array)
```
    Adds an item to a cheapArray at a specific position. This is only allowed before the array is optimized. Use instead of List.add().
    
    Parameters:
    index - the position at which to add the item
    item - the item to add
    array - a cheapArray
  - replace
```
public static void replace(int index,
           Object item,
           Object array)
```
    Replaces the item at the given index in the passed in array
    
    Parameters:
    index - the index to replace at
    item - the item to use as a replacement
    array - the array to operate on
  - remove
```
public static void remove(Object item,
          Object array)
```
    Remove an item from a cheapArray. This is only allowed before the array is optimized. Use instead of List.remove().
    
    Parameters:
    item - the item to remove
    array - a cheapArray
  - remove
```
public static Object remove(Object item,
            Object array,
            Object[] emptyArray)
```
    Remove an item from a cheapArray. This can be used either before or after the array is optimized. Use instead of List.remove().
    
    Parameters:
    item - the item to remove
    array - a cheapArray
  - optimize
```
public static Object optimize(Object array,
              Object[] emptyArray)
```
    Optimize the cheapArray so it uses the minimum possible memory. Use this after the array has been populated with all of its data. After this call, you cannot use add() or remove() on the cheapArray. Use instead of ArrayList.trimToSize().
    
    Parameters:
    array - a cheapArray
    emptyArray - a zero-length array. The array returned by this function will be the same runtime type as this parameter.
    
    Returns:
    a 'cheapArray' Object that you can use as the "array" parameter in calls to CheapArray functions.

Class CheapArray

Method Summary

Methods inherited from class java.lang.Object

Method Detail

create

toArray

size

get

add

sort

add

add

replace

remove

remove

optimize