de.tsl2.nano.collection

Class CollectionUtil

java.lang.Object

de.tsl2.nano.core.util.CollectionUtil

de.tsl2.nano.collection.CollectionUtil

public class CollectionUtil
extends CollectionUtil

some transformation und filter methods for collections

Version:

$Revision$

Author:

Thomas Schneider

Constructor Summary

Constructors

Constructor and Description
CollectionUtil()

Method Summary

Modifier and Type	Method and Description
static <K,V> Set<Map.Entry<K,V>>	asEntrySetExtender(Map<K,V> m) see MapEntrySet.
static <T> ListSet<T>	asListSet(Collection<T> listOrSet) if both interfaces (List and Set) are needed for one instance, the given collection will be wrapped into a ListSet.
static <T> T	find(Collection<T> source, Class<T> type, String attributeName, Object value) finds an entry through bean-reflection
static Collection<?>	getContainer(Object obj) if #isContainer(Object) returns true, obj is an array, collection or map. this method returns a collection where obj is wrapped into.
static <T extends Comparable<T>> Collection<T>	getFilteredBetween(Collection<T> src, T from, T to) delegates to getFilteringBetween(Iterable, Comparable, Comparable), copying the filtered list.
static <T> Collection<T>	getFilteredBetween(Collection<T> src, T from, T to, boolean ignoreCase) delegates to getFilteringBetween(Iterable, Object, Object, boolean), copying the filtered list.
static <T> Collection<T>	getFilteredCollection(Iterable<T> src, IPredicate<T> predicate)
static <I extends Iterable<T>,T> I	getFiltering(I src, IPredicate<T> filter) getFiltering
static <I extends Iterable<T>,T> I	getFiltering(I src, StringBuilder expression) filters the given collection.
static <I extends Iterable<T>,T extends Comparable<T>> I	getFilteringBetween(I src, T from, T to) filters the given collection.
static <I extends Iterable<T>,T> I	getFilteringBetween(I src, T from, T to, boolean ignoreCase) filters the given collection through its string representations.
static <I extends Map<S,T>,S,T extends Comparable<T>> I	getFilteringMapKey(I src, IPredicate<T> filter) getFiltering
static <S,T> Collection<T>	getTransformedCollection(Collection<S> toTransform, String attributeName) delegates to getTransformedCollection(Collection, String, Class).
static <S,T> Collection<T>	getTransformedCollection(Collection<S> toTransform, String attributeName, Class<T> transformedType) transform a collection.
static <I extends Iterable<T>,S,T> I	getTransforming(Iterable<S> src, ITransformer<S,T> transformer) getTransforming
static <I extends Iterable<T>,S,T> I	getTransforming(Iterable<S> src, ITransformer<S,T> transformer, IPredicate<T> filter) combines transforming and filtering a collection
static <S,T> Collection<T>	next(Iterator<S> elements, int count, ITransformer<S,T> transformer) iterates through next count elements and returns a new sublist containing them. useful for performance optimizations sending statements to a server. if you don't need a transformer you may use List.sublist(..)
static <T> T	remove(Collection<T> source, Class<T> type, String attributeName, Object value) remove
static <S> Collection<String>	toStringTransformed(Collection<S> toTransform)
static <T> Collection<?>	wrap(Collection<T> source, Class<T> type, String attributeName) wrap source collection holding instances of type 'type' into a new collection - holding values given by attributeName.

Methods inherited from class de.tsl2.nano.core.util.CollectionUtil

addAll, asArray, asList, asListCombined, asStandardArrayList, concat, concat, concatNew, contains, copy, copyOfRange, copyOfRange, findEnum, fuzzyFind, get, getEnumNames, getEnumValues, getList, getSortedList, getSortedList, getSortedList, hasNoValues, indexOf, load, removeEmptyEntries, split, swap, write

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

CollectionUtil

public CollectionUtil()

Method Detail

asListSet

public static final <T> ListSet<T> asListSet(Collection<T> listOrSet)

if both interfaces (List and Set) are needed for one instance, the given collection will be wrapped into a ListSet.

Type Parameters:

T - item type

Parameters:

listOrSet - implementation of List or Set to be combined in a new instance of ListSet.

Returns:

new instanceof ListSet.

TODO: how to create generics expression to define Set or List like: , L extends List> with listOrSet ?

getTransformedCollection

public static <S,T> Collection<T> getTransformedCollection(Collection<S> toTransform,
                                                           String attributeName)

delegates to getTransformedCollection(Collection, String, Class).

getTransformedCollection

public static <S,T> Collection<T> getTransformedCollection(Collection<S> toTransform,
                                                           String attributeName,
                                                           Class<T> transformedType)

transform a collection.

Type Parameters:

S - real type of collection items

T - transformed type of collection items

Parameters:

toTransform - original collection

attributeName - attribute name to use to get the transformed type

Returns:

transformed collection

toStringTransformed

public static <S> Collection<String> toStringTransformed(Collection<S> toTransform)

getFilteredCollection

public static <T> Collection<T> getFilteredCollection(Iterable<T> src,
                                                      IPredicate<T> predicate)

Parameters:

src - full collection

predicate - filter

Returns:

filtering collection

remove

public static final <T> T remove(Collection<T> source,
                                 Class<T> type,
                                 String attributeName,
                                 Object value)

remove

Type Parameters:

T - collection type

Parameters:

source - source collection

attributeName - attribute name of type

value - value to search to be removed

Returns:

removed item or null, if remove failed

find

public static final <T> T find(Collection<T> source,
                               Class<T> type,
                               String attributeName,
                               Object value)

finds an entry through bean-reflection

Type Parameters:

T - collection type

Parameters:

source - source collection

attributeName - attribute name of type

value - value to search to be found

Returns:

found item or null

wrap

public static final <T> Collection<?> wrap(Collection<T> source,
                                           Class<T> type,
                                           String attributeName)

wrap source collection holding instances of type 'type' into a new collection - holding values given by attributeName.

Type Parameters:

T - source collection item type

Parameters:

source - source collection

type - source collection type

attributeName - attribute of source collection item to get the value as wrapper stored in the new collection

Returns:

new collection holding wrapped item instances

next

public static final <S,T> Collection<T> next(Iterator<S> elements,
                                             int count,
                                             ITransformer<S,T> transformer)

iterates through next count elements and returns a new sublist containing them. useful for performance optimizations sending statements to a server. if you don't need a transformer you may use List.sublist(..) instead.

Example:

 Collection myEntities = null;
 Iterator<MySearchViewBean> searchIt = akten.iterator();
 ITransformer<MySearchViewBean, Long> toNumbers = new ITransformer<MySearchViewBean, Long>() {
     @Override
     public Long transform(MySearchViewBean arg0) {
         return arg0.getSpecificNumber();
     }
 };
 for (Collection<Long> specNumbers = CollectionUtil.next(searchIt, blockSize, toNumbers); searchIt.hasNext(); specNumbers = CollectionUtil.next(searchIt,
     blockSize,
     toNumbers)) {
     myEntities = myService.getMyEntityBeans(specNumbers);
     ...
 }
 
 

Type Parameters:

T - element type

Parameters:

elements - iterator on each next call this iterator should be the identical instance!

count - block size for. will be the size of the returned sub list

transformer - (optional) to transform the items of elements to the type T to be filled into the new list.

Returns:

sublist

getFilteredBetween

public static final <T extends Comparable<T>> Collection<T> getFilteredBetween(Collection<T> src,
                                                                               T from,
                                                                               T to)

delegates to getFilteringBetween(Iterable, Comparable, Comparable), copying the filtered list.

getFilteredBetween

public static final <T> Collection<T> getFilteredBetween(Collection<T> src,
                                                         T from,
                                                         T to,
                                                         boolean ignoreCase)

delegates to getFilteringBetween(Iterable, Object, Object, boolean), copying the filtered list.

getFiltering

public static final <I extends Iterable<T>,T> I getFiltering(I src,
                                                             IPredicate<T> filter)

getFiltering

Parameters:

src - collection to filter

filter - filter

Returns:

filtering collection

getFilteringMapKey

public static final <I extends Map<S,T>,S,T extends Comparable<T>> I getFilteringMapKey(I src,
                                                                                        IPredicate<T> filter)

getFiltering

Parameters:

src - map to filter

filter - key filter

Returns:

filtering map

getFiltering

public static final <I extends Iterable<T>,T> I getFiltering(I src,
                                                             StringBuilder expression)

filters the given collection.

Attention: if 'expression' changes afterwards, the collection iterator may change, too! If you do not want that, use {@link #getList(Iterator) to create a copy.

Type Parameters:

T - collection item type

Parameters:

src - collection to filter

expression - regular expression to be used as filter. the toString() methods of objects will be used to match against.

Returns:

filtered collection

getFilteringBetween

public static final <I extends Iterable<T>,T extends Comparable<T>> I getFilteringBetween(I src,
                                                                                          T from,
                                                                                          T to)

filters the given collection.

Attention: if 'from' or 'to' are mutables and change afterwards, the collection iterator may change, too! If you do not want that, use CollectionUtil.getList(Iterator) to create a copy.

Type Parameters:

T - collection item type

Parameters:

src - collection to filter

from - minimum object

to - maximum object

Returns:

filtered collection

getFilteringBetween

public static final <I extends Iterable<T>,T> I getFilteringBetween(I src,
                                                                    T from,
                                                                    T to,
                                                                    boolean ignoreCase)

filters the given collection through its string representations.

Attention: if 'from' or 'to' are mutables and change afterwards, the collection iterator may change, too! If you do not want that, use CollectionUtil.getList(Iterator) to create a copy.

Type Parameters:

T - collection item type

Parameters:

src - collection to filter

from - minimum object

to - maximum object

Returns:

filtered collection

getTransforming

public static final <I extends Iterable<T>,S,T> I getTransforming(Iterable<S> src,
                                                                  ITransformer<S,T> transformer)

getTransforming

Type Parameters:

I - iterable type

T - iterable content type

Parameters:

src - mostly a collection

transformer - transformer

Returns:

proxied iterable giving TransformingIterator as iterator.

getTransforming

public static final <I extends Iterable<T>,S,T> I getTransforming(Iterable<S> src,
                                                                  ITransformer<S,T> transformer,
                                                                  IPredicate<T> filter)

combines transforming and filtering a collection

Type Parameters:

I - iterable type

T - iterable content type

Parameters:

src - mostly a collection

transformer - transformer

filter - filter

Returns:

filtered and transformed iterable

asEntrySetExtender

public static <K,V> Set<Map.Entry<K,V>> asEntrySetExtender(Map<K,V> m)

see MapEntrySet.

Parameters:

m - map to wrap into a proxy to combine the both interfaces List and Map.

Returns:

proxy implementing both interfaces through delegation.

getContainer

public static final Collection<?> getContainer(Object obj)

if #isContainer(Object) returns true, obj is an array, collection or map. this method returns a collection where obj is wrapped into.

Parameters:

obj -

Returns: