sharin.unlinq
Class BasicDictionary<TKey,TValue>

java.lang.Object
  extended by sharin.unlinq.BasicDictionary<TKey,TValue>
All Implemented Interfaces:
Iterable<Map.Entry<TKey,TValue>>, Map<TKey,TValue>, Dictionary<TKey,TValue>, Enumerable<Map.Entry<TKey,TValue>>

public class BasicDictionary<TKey,TValue>
extends Object
implements Dictionary<TKey,TValue>


Nested Class Summary
 
Nested classes/interfaces inherited from interface java.util.Map
Map.Entry<K,V>
 
Constructor Summary
BasicDictionary()
           
BasicDictionary(Map<TKey,TValue> map)
           
 
Method Summary
<A> A
aggregate(A seed, Func2<A,Map.Entry<TKey,TValue>,A> func)
           
<A,R> R
aggregate(A seed, Func2<A,Map.Entry<TKey,TValue>,A> func, Func<A,R> resultSelector)
           
 Map.Entry<TKey,TValue> aggregate(Func2<Map.Entry<TKey,TValue>,Map.Entry<TKey,TValue>,Map.Entry<TKey,TValue>> func)
           
 Boolean all(Func<Map.Entry<TKey,TValue>,Boolean> predicate)
           
 Boolean any()
           
 Boolean any(Func<Map.Entry<TKey,TValue>,Boolean> predicate)
           
 double average()
           
 double average(Func<Map.Entry<TKey,TValue>,Integer> selector)
           
 double averageDouble()
           
 double averageDouble(Func<Map.Entry<TKey,TValue>,Double> selector)
           
 float averageFloat()
           
 float averageFloat(Func<Map.Entry<TKey,TValue>,Float> selector)
           
 double averageLong()
           
 double averageLong(Func<Map.Entry<TKey,TValue>,Long> selector)
           
<R> Enumerable<R>
cast(Class<R> resultClass)
           
 void clear()
           
 Enumerable<Map.Entry<TKey,TValue>> concat(Enumerable<Map.Entry<TKey,TValue>> second)
           
 boolean contains(Object o)
           
 boolean containsKey(Object key)
           
 boolean containsValue(Object value)
           
 int count()
           
 int count(Func<Map.Entry<TKey,TValue>,Boolean> predicate)
           
 Enumerable<Map.Entry<TKey,TValue>> defaultIfEmpty()
           
 Enumerable<Map.Entry<TKey,TValue>> defaultIfEmpty(Map.Entry<TKey,TValue> defaultValue)
           
 Enumerable<Map.Entry<TKey,TValue>> distinct()
           
 Map.Entry<TKey,TValue> elementAt(int index)
           
 Map.Entry<TKey,TValue> elementAtOrDefault(int index)
           
 Map.Entry<TKey,TValue> elementAtOrDefault(int index, Map.Entry<TKey,TValue> defaultValue)
           
 Set<Map.Entry<TKey,TValue>> entrySet()
           
 Enumerable<Map.Entry<TKey,TValue>> except(Enumerable<Map.Entry<TKey,TValue>> second)
           
 Map.Entry<TKey,TValue> first()
           
 Map.Entry<TKey,TValue> first(Func<Map.Entry<TKey,TValue>,Boolean> predicate)
           
 Map.Entry<TKey,TValue> firstOrDefault()
           
 Map.Entry<TKey,TValue> firstOrDefault(Func<Map.Entry<TKey,TValue>,Boolean> predicate)
           
 Map.Entry<TKey,TValue> firstOrDefault(Func<Map.Entry<TKey,TValue>,Boolean> predicate, Map.Entry<TKey,TValue> defaultValue)
           
 Map.Entry<TKey,TValue> firstOrDefault(Map.Entry<TKey,TValue> defaultValue)
           
 TValue get(Object key)
           
<K> Enumerable<Grouping<K,Map.Entry<TKey,TValue>>>
groupBy(Func<Map.Entry<TKey,TValue>,K> keySelector)
           
<K,E> Enumerable<Grouping<K,E>>
groupBy(Func<Map.Entry<TKey,TValue>,K> keySelector, Func<Map.Entry<TKey,TValue>,E> elementSelector)
           
<K,E,R> Enumerable<R>
groupBy(Func<Map.Entry<TKey,TValue>,K> keySelector, Func<Map.Entry<TKey,TValue>,E> elementSelector, Func2<K,Enumerable<E>,R> resultSelector)
           
<K,R> Enumerable<R>
groupBy(Func<Map.Entry<TKey,TValue>,K> keySelector, Func2<K,Enumerable<Map.Entry<TKey,TValue>>,R> resultSelector)
           
<I,K,R> Enumerable<R>
groupJoin(Enumerable<I> inner, Func<Map.Entry<TKey,TValue>,K> outerKeySelector, Func<I,K> innerKeySelector, Func2<Map.Entry<TKey,TValue>,Enumerable<I>,R> resultSelector)
           
 Enumerable<Map.Entry<TKey,TValue>> intersect(Enumerable<Map.Entry<TKey,TValue>> second)
           
 boolean isEmpty()
           
 Iterator<Map.Entry<TKey,TValue>> iterator()
           
<I,K,R> Enumerable<R>
join(Enumerable<I> inner, Func<Map.Entry<TKey,TValue>,K> outerKeySelector, Func<I,K> innerKeySelector, Func2<Map.Entry<TKey,TValue>,I,R> resultSelector)
           
 Set<TKey> keySet()
           
 Map.Entry<TKey,TValue> last()
           
 Map.Entry<TKey,TValue> last(Func<Map.Entry<TKey,TValue>,Boolean> predicate)
           
 Map.Entry<TKey,TValue> lastOrDefault()
           
 Map.Entry<TKey,TValue> lastOrDefault(Func<Map.Entry<TKey,TValue>,Boolean> predicate)
           
 Map.Entry<TKey,TValue> lastOrDefault(Func<Map.Entry<TKey,TValue>,Boolean> predicate, Map.Entry<TKey,TValue> defaultValue)
           
 Map.Entry<TKey,TValue> lastOrDefault(Map.Entry<TKey,TValue> defaultValue)
           
 long longCount()
           
 long longCount(Func<Map.Entry<TKey,TValue>,Boolean> predicate)
           
 Map.Entry<TKey,TValue> max()
           
<R extends Comparable<R>>
R
max(Func<Map.Entry<TKey,TValue>,R> selector)
           
 Map.Entry<TKey,TValue> min()
           
<R extends Comparable<R>>
R
min(Func<Map.Entry<TKey,TValue>,R> selector)
           
<R> Enumerable<R>
ofType(Class<R> resultClass)
           
<K> OrderedEnumerable<Map.Entry<TKey,TValue>>
orderBy(Func<Map.Entry<TKey,TValue>,K> keySelector)
           
<K> OrderedEnumerable<Map.Entry<TKey,TValue>>
orderBy(Func<Map.Entry<TKey,TValue>,K> keySelector, Comparator<K> comparator)
           
<K> OrderedEnumerable<Map.Entry<TKey,TValue>>
orderByDescending(Func<Map.Entry<TKey,TValue>,K> keySelector)
           
<K> OrderedEnumerable<Map.Entry<TKey,TValue>>
orderByDescending(Func<Map.Entry<TKey,TValue>,K> keySelector, Comparator<K> comparator)
           
 TValue put(TKey key, TValue value)
           
 void putAll(Map<? extends TKey,? extends TValue> t)
           
 TValue remove(Object key)
           
 Enumerable<Map.Entry<TKey,TValue>> reverse()
           
<R> Enumerable<R>
select(Func<Map.Entry<TKey,TValue>,R> selector)
           
<R> Enumerable<R>
select(Func2<Map.Entry<TKey,TValue>,Integer,R> selector)
           
<C,R> Enumerable<R>
selectMany(Func<Map.Entry<TKey,TValue>,Enumerable<C>> collectionSelector, Func2<Map.Entry<TKey,TValue>,C,R> resultSelector)
           
<R> Enumerable<R>
selectMany(Func<Map.Entry<TKey,TValue>,Enumerable<R>> selector)
           
<C,R> Enumerable<R>
selectMany(Func2<Map.Entry<TKey,TValue>,Integer,Enumerable<C>> collectionSelector, Func2<Map.Entry<TKey,TValue>,C,R> resultSelector)
           
<R> Enumerable<R>
selectMany(Func2<Map.Entry<TKey,TValue>,Integer,Enumerable<R>> selector)
           
 Boolean sequenceEqual(Enumerable<Map.Entry<TKey,TValue>> second)
           
 Map.Entry<TKey,TValue> single()
           
 Map.Entry<TKey,TValue> single(Func<Map.Entry<TKey,TValue>,Boolean> predicate)
           
 Map.Entry<TKey,TValue> singleOrDefault()
           
 Map.Entry<TKey,TValue> singleOrDefault(Func<Map.Entry<TKey,TValue>,Boolean> predicate)
           
 Map.Entry<TKey,TValue> singleOrDefault(Func<Map.Entry<TKey,TValue>,Boolean> predicate, Map.Entry<TKey,TValue> defaultValue)
           
 Map.Entry<TKey,TValue> singleOrDefault(Map.Entry<TKey,TValue> defaultValue)
           
 int size()
           
 Enumerable<Map.Entry<TKey,TValue>> skip(int count)
           
 Enumerable<Map.Entry<TKey,TValue>> skipWhile(Func<Map.Entry<TKey,TValue>,Boolean> predicate)
           
 Enumerable<Map.Entry<TKey,TValue>> skipWhile(Func2<Map.Entry<TKey,TValue>,Integer,Boolean> predicate)
           
 int sum()
           
 int sum(Func<Map.Entry<TKey,TValue>,Integer> selector)
           
 double sumDouble()
           
 double sumDouble(Func<Map.Entry<TKey,TValue>,Double> selector)
           
 float sumFloat()
           
 float sumFloat(Func<Map.Entry<TKey,TValue>,Float> selector)
           
 long sumLong()
           
 long sumLong(Func<Map.Entry<TKey,TValue>,Long> selector)
           
 Enumerable<Map.Entry<TKey,TValue>> take(int count)
           
 Enumerable<Map.Entry<TKey,TValue>> takeWhile(Func<Map.Entry<TKey,TValue>,Boolean> predicate)
           
 Enumerable<Map.Entry<TKey,TValue>> takeWhile(Func2<Map.Entry<TKey,TValue>,Integer,Boolean> predicate)
           
 Object[] toArray()
           
<R> R[]
toArray(Class<R> resultClass)
           
<K> Dictionary<K,Map.Entry<TKey,TValue>>
toDictionary(Func<Map.Entry<TKey,TValue>,K> keySelector)
           
<K,E> Dictionary<K,E>
toDictionary(Func<Map.Entry<TKey,TValue>,K> keySelector, Func<Map.Entry<TKey,TValue>,E> elementSelector)
           
 EnumerableList<Map.Entry<TKey,TValue>> toEnumerableList()
           
 List<Map.Entry<TKey,TValue>> toList()
           
<K> Map<K,List<Map.Entry<TKey,TValue>>>
toListMap(Func<Map.Entry<TKey,TValue>,K> keySelector)
           
<K,E> Map<K,List<E>>
toListMap(Func<Map.Entry<TKey,TValue>,K> keySelector, Func<Map.Entry<TKey,TValue>,E> elementSelector)
           
<K> Lookup<K,Map.Entry<TKey,TValue>>
toLookup(Func<Map.Entry<TKey,TValue>,K> keySelector)
           
<K,E> Lookup<K,E>
toLookup(Func<Map.Entry<TKey,TValue>,K> keySelector, Func<Map.Entry<TKey,TValue>,E> elementSelector)
           
<K> Map<K,Map.Entry<TKey,TValue>>
toMap(Func<Map.Entry<TKey,TValue>,K> keySelector)
           
<K,E> Map<K,E>
toMap(Func<Map.Entry<TKey,TValue>,K> keySelector, Func<Map.Entry<TKey,TValue>,E> elementSelector)
           
 String toString()
           
 Enumerable<Map.Entry<TKey,TValue>> union(Enumerable<Map.Entry<TKey,TValue>> second)
           
 Collection<TValue> values()
           
 Enumerable<Map.Entry<TKey,TValue>> where(Func<Map.Entry<TKey,TValue>,Boolean> predicate)
           
 Enumerable<Map.Entry<TKey,TValue>> where(Func2<Map.Entry<TKey,TValue>,Integer,Boolean> predicate)
           
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
 
Methods inherited from interface java.util.Map
equals, hashCode
 

Constructor Detail

BasicDictionary

public BasicDictionary()

BasicDictionary

public BasicDictionary(Map<TKey,TValue> map)
Method Detail

toString

public String toString()
Overrides:
toString in class Object

clear

public void clear()
Specified by:
clear in interface Map<TKey,TValue>

containsKey

public boolean containsKey(Object key)
Specified by:
containsKey in interface Map<TKey,TValue>

containsValue

public boolean containsValue(Object value)
Specified by:
containsValue in interface Map<TKey,TValue>

entrySet

public Set<Map.Entry<TKey,TValue>> entrySet()
Specified by:
entrySet in interface Map<TKey,TValue>

get

public TValue get(Object key)
Specified by:
get in interface Map<TKey,TValue>

isEmpty

public boolean isEmpty()
Specified by:
isEmpty in interface Map<TKey,TValue>

keySet

public Set<TKey> keySet()
Specified by:
keySet in interface Map<TKey,TValue>

put

public TValue put(TKey key,
                  TValue value)
Specified by:
put in interface Map<TKey,TValue>

putAll

public void putAll(Map<? extends TKey,? extends TValue> t)
Specified by:
putAll in interface Map<TKey,TValue>

remove

public TValue remove(Object key)
Specified by:
remove in interface Map<TKey,TValue>

size

public int size()
Specified by:
size in interface Map<TKey,TValue>

values

public Collection<TValue> values()
Specified by:
values in interface Map<TKey,TValue>

aggregate

public <A,R> R aggregate(A seed,
                         Func2<A,Map.Entry<TKey,TValue>,A> func,
                         Func<A,R> resultSelector)
Specified by:
aggregate in interface Enumerable<Map.Entry<TKey,TValue>>

aggregate

public <A> A aggregate(A seed,
                       Func2<A,Map.Entry<TKey,TValue>,A> func)
Specified by:
aggregate in interface Enumerable<Map.Entry<TKey,TValue>>

aggregate

public Map.Entry<TKey,TValue> aggregate(Func2<Map.Entry<TKey,TValue>,Map.Entry<TKey,TValue>,Map.Entry<TKey,TValue>> func)
Specified by:
aggregate in interface Enumerable<Map.Entry<TKey,TValue>>

all

public Boolean all(Func<Map.Entry<TKey,TValue>,Boolean> predicate)
Specified by:
all in interface Enumerable<Map.Entry<TKey,TValue>>

any

public Boolean any()
Specified by:
any in interface Enumerable<Map.Entry<TKey,TValue>>

any

public Boolean any(Func<Map.Entry<TKey,TValue>,Boolean> predicate)
Specified by:
any in interface Enumerable<Map.Entry<TKey,TValue>>

average

public double average()
Specified by:
average in interface Enumerable<Map.Entry<TKey,TValue>>

average

public double average(Func<Map.Entry<TKey,TValue>,Integer> selector)
Specified by:
average in interface Enumerable<Map.Entry<TKey,TValue>>

averageDouble

public double averageDouble()
Specified by:
averageDouble in interface Enumerable<Map.Entry<TKey,TValue>>

averageDouble

public double averageDouble(Func<Map.Entry<TKey,TValue>,Double> selector)
Specified by:
averageDouble in interface Enumerable<Map.Entry<TKey,TValue>>

averageFloat

public float averageFloat()
Specified by:
averageFloat in interface Enumerable<Map.Entry<TKey,TValue>>

averageFloat

public float averageFloat(Func<Map.Entry<TKey,TValue>,Float> selector)
Specified by:
averageFloat in interface Enumerable<Map.Entry<TKey,TValue>>

averageLong

public double averageLong()
Specified by:
averageLong in interface Enumerable<Map.Entry<TKey,TValue>>

averageLong

public double averageLong(Func<Map.Entry<TKey,TValue>,Long> selector)
Specified by:
averageLong in interface Enumerable<Map.Entry<TKey,TValue>>

cast

public <R> Enumerable<R> cast(Class<R> resultClass)
Specified by:
cast in interface Enumerable<Map.Entry<TKey,TValue>>

concat

public Enumerable<Map.Entry<TKey,TValue>> concat(Enumerable<Map.Entry<TKey,TValue>> second)
Specified by:
concat in interface Enumerable<Map.Entry<TKey,TValue>>

contains

public boolean contains(Object o)
Specified by:
contains in interface Enumerable<Map.Entry<TKey,TValue>>

count

public int count()
Specified by:
count in interface Enumerable<Map.Entry<TKey,TValue>>

count

public int count(Func<Map.Entry<TKey,TValue>,Boolean> predicate)
Specified by:
count in interface Enumerable<Map.Entry<TKey,TValue>>

defaultIfEmpty

public Enumerable<Map.Entry<TKey,TValue>> defaultIfEmpty()
Specified by:
defaultIfEmpty in interface Enumerable<Map.Entry<TKey,TValue>>

defaultIfEmpty

public Enumerable<Map.Entry<TKey,TValue>> defaultIfEmpty(Map.Entry<TKey,TValue> defaultValue)
Specified by:
defaultIfEmpty in interface Enumerable<Map.Entry<TKey,TValue>>

distinct

public Enumerable<Map.Entry<TKey,TValue>> distinct()
Specified by:
distinct in interface Enumerable<Map.Entry<TKey,TValue>>

elementAt

public Map.Entry<TKey,TValue> elementAt(int index)
Specified by:
elementAt in interface Enumerable<Map.Entry<TKey,TValue>>

elementAtOrDefault

public Map.Entry<TKey,TValue> elementAtOrDefault(int index,
                                                 Map.Entry<TKey,TValue> defaultValue)
Specified by:
elementAtOrDefault in interface Enumerable<Map.Entry<TKey,TValue>>

elementAtOrDefault

public Map.Entry<TKey,TValue> elementAtOrDefault(int index)
Specified by:
elementAtOrDefault in interface Enumerable<Map.Entry<TKey,TValue>>

except

public Enumerable<Map.Entry<TKey,TValue>> except(Enumerable<Map.Entry<TKey,TValue>> second)
Specified by:
except in interface Enumerable<Map.Entry<TKey,TValue>>

first

public Map.Entry<TKey,TValue> first()
Specified by:
first in interface Enumerable<Map.Entry<TKey,TValue>>

first

public Map.Entry<TKey,TValue> first(Func<Map.Entry<TKey,TValue>,Boolean> predicate)
Specified by:
first in interface Enumerable<Map.Entry<TKey,TValue>>

firstOrDefault

public Map.Entry<TKey,TValue> firstOrDefault()
Specified by:
firstOrDefault in interface Enumerable<Map.Entry<TKey,TValue>>

firstOrDefault

public Map.Entry<TKey,TValue> firstOrDefault(Map.Entry<TKey,TValue> defaultValue)
Specified by:
firstOrDefault in interface Enumerable<Map.Entry<TKey,TValue>>

firstOrDefault

public Map.Entry<TKey,TValue> firstOrDefault(Func<Map.Entry<TKey,TValue>,Boolean> predicate,
                                             Map.Entry<TKey,TValue> defaultValue)
Specified by:
firstOrDefault in interface Enumerable<Map.Entry<TKey,TValue>>

firstOrDefault

public Map.Entry<TKey,TValue> firstOrDefault(Func<Map.Entry<TKey,TValue>,Boolean> predicate)
Specified by:
firstOrDefault in interface Enumerable<Map.Entry<TKey,TValue>>

groupBy

public <K,E,R> Enumerable<R> groupBy(Func<Map.Entry<TKey,TValue>,K> keySelector,
                                     Func<Map.Entry<TKey,TValue>,E> elementSelector,
                                     Func2<K,Enumerable<E>,R> resultSelector)
Specified by:
groupBy in interface Enumerable<Map.Entry<TKey,TValue>>

groupBy

public <K,E> Enumerable<Grouping<K,E>> groupBy(Func<Map.Entry<TKey,TValue>,K> keySelector,
                                               Func<Map.Entry<TKey,TValue>,E> elementSelector)
Specified by:
groupBy in interface Enumerable<Map.Entry<TKey,TValue>>

groupBy

public <K,R> Enumerable<R> groupBy(Func<Map.Entry<TKey,TValue>,K> keySelector,
                                   Func2<K,Enumerable<Map.Entry<TKey,TValue>>,R> resultSelector)
Specified by:
groupBy in interface Enumerable<Map.Entry<TKey,TValue>>

groupBy

public <K> Enumerable<Grouping<K,Map.Entry<TKey,TValue>>> groupBy(Func<Map.Entry<TKey,TValue>,K> keySelector)
Specified by:
groupBy in interface Enumerable<Map.Entry<TKey,TValue>>

groupJoin

public <I,K,R> Enumerable<R> groupJoin(Enumerable<I> inner,
                                       Func<Map.Entry<TKey,TValue>,K> outerKeySelector,
                                       Func<I,K> innerKeySelector,
                                       Func2<Map.Entry<TKey,TValue>,Enumerable<I>,R> resultSelector)
Specified by:
groupJoin in interface Enumerable<Map.Entry<TKey,TValue>>

intersect

public Enumerable<Map.Entry<TKey,TValue>> intersect(Enumerable<Map.Entry<TKey,TValue>> second)
Specified by:
intersect in interface Enumerable<Map.Entry<TKey,TValue>>

iterator

public Iterator<Map.Entry<TKey,TValue>> iterator()
Specified by:
iterator in interface Iterable<Map.Entry<TKey,TValue>>

join

public <I,K,R> Enumerable<R> join(Enumerable<I> inner,
                                  Func<Map.Entry<TKey,TValue>,K> outerKeySelector,
                                  Func<I,K> innerKeySelector,
                                  Func2<Map.Entry<TKey,TValue>,I,R> resultSelector)
Specified by:
join in interface Enumerable<Map.Entry<TKey,TValue>>

last

public Map.Entry<TKey,TValue> last()
Specified by:
last in interface Enumerable<Map.Entry<TKey,TValue>>

last

public Map.Entry<TKey,TValue> last(Func<Map.Entry<TKey,TValue>,Boolean> predicate)
Specified by:
last in interface Enumerable<Map.Entry<TKey,TValue>>

lastOrDefault

public Map.Entry<TKey,TValue> lastOrDefault()
Specified by:
lastOrDefault in interface Enumerable<Map.Entry<TKey,TValue>>

lastOrDefault

public Map.Entry<TKey,TValue> lastOrDefault(Map.Entry<TKey,TValue> defaultValue)
Specified by:
lastOrDefault in interface Enumerable<Map.Entry<TKey,TValue>>

lastOrDefault

public Map.Entry<TKey,TValue> lastOrDefault(Func<Map.Entry<TKey,TValue>,Boolean> predicate,
                                            Map.Entry<TKey,TValue> defaultValue)
Specified by:
lastOrDefault in interface Enumerable<Map.Entry<TKey,TValue>>

lastOrDefault

public Map.Entry<TKey,TValue> lastOrDefault(Func<Map.Entry<TKey,TValue>,Boolean> predicate)
Specified by:
lastOrDefault in interface Enumerable<Map.Entry<TKey,TValue>>

longCount

public long longCount()
Specified by:
longCount in interface Enumerable<Map.Entry<TKey,TValue>>

longCount

public long longCount(Func<Map.Entry<TKey,TValue>,Boolean> predicate)
Specified by:
longCount in interface Enumerable<Map.Entry<TKey,TValue>>

max

public Map.Entry<TKey,TValue> max()
Specified by:
max in interface Enumerable<Map.Entry<TKey,TValue>>

max

public <R extends Comparable<R>> R max(Func<Map.Entry<TKey,TValue>,R> selector)
Specified by:
max in interface Enumerable<Map.Entry<TKey,TValue>>

min

public Map.Entry<TKey,TValue> min()
Specified by:
min in interface Enumerable<Map.Entry<TKey,TValue>>

min

public <R extends Comparable<R>> R min(Func<Map.Entry<TKey,TValue>,R> selector)
Specified by:
min in interface Enumerable<Map.Entry<TKey,TValue>>

ofType

public <R> Enumerable<R> ofType(Class<R> resultClass)
Specified by:
ofType in interface Enumerable<Map.Entry<TKey,TValue>>

orderBy

public <K> OrderedEnumerable<Map.Entry<TKey,TValue>> orderBy(Func<Map.Entry<TKey,TValue>,K> keySelector,
                                                             Comparator<K> comparator)
Specified by:
orderBy in interface Enumerable<Map.Entry<TKey,TValue>>

orderBy

public <K> OrderedEnumerable<Map.Entry<TKey,TValue>> orderBy(Func<Map.Entry<TKey,TValue>,K> keySelector)
Specified by:
orderBy in interface Enumerable<Map.Entry<TKey,TValue>>

orderByDescending

public <K> OrderedEnumerable<Map.Entry<TKey,TValue>> orderByDescending(Func<Map.Entry<TKey,TValue>,K> keySelector,
                                                                       Comparator<K> comparator)
Specified by:
orderByDescending in interface Enumerable<Map.Entry<TKey,TValue>>

orderByDescending

public <K> OrderedEnumerable<Map.Entry<TKey,TValue>> orderByDescending(Func<Map.Entry<TKey,TValue>,K> keySelector)
Specified by:
orderByDescending in interface Enumerable<Map.Entry<TKey,TValue>>

reverse

public Enumerable<Map.Entry<TKey,TValue>> reverse()
Specified by:
reverse in interface Enumerable<Map.Entry<TKey,TValue>>

select

public <R> Enumerable<R> select(Func<Map.Entry<TKey,TValue>,R> selector)
Specified by:
select in interface Enumerable<Map.Entry<TKey,TValue>>

select

public <R> Enumerable<R> select(Func2<Map.Entry<TKey,TValue>,Integer,R> selector)
Specified by:
select in interface Enumerable<Map.Entry<TKey,TValue>>

selectMany

public <C,R> Enumerable<R> selectMany(Func<Map.Entry<TKey,TValue>,Enumerable<C>> collectionSelector,
                                      Func2<Map.Entry<TKey,TValue>,C,R> resultSelector)
Specified by:
selectMany in interface Enumerable<Map.Entry<TKey,TValue>>

selectMany

public <R> Enumerable<R> selectMany(Func<Map.Entry<TKey,TValue>,Enumerable<R>> selector)
Specified by:
selectMany in interface Enumerable<Map.Entry<TKey,TValue>>

selectMany

public <C,R> Enumerable<R> selectMany(Func2<Map.Entry<TKey,TValue>,Integer,Enumerable<C>> collectionSelector,
                                      Func2<Map.Entry<TKey,TValue>,C,R> resultSelector)
Specified by:
selectMany in interface Enumerable<Map.Entry<TKey,TValue>>

selectMany

public <R> Enumerable<R> selectMany(Func2<Map.Entry<TKey,TValue>,Integer,Enumerable<R>> selector)
Specified by:
selectMany in interface Enumerable<Map.Entry<TKey,TValue>>

sequenceEqual

public Boolean sequenceEqual(Enumerable<Map.Entry<TKey,TValue>> second)
Specified by:
sequenceEqual in interface Enumerable<Map.Entry<TKey,TValue>>

single

public Map.Entry<TKey,TValue> single()
Specified by:
single in interface Enumerable<Map.Entry<TKey,TValue>>

single

public Map.Entry<TKey,TValue> single(Func<Map.Entry<TKey,TValue>,Boolean> predicate)
Specified by:
single in interface Enumerable<Map.Entry<TKey,TValue>>

singleOrDefault

public Map.Entry<TKey,TValue> singleOrDefault()
Specified by:
singleOrDefault in interface Enumerable<Map.Entry<TKey,TValue>>

singleOrDefault

public Map.Entry<TKey,TValue> singleOrDefault(Map.Entry<TKey,TValue> defaultValue)
Specified by:
singleOrDefault in interface Enumerable<Map.Entry<TKey,TValue>>

singleOrDefault

public Map.Entry<TKey,TValue> singleOrDefault(Func<Map.Entry<TKey,TValue>,Boolean> predicate,
                                              Map.Entry<TKey,TValue> defaultValue)
Specified by:
singleOrDefault in interface Enumerable<Map.Entry<TKey,TValue>>

singleOrDefault

public Map.Entry<TKey,TValue> singleOrDefault(Func<Map.Entry<TKey,TValue>,Boolean> predicate)
Specified by:
singleOrDefault in interface Enumerable<Map.Entry<TKey,TValue>>

skip

public Enumerable<Map.Entry<TKey,TValue>> skip(int count)
Specified by:
skip in interface Enumerable<Map.Entry<TKey,TValue>>

skipWhile

public Enumerable<Map.Entry<TKey,TValue>> skipWhile(Func<Map.Entry<TKey,TValue>,Boolean> predicate)
Specified by:
skipWhile in interface Enumerable<Map.Entry<TKey,TValue>>

skipWhile

public Enumerable<Map.Entry<TKey,TValue>> skipWhile(Func2<Map.Entry<TKey,TValue>,Integer,Boolean> predicate)
Specified by:
skipWhile in interface Enumerable<Map.Entry<TKey,TValue>>

sum

public int sum()
Specified by:
sum in interface Enumerable<Map.Entry<TKey,TValue>>

sum

public int sum(Func<Map.Entry<TKey,TValue>,Integer> selector)
Specified by:
sum in interface Enumerable<Map.Entry<TKey,TValue>>

sumDouble

public double sumDouble()
Specified by:
sumDouble in interface Enumerable<Map.Entry<TKey,TValue>>

sumDouble

public double sumDouble(Func<Map.Entry<TKey,TValue>,Double> selector)
Specified by:
sumDouble in interface Enumerable<Map.Entry<TKey,TValue>>

sumFloat

public float sumFloat()
Specified by:
sumFloat in interface Enumerable<Map.Entry<TKey,TValue>>

sumFloat

public float sumFloat(Func<Map.Entry<TKey,TValue>,Float> selector)
Specified by:
sumFloat in interface Enumerable<Map.Entry<TKey,TValue>>

sumLong

public long sumLong()
Specified by:
sumLong in interface Enumerable<Map.Entry<TKey,TValue>>

sumLong

public long sumLong(Func<Map.Entry<TKey,TValue>,Long> selector)
Specified by:
sumLong in interface Enumerable<Map.Entry<TKey,TValue>>

take

public Enumerable<Map.Entry<TKey,TValue>> take(int count)
Specified by:
take in interface Enumerable<Map.Entry<TKey,TValue>>

takeWhile

public Enumerable<Map.Entry<TKey,TValue>> takeWhile(Func<Map.Entry<TKey,TValue>,Boolean> predicate)
Specified by:
takeWhile in interface Enumerable<Map.Entry<TKey,TValue>>

takeWhile

public Enumerable<Map.Entry<TKey,TValue>> takeWhile(Func2<Map.Entry<TKey,TValue>,Integer,Boolean> predicate)
Specified by:
takeWhile in interface Enumerable<Map.Entry<TKey,TValue>>

toArray

public Object[] toArray()
Specified by:
toArray in interface Enumerable<Map.Entry<TKey,TValue>>

toArray

public <R> R[] toArray(Class<R> resultClass)
Specified by:
toArray in interface Enumerable<Map.Entry<TKey,TValue>>

toDictionary

public <K,E> Dictionary<K,E> toDictionary(Func<Map.Entry<TKey,TValue>,K> keySelector,
                                          Func<Map.Entry<TKey,TValue>,E> elementSelector)
Specified by:
toDictionary in interface Enumerable<Map.Entry<TKey,TValue>>

toDictionary

public <K> Dictionary<K,Map.Entry<TKey,TValue>> toDictionary(Func<Map.Entry<TKey,TValue>,K> keySelector)
Specified by:
toDictionary in interface Enumerable<Map.Entry<TKey,TValue>>

toEnumerableList

public EnumerableList<Map.Entry<TKey,TValue>> toEnumerableList()
Specified by:
toEnumerableList in interface Enumerable<Map.Entry<TKey,TValue>>

toList

public List<Map.Entry<TKey,TValue>> toList()
Specified by:
toList in interface Enumerable<Map.Entry<TKey,TValue>>

toListMap

public <K,E> Map<K,List<E>> toListMap(Func<Map.Entry<TKey,TValue>,K> keySelector,
                                      Func<Map.Entry<TKey,TValue>,E> elementSelector)
Specified by:
toListMap in interface Enumerable<Map.Entry<TKey,TValue>>

toListMap

public <K> Map<K,List<Map.Entry<TKey,TValue>>> toListMap(Func<Map.Entry<TKey,TValue>,K> keySelector)
Specified by:
toListMap in interface Enumerable<Map.Entry<TKey,TValue>>

toLookup

public <K,E> Lookup<K,E> toLookup(Func<Map.Entry<TKey,TValue>,K> keySelector,
                                  Func<Map.Entry<TKey,TValue>,E> elementSelector)
Specified by:
toLookup in interface Enumerable<Map.Entry<TKey,TValue>>

toLookup

public <K> Lookup<K,Map.Entry<TKey,TValue>> toLookup(Func<Map.Entry<TKey,TValue>,K> keySelector)
Specified by:
toLookup in interface Enumerable<Map.Entry<TKey,TValue>>

toMap

public <K,E> Map<K,E> toMap(Func<Map.Entry<TKey,TValue>,K> keySelector,
                            Func<Map.Entry<TKey,TValue>,E> elementSelector)
Specified by:
toMap in interface Enumerable<Map.Entry<TKey,TValue>>

toMap

public <K> Map<K,Map.Entry<TKey,TValue>> toMap(Func<Map.Entry<TKey,TValue>,K> keySelector)
Specified by:
toMap in interface Enumerable<Map.Entry<TKey,TValue>>

union

public Enumerable<Map.Entry<TKey,TValue>> union(Enumerable<Map.Entry<TKey,TValue>> second)
Specified by:
union in interface Enumerable<Map.Entry<TKey,TValue>>

where

public Enumerable<Map.Entry<TKey,TValue>> where(Func<Map.Entry<TKey,TValue>,Boolean> predicate)
Specified by:
where in interface Enumerable<Map.Entry<TKey,TValue>>

where

public Enumerable<Map.Entry<TKey,TValue>> where(Func2<Map.Entry<TKey,TValue>,Integer,Boolean> predicate)
Specified by:
where in interface Enumerable<Map.Entry<TKey,TValue>>


Copyright © 2009 SHU. All Rights Reserved.