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
Interface Enumerable<T>

All Superinterfaces:
  Iterable<T>

All Known Subinterfaces:
  Dictionary<K,V>, EnumerableList<E>, Grouping<K,E>, Lookup<K,V>, OrderedEnumerable<T>

All Known Implementing Classes:
  BasicDictionary, BasicEnumerable, BasicEnumerableList, BasicGrouping, BasicLookup, BasicOrderedEnumerable

    public interface Enumerable<T>

extends Iterable<T>

Method Summary
`
`<A> A`
` | `aggregate(A seed, Func2<A,T,A> func)`
`
`<A,R> R`
` | `aggregate(A seed, Func2<A,T,A> func, Func<A,R> resultSelector)`
`T` | `aggregate(Func2<T,T,T> func)`
`Boolean` | `all(Func<T,Boolean> predicate)`
`Boolean` | `any()`
`Boolean` | `any(Func<T,Boolean> predicate)`
`double` | `average()`
`double` | `average(Func<T,Integer> selector)`
`double` | `averageDouble()`
`double` | `averageDouble(Func<T,Double> selector)`
`float` | `averageFloat()`
`float` | `averageFloat(Func<T,Float> selector)`
`double` | `averageLong()`
`double` | `averageLong(Func<T,Long> selector)`
`
`<R> Enumerable<R>`
` | `cast(Class<R> resultClass)`
`Enumerable<T>` | `concat(Enumerable<T> second)`
`boolean` | `contains(Object o)`
`int` | `count()`
`int` | `count(Func<T,Boolean> predicate)`
`Enumerable<T>` | `defaultIfEmpty()`
`Enumerable<T>` | `defaultIfEmpty(T defaultValue)`
`Enumerable<T>` | `distinct()`
`T` | `elementAt(int index)`
`T` | `elementAtOrDefault(int index)`
`T` | `elementAtOrDefault(int index, T defaultValue)`
`Enumerable<T>` | `except(Enumerable<T> second)`
`T` | `first()`
`T` | `first(Func<T,Boolean> predicate)`
`T` | `firstOrDefault()`
`T` | `firstOrDefault(Func<T,Boolean> predicate)`
`T` | `firstOrDefault(Func<T,Boolean> predicate, T defaultValue)`
`T` | `firstOrDefault(T defaultValue)`
`
`<K> Enumerable<Grouping<K,T>>`
` | `groupBy(Func<T,K> keySelector)`
`
`<K,E> Enumerable<Grouping<K,E>>`
` | `groupBy(Func<T,K> keySelector, Func<T,E> elementSelector)`
`
`<K,E,R> Enumerable<R>`
` | `groupBy(Func<T,K> keySelector, Func<T,E> elementSelector, Func2<K,Enumerable<E>,R> resultSelector)`
`
`<K,R> Enumerable<R>`
` | `groupBy(Func<T,K> keySelector, Func2<K,Enumerable<T>,R> resultSelector)`
`
`<I,K,R> Enumerable<R>`
` | `groupJoin(Enumerable<I> inner, Func<T,K> outerKeySelector, Func<I,K> innerKeySelector, Func2<T,Enumerable<I>,R> resultSelector)`
`Enumerable<T>` | `intersect(Enumerable<T> second)`
`
`<I,K,R> Enumerable<R>`
` | `join(Enumerable<I> inner, Func<T,K> outerKeySelector, Func<I,K> innerKeySelector, Func2<T,I,R> resultSelector)`
`T` | `last()`
`T` | `last(Func<T,Boolean> predicate)`
`T` | `lastOrDefault()`
`T` | `lastOrDefault(Func<T,Boolean> predicate)`
`T` | `lastOrDefault(Func<T,Boolean> predicate, T defaultValue)`
`T` | `lastOrDefault(T defaultValue)`
`long` | `longCount()`
`long` | `longCount(Func<T,Boolean> predicate)`
`T` | `max()`
`
`<R extends Comparable<R>> R`
` | `max(Func<T,R> selector)`
`T` | `min()`
`
`<R extends Comparable<R>> R`
` | `min(Func<T,R> selector)`
`
`<R> Enumerable<R>`
` | `ofType(Class<R> resultClass)`
`
`<K> OrderedEnumerable<T>`
` | `orderBy(Func<T,K> keySelector)`
`
`<K> OrderedEnumerable<T>`
` | `orderBy(Func<T,K> keySelector, Comparator<K> comparator)`
`
`<K> OrderedEnumerable<T>`
` | `orderByDescending(Func<T,K> keySelector)`
`
`<K> OrderedEnumerable<T>`
` | `orderByDescending(Func<T,K> keySelector, Comparator<K> comparator)`
`Enumerable<T>` | `reverse()`
`
`<R> Enumerable<R>`
` | `select(Func<T,R> selector)`
`
`<R> Enumerable<R>`
` | `select(Func2<T,Integer,R> selector)`
`
`<C,R> Enumerable<R>`
` | `selectMany(Func<T,Enumerable<C>> collectionSelector, Func2<T,C,R> resultSelector)`
`
`<R> Enumerable<R>`
` | `selectMany(Func<T,Enumerable<R>> selector)`
`
`<C,R> Enumerable<R>`
` | `selectMany(Func2<T,Integer,Enumerable<C>> collectionSelector, Func2<T,C,R> resultSelector)`
`
`<R> Enumerable<R>`
` | `selectMany(Func2<T,Integer,Enumerable<R>> selector)`
`Boolean` | `sequenceEqual(Enumerable<T> second)`
`T` | `single()`
`T` | `single(Func<T,Boolean> predicate)`
`T` | `singleOrDefault()`
`T` | `singleOrDefault(Func<T,Boolean> predicate)`
`T` | `singleOrDefault(Func<T,Boolean> predicate, T defaultValue)`
`T` | `singleOrDefault(T defaultValue)`
`Enumerable<T>` | `skip(int count)`
`Enumerable<T>` | `skipWhile(Func<T,Boolean> predicate)`
`Enumerable<T>` | `skipWhile(Func2<T,Integer,Boolean> predicate)`
`int` | `sum()`
`int` | `sum(Func<T,Integer> selector)`
`double` | `sumDouble()`
`double` | `sumDouble(Func<T,Double> selector)`
`float` | `sumFloat()`
`float` | `sumFloat(Func<T,Float> selector)`
`long` | `sumLong()`
`long` | `sumLong(Func<T,Long> selector)`
`Enumerable<T>` | `take(int count)`
`Enumerable<T>` | `takeWhile(Func<T,Boolean> predicate)`
`Enumerable<T>` | `takeWhile(Func2<T,Integer,Boolean> predicate)`
`Object[]` | `toArray()`
`
`<R> R[]`
` | `toArray(Class<R> resultClass)`
`
`<K> Dictionary<K,T>`
` | `toDictionary(Func<T,K> keySelector)`
`
`<K,E> Dictionary<K,E>`
` | `toDictionary(Func<T,K> keySelector, Func<T,E> elementSelector)`
`EnumerableList<T>` | `toEnumerableList()`
`List<T>` | `toList()`
`
`<K> Map<K,List<T>>`
` | `toListMap(Func<T,K> keySelector)`
`
`<K,E> Map<K,List<E>>`
` | `toListMap(Func<T,K> keySelector, Func<T,E> elementSelector)`
`
`<K> Lookup<K,T>`
` | `toLookup(Func<T,K> keySelector)`
`
`<K,E> Lookup<K,E>`
` | `toLookup(Func<T,K> keySelector, Func<T,E> elementSelector)`
`
`<K> Map<K,T>`
` | `toMap(Func<T,K> keySelector)`
`
`<K,E> Map<K,E>`
` | `toMap(Func<T,K> keySelector, Func<T,E> elementSelector)`
`Enumerable<T>` | `union(Enumerable<T> second)`
`Enumerable<T>` | `where(Func<T,Boolean> predicate)`
`Enumerable<T>` | `where(Func2<T,Integer,Boolean> predicate)`

Methods inherited from interface java.lang.Iterable
`iterator`

Method Detail

### aggregate

    T aggregate(Func2<T,T,T> func)

### aggregate

    <A> A aggregate(A seed,
                    Func2<A,T,A> func)

### aggregate

    <A,R> R aggregate(A seed,
                      Func2<A,T,A> func,
                      Func<A,R> resultSelector)

### all

    Boolean all(Func<T,Boolean> predicate)

### any

    Boolean any()

### any

    Boolean any(Func<T,Boolean> predicate)

### average

    double average()

### averageLong

    double averageLong()

### averageFloat

    float averageFloat()

### averageDouble

    double averageDouble()

### average

    double average(Func<T,Integer> selector)

### averageLong

    double averageLong(Func<T,Long> selector)

### averageFloat

    float averageFloat(Func<T,Float> selector)

### averageDouble

    double averageDouble(Func<T,Double> selector)

### cast

    <R> Enumerable<R> cast(Class<R> resultClass)

### concat

    Enumerable<T> concat(Enumerable<T> second)

### contains

    boolean contains(Object o)

### count

    int count()

### count

    int count(Func<T,Boolean> predicate)

### defaultIfEmpty

    Enumerable<T> defaultIfEmpty()

### defaultIfEmpty

    Enumerable<T> defaultIfEmpty(T defaultValue)

### distinct

    Enumerable<T> distinct()

### elementAt

    T elementAt(int index)

### elementAtOrDefault

    T elementAtOrDefault(int index)

### elementAtOrDefault

    T elementAtOrDefault(int index,
                         T defaultValue)

### except

    Enumerable<T> except(Enumerable<T> second)

### first

    T first()

### first

    T first(Func<T,Boolean> predicate)

### firstOrDefault

    T firstOrDefault()

### firstOrDefault

    T firstOrDefault(T defaultValue)

### firstOrDefault

    T firstOrDefault(Func<T,Boolean> predicate)

### firstOrDefault

    T firstOrDefault(Func<T,Boolean> predicate,
                     T defaultValue)

### groupBy

    <K> Enumerable<Grouping<K,T>> groupBy(Func<T,K> keySelector)

### groupBy

    <K,R> Enumerable<R> groupBy(Func<T,K> keySelector,
                                Func2<K,Enumerable<T>,R> resultSelector)

### groupBy

    <K,E> Enumerable<Grouping<K,E>> groupBy(Func<T,K> keySelector,
                                            Func<T,E> elementSelector)

### groupBy

    <K,E,R> Enumerable<R> groupBy(Func<T,K> keySelector,
                                  Func<T,E> elementSelector,
                                  Func2<K,Enumerable<E>,R> resultSelector)

### groupJoin

    <I,K,R> Enumerable<R> groupJoin(Enumerable<I> inner,
                                    Func<T,K> outerKeySelector,
                                    Func<I,K> innerKeySelector,
                                    Func2<T,Enumerable<I>,R> resultSelector)

### intersect

    Enumerable<T> intersect(Enumerable<T> second)

### join

    <I,K,R> Enumerable<R> join(Enumerable<I> inner,
                               Func<T,K> outerKeySelector,
                               Func<I,K> innerKeySelector,
                               Func2<T,I,R> resultSelector)

### last

    T last()

### last

    T last(Func<T,Boolean> predicate)

### lastOrDefault

    T lastOrDefault()

### lastOrDefault

    T lastOrDefault(T defaultValue)

### lastOrDefault

    T lastOrDefault(Func<T,Boolean> predicate)

### lastOrDefault

    T lastOrDefault(Func<T,Boolean> predicate,
                    T defaultValue)

### longCount

    long longCount()

### longCount

    long longCount(Func<T,Boolean> predicate)

### max

    T max()

### max

    <R extends Comparable<R>> R max(Func<T,R> selector)

### min

    T min()

### min

    <R extends Comparable<R>> R min(Func<T,R> selector)

### ofType

    <R> Enumerable<R> ofType(Class<R> resultClass)

### orderBy

    <K> OrderedEnumerable<T> orderBy(Func<T,K> keySelector)

### orderBy

    <K> OrderedEnumerable<T> orderBy(Func<T,K> keySelector,
                                     Comparator<K> comparator)

### orderByDescending

    <K> OrderedEnumerable<T> orderByDescending(Func<T,K> keySelector)

### orderByDescending

    <K> OrderedEnumerable<T> orderByDescending(Func<T,K> keySelector,
                                               Comparator<K> comparator)

### reverse

    Enumerable<T> reverse()

### select

    <R> Enumerable<R> select(Func2<T,Integer,R> selector)

### select

    <R> Enumerable<R> select(Func<T,R> selector)

### selectMany

    <R> Enumerable<R> selectMany(Func<T,Enumerable<R>> selector)

### selectMany

    <R> Enumerable<R> selectMany(Func2<T,Integer,Enumerable<R>> selector)

### selectMany

    <C,R> Enumerable<R> selectMany(Func<T,Enumerable<C>> collectionSelector,
                                   Func2<T,C,R> resultSelector)

### selectMany

    <C,R> Enumerable<R> selectMany(Func2<T,Integer,Enumerable<C>> collectionSelector,
                                   Func2<T,C,R> resultSelector)

### sequenceEqual

    Boolean sequenceEqual(Enumerable<T> second)

### single

    T single()

### single

    T single(Func<T,Boolean> predicate)

### singleOrDefault

    T singleOrDefault()

### singleOrDefault

    T singleOrDefault(T defaultValue)

### singleOrDefault

    T singleOrDefault(Func<T,Boolean> predicate)

### singleOrDefault

    T singleOrDefault(Func<T,Boolean> predicate,
                      T defaultValue)

### skip

    Enumerable<T> skip(int count)

### skipWhile

    Enumerable<T> skipWhile(Func<T,Boolean> predicate)

### skipWhile

    Enumerable<T> skipWhile(Func2<T,Integer,Boolean> predicate)

### sum

    int sum()

### sumLong

    long sumLong()

### sumFloat

    float sumFloat()

### sumDouble

    double sumDouble()

### sum

    int sum(Func<T,Integer> selector)

### sumLong

    long sumLong(Func<T,Long> selector)

### sumFloat

    float sumFloat(Func<T,Float> selector)

### sumDouble

    double sumDouble(Func<T,Double> selector)

### take

    Enumerable<T> take(int count)

### takeWhile

    Enumerable<T> takeWhile(Func<T,Boolean> predicate)

### takeWhile

    Enumerable<T> takeWhile(Func2<T,Integer,Boolean> predicate)

### toArray

    Object[] toArray()

### toArray

    <R> R[] toArray(Class<R> resultClass)

### toMap

    <K> Map<K,T> toMap(Func<T,K> keySelector)

### toMap

    <K,E> Map<K,E> toMap(Func<T,K> keySelector,
                         Func<T,E> elementSelector)

### toDictionary

    <K> Dictionary<K,T> toDictionary(Func<T,K> keySelector)

### toDictionary

    <K,E> Dictionary<K,E> toDictionary(Func<T,K> keySelector,
                                       Func<T,E> elementSelector)

### toList

    List<T> toList()

### toEnumerableList

    EnumerableList<T> toEnumerableList()

### toListMap

    <K> Map<K,List<T>> toListMap(Func<T,K> keySelector)

### toListMap

    <K,E> Map<K,List<E>> toListMap(Func<T,K> keySelector,
                                   Func<T,E> elementSelector)

### toLookup

    <K> Lookup<K,T> toLookup(Func<T,K> keySelector)

### toLookup

    <K,E> Lookup<K,E> toLookup(Func<T,K> keySelector,
                               Func<T,E> elementSelector)

### union

    Enumerable<T> union(Enumerable<T> second)

### where

    Enumerable<T> where(Func<T,Boolean> predicate)

### where

    Enumerable<T> where(Func2<T,Integer,Boolean> predicate)

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.