|
||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Object java.util.AbstractCollection java.util.AbstractList java.util.ArrayList org.apache.commons.beanutils.LazyDynaList
public class LazyDynaList
There are two main purposes for this class:
List
with either DynaBean
, java.util.Map
or POJO Beans.All elements added to the List are stored as DynaBean
's:
java.util.Map
elements are "wrapped" in a LazyDynaMap
.
WrapDynaBean.
DynaBean
's are stored un-changed.
toArray()
The toArray()
method returns an array of the
elements of the appropriate type. If the LazyDynaList
is populated with java.util.Map
objects a
Map[]
array is returned.
If the list is populated with POJO Beans an appropriate
array of the POJO Beans is returned. Otherwise a DynaBean[]
array is returned.
toDynaBeanArray()
The toDynaBeanArray()
method returns a
DynaBean[]
array of the elements in the List.
N.B.All the elements in the List must be the
same type. If the DynaClass
or Class
of the LazyDynaList
's elements is
not specified, then it will be automatically set to the type
of the first element populated.
If you have an array of java.util.Map[]
- you can put that into
a LazyDynaList
.
TreeMap[] myArray = .... // your Map[]
List lazyList = new LazyDynaList(myArray);
New elements of the appropriate Map type are automatically populated:
// get(index) automatically grows the list
DynaBean newElement = (DynaBean)lazyList.get(lazyList.size());
newElement.put("someProperty", "someValue");
Once you've finished you can get back an Array of the elements of the appropriate type:
// Retrieve the array from the list
TreeMap[] myArray = (TreeMap[])lazyList.toArray());
Alternatively you can create an empty List and specify the Class for List's elements. The LazyDynaList uses the Class to automatically populate elements:
// e.g. For Maps
List lazyList = new LazyDynaList(TreeMap.class);
// e.g. For POJO Beans
List lazyList = new LazyDynaList(MyPojo.class);
// e.g. For DynaBeans
List lazyList = new LazyDynaList(MyDynaBean.class);
Alternatively you can create an empty List and specify the DynaClass for List's elements. The LazyDynaList uses the DynaClass to automatically populate elements:
// e.g. For Maps
DynaClass dynaClass = new LazyDynaMap(new HashMap());
List lazyList = new LazyDynaList(dynaClass);
// e.g. For POJO Beans
DynaClass dynaClass = (new WrapDynaBean(myPojo)).getDynaClass();
List lazyList = new LazyDynaList(dynaClass);
// e.g. For DynaBeans
DynaClass dynaClass = new BasicDynaClass(properties);
List lazyList = new LazyDynaList(dynaClass);
N.B. You may wonder why control the type
using a DynaClass
rather than the Class
as in the previous example - the reason is that some DynaBean
implementations don't have a default empty constructor and
therefore need to be instantiated using the DynaClass.newInstance()
method.
A slight variation - set the element type using either
the setElementType(Class)
method or the
setElementDynaClass(DynaClass)
method - then populate
with the normal java.util.List
methods(i.e.
add()
, addAll()
or set()
).
// Create a new LazyDynaList (100 element capacity)
LazyDynaList lazyList = new LazyDynaList(100);
// Either Set the element type...
lazyList.setElementType(TreeMap.class);
// ...or the element DynaClass...
lazyList.setElementDynaClass(new MyCustomDynaClass());
// Populate from a collection
lazyList.addAll(myCollection);
Field Summary |
---|
Fields inherited from class java.util.AbstractList |
---|
modCount |
Constructor Summary | |
---|---|
LazyDynaList()
Default Constructor. |
|
LazyDynaList(Class elementType)
Construct a LazyDynaList with a specified type for its elements. |
|
LazyDynaList(Collection collection)
Construct a LazyDynaList populated with the elements of a Collection. |
|
LazyDynaList(DynaClass elementDynaClass)
Construct a LazyDynaList with a specified DynaClass for its elements. |
|
LazyDynaList(int capacity)
Construct a LazyDynaList with the specified capacity. |
|
LazyDynaList(Object[] array)
Construct a LazyDynaList populated with the elements of an Array. |
Method Summary | |
---|---|
void |
add(int index,
Object element)
Insert an element at the specified index position. |
boolean |
add(Object element)
Add an element to the List. |
boolean |
addAll(Collection collection)
Add all the elements from a Collection to the list. |
boolean |
addAll(int index,
Collection collection)
Insert all the elements from a Collection into the list at a specified position. |
Object |
get(int index)
Return the element at the specified position. |
Object |
set(int index,
Object element)
Set the element at the specified position. |
void |
setElementDynaClass(DynaClass elementDynaClass)
Set the element Type and DynaClass. |
void |
setElementType(Class elementType)
Set the element Type and DynaClass. |
Object[] |
toArray()
Converts the List to an Array. |
Object[] |
toArray(Object[] model)
Converts the List to an Array of the specified type. |
DynaBean[] |
toDynaBeanArray()
Converts the List to an DynaBean Array. |
Methods inherited from class java.util.ArrayList |
---|
clear, clone, contains, ensureCapacity, indexOf, isEmpty, lastIndexOf, remove, remove, removeRange, size, trimToSize |
Methods inherited from class java.util.AbstractList |
---|
equals, hashCode, iterator, listIterator, listIterator, subList |
Methods inherited from class java.util.AbstractCollection |
---|
containsAll, removeAll, retainAll, toString |
Methods inherited from class java.lang.Object |
---|
finalize, getClass, notify, notifyAll, wait, wait, wait |
Methods inherited from interface java.util.List |
---|
containsAll, equals, hashCode, iterator, listIterator, listIterator, removeAll, retainAll, subList |
Constructor Detail |
---|
public LazyDynaList()
public LazyDynaList(int capacity)
capacity
- The initial capacity of the list.public LazyDynaList(DynaClass elementDynaClass)
elementDynaClass
- The DynaClass of the List's elements.public LazyDynaList(Class elementType)
elementType
- The Type of the List's elements.public LazyDynaList(Collection collection)
collection
- The Collection to poulate the List from.public LazyDynaList(Object[] array)
array
- The Array to poulate the List from.Method Detail |
---|
public void add(int index, Object element)
Insert an element at the specified index position.
If the index position is greater than the current size of the List, then the List is automatically grown to the appropriate size.
add
in interface List
add
in class ArrayList
index
- The index position to insert the new element.element
- The new element to add.public boolean add(Object element)
Add an element to the List.
add
in interface Collection
add
in interface List
add
in class ArrayList
element
- The new element to add.
public boolean addAll(Collection collection)
Add all the elements from a Collection to the list.
addAll
in interface Collection
addAll
in interface List
addAll
in class ArrayList
collection
- The Collection of new elements.
public boolean addAll(int index, Collection collection)
Insert all the elements from a Collection into the list at a specified position.
If the index position is greater than the current size of the List, then the List is automatically grown to the appropriate size.
addAll
in interface List
addAll
in class ArrayList
collection
- The Collection of new elements.index
- The index position to insert the new elements at.
public Object get(int index)
Return the element at the specified position.
If the position requested is greater than the current size of the List, then the List is automatically grown (and populated) to the appropriate size.
get
in interface List
get
in class ArrayList
index
- The index position to insert the new elements at.
public Object set(int index, Object element)
Set the element at the specified position.
If the position requested is greater than the current size of the List, then the List is automatically grown (and populated) to the appropriate size.
set
in interface List
set
in class ArrayList
index
- The index position to insert the new element at.element
- The new element.
public Object[] toArray()
Converts the List to an Array.
The type of Array created depends on the contents of the List:
toArray
in interface Collection
toArray
in interface List
toArray
in class ArrayList
public Object[] toArray(Object[] model)
Converts the List to an Array of the specified type.
toArray
in interface Collection
toArray
in interface List
toArray
in class ArrayList
model
- The model for the type of array to return
public DynaBean[] toDynaBeanArray()
Converts the List to an DynaBean Array.
public void setElementType(Class elementType)
Set the element Type and DynaClass.
elementType
- The type of the elements.
IllegalArgumentException
- if the List already
contains elements or the DynaClass is null.public void setElementDynaClass(DynaClass elementDynaClass)
Set the element Type and DynaClass.
elementDynaClass
- The DynaClass of the elements.
IllegalArgumentException
- if the List already
contains elements or the DynaClass is null.
|
||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |