Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## sharin.unlinq
Class BasicDictionary<TKey,TValue>

    java.lang.Object
      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>>`

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright © 2009 SHU. All Rights Reserved.