Package org.apache.calcite.linq4j

Interface ExtendedEnumerable<TSource>

Type Parameters:
TSource - Element type
All Known Subinterfaces:
Enumerable<T>, ExtendedOrderedEnumerable<T>, ExtendedOrderedQueryable<T>, org.apache.calcite.linq4j.ExtendedQueryable<TSource>, Grouping<K,V>, Lookup<K,V>, OrderedEnumerable<T>, OrderedQueryable<T>, Queryable<T>, QueryableDefaults.Replayable<T>, RawQueryable<T>
All Known Implementing Classes:
AbstractEnumerable, AbstractEnumerable2, AbstractQueryable, AbstractTableQueryable, BaseQueryable, CassandraTable.CassandraQueryable, DefaultEnumerable, ElasticsearchTable.ElasticsearchQueryable, GeodeTable.GeodeQueryable, InnodbTable.InnodbQueryable, Interpreter, MemoryEnumerable, MongoTable.MongoQueryable, QueryableDefaults.NonLeafReplayableQueryable, QueryableDefaults.ReplayableQueryable, QueryProviderImpl.QueryableImpl, ResultSetEnumerable, SpatialTypeFunctions.GridEnumerable, SplunkQuery
@Covariant(0) public interface ExtendedEnumerable<TSource>
Extension methods in Enumerable.

  • Method Details

    • foreach

      <R> @Nullable R foreach(Function1<TSource,R> func)
      Performs an operation for each member of this enumeration.

      Returns the value returned by the function for the last element in this enumeration, or null if this enumeration is empty.

      Type Parameters:
      R - Return type
      Parameters:
      func - Operation

    • aggregate

      @Nullable TSource aggregate(Function2<@Nullable TSource,TSource,TSource> func)
      Applies an accumulator function over a sequence.

    • aggregate

      <TAccumulate> @PolyNull TAccumulate aggregate(@PolyNull TAccumulate seed, Function2<@PolyNull TAccumulate,TSource,@PolyNull TAccumulate> func)
      Applies an accumulator function over a sequence. The specified seed value is used as the initial accumulator value.

      If seed is not null, the result is never null.

    • aggregate

      <TAccumulate, TResult> TResult aggregate(TAccumulate seed, Function2<TAccumulate,TSource,TAccumulate> func, Function1<TAccumulate,TResult> selector)
      Applies an accumulator function over a sequence. The specified seed value is used as the initial accumulator value, and the specified function is used to select the result value.

    • all

      boolean all(Predicate1<TSource> predicate)
      Determines whether all elements of a sequence satisfy a condition.

    • any

      boolean any()
      Determines whether a sequence contains any elements. (Defined by Enumerable.)

    • any

      boolean any(Predicate1<TSource> predicate)
      Determines whether any element of a sequence satisfies a condition.

    • asEnumerable

      Enumerable<TSource> asEnumerable()
      Returns the input typed as Enumerable<TSource>.

      This method has no effect other than to change the compile-time type of source from a type that implements Enumerable<TSource> to Enumerable<TSource> itself.

      asEnumerable<TSource>(Enumerable<TSource>) can be used to choose between query implementations when a sequence implements Enumerable<TSource> but also has a different set of public query methods available. For example, given a generic class Table that implements Enumerable<TSource> and has its own methods such as where, select, and selectMany, a call to where would invoke the public where method of Table. A Table type that represents a database table could have a where method that takes the predicate argument as an expression tree and converts the tree to SQL for remote execution. If remote execution is not desired, for example because the predicate invokes a local method, the asEnumerable<TSource> method can be used to hide the custom methods and instead make the standard query operators available.

    • asQueryable

      Queryable<TSource> asQueryable()
      Converts an Enumerable to a Queryable.

      If the type of source implements Queryable, this method returns it directly. Otherwise, it returns a Queryable that executes queries by calling the equivalent query operator methods in Enumerable instead of those in Queryable.

      Analogous to the LINQ's Enumerable.AsQueryable extension method.

      Returns:
      A queryable

    • average

      BigDecimal average(BigDecimalFunction1<TSource> selector)
      Computes the average of a sequence of Decimal values that are obtained by invoking a transform function on each element of the input sequence.

    • average

      BigDecimal average(NullableBigDecimalFunction1<TSource> selector)
      Computes the average of a sequence of nullable Decimal values that are obtained by invoking a transform function on each element of the input sequence.

    • average

      double average(DoubleFunction1<TSource> selector)
      Computes the average of a sequence of Double values that are obtained by invoking a transform function on each element of the input sequence.

    • average

      Double average(NullableDoubleFunction1<TSource> selector)
      Computes the average of a sequence of nullable Double values that are obtained by invoking a transform function on each element of the input sequence.

    • average

      int average(IntegerFunction1<TSource> selector)
      Computes the average of a sequence of int values that are obtained by invoking a transform function on each element of the input sequence.

    • average

      Integer average(NullableIntegerFunction1<TSource> selector)
      Computes the average of a sequence of nullable int values that are obtained by invoking a transform function on each element of the input sequence.

    • average

      long average(LongFunction1<TSource> selector)
      Computes the average of a sequence of long values that are obtained by invoking a transform function on each element of the input sequence.

    • average

      Long average(NullableLongFunction1<TSource> selector)
      Computes the average of a sequence of nullable long values that are obtained by invoking a transform function on each element of the input sequence.

    • average

      float average(FloatFunction1<TSource> selector)
      Computes the average of a sequence of Float values that are obtained by invoking a transform function on each element of the input sequence.

    • average

      Float average(NullableFloatFunction1<TSource> selector)
      Computes the average of a sequence of nullable Float values that are obtained by invoking a transform function on each element of the input sequence.

    • cast

      <T2> Enumerable<T2> cast(Class<T2> clazz)
      Converts the elements of this Enumerable to the specified type.

      This method is implemented by using deferred execution. The immediate return value is an object that stores all the information that is required to perform the action. The query represented by this method is not executed until the object is enumerated either by calling its RawEnumerable.enumerator() method directly or by using for (... in ...).

      If an element cannot be cast to type TResult, the Enumerator.current() method will throw a ClassCastException a exception when the element it accessed. To obtain only those elements that can be cast to type TResult, use the ofType(Class) method instead.

      See Also:

    • concat

      Enumerable<TSource> concat(Enumerable<TSource> enumerable1)
      Concatenates two sequences.

    • contains

      boolean contains(TSource element)
      Determines whether a sequence contains a specified element by using the default equality comparer.

    • contains

      boolean contains(TSource element, EqualityComparer<TSource> comparer)
      Determines whether a sequence contains a specified element by using a specified EqualityComparer<TSource>.

    • count

      int count()
      Returns the number of elements in a sequence.

    • count

      int count(Predicate1<TSource> predicate)
      Returns a number that represents how many elements in the specified sequence satisfy a condition.

    • defaultIfEmpty

      Enumerable<@Nullable TSource> defaultIfEmpty()
      Returns the elements of the specified sequence or the type parameter's default value in a singleton collection if the sequence is empty.

    • defaultIfEmpty

      Enumerable<@PolyNull TSource> defaultIfEmpty(@PolyNull TSource value)
      Returns the elements of the specified sequence or the specified value in a singleton collection if the sequence is empty.

      If value is not null, the result is never null.

    • distinct

      Enumerable<TSource> distinct()
      Returns distinct elements from a sequence by using the default equality comparer to compare values.

    • distinct

      Enumerable<TSource> distinct(EqualityComparer<TSource> comparer)
      Returns distinct elements from a sequence by using a specified EqualityComparer<TSource> to compare values.

    • elementAt

      TSource elementAt(int index)
      Returns the element at a specified index in a sequence.

    • elementAtOrDefault

      @Nullable TSource elementAtOrDefault(int index)
      Returns the element at a specified index in a sequence or a default value if the index is out of range.

    • except

      Enumerable<TSource> except(Enumerable<TSource> enumerable1)
      Produces the set difference of two sequences by using the default equality comparer to compare values, eliminate duplicates. (Defined by Enumerable.)

    • except

      Enumerable<TSource> except(Enumerable<TSource> enumerable1, boolean all)
      Produces the set difference of two sequences by using the default equality comparer to compare values, using all to indicate whether to eliminate duplicates. (Defined by Enumerable.)

    • except

      Enumerable<TSource> except(Enumerable<TSource> enumerable1, EqualityComparer<TSource> comparer)
      Produces the set difference of two sequences by using the specified EqualityComparer<TSource> to compare values, eliminate duplicates.

    • except

      Enumerable<TSource> except(Enumerable<TSource> enumerable1, EqualityComparer<TSource> comparer, boolean all)
      Produces the set difference of two sequences by using the specified EqualityComparer<TSource> to compare values, using all to indicate whether to eliminate duplicates.

    • first

      TSource first()
      Returns the first element of a sequence. (Defined by Enumerable.)

    • first

      TSource first(Predicate1<TSource> predicate)
      Returns the first element in a sequence that satisfies a specified condition.

    • firstOrDefault

      @Nullable TSource firstOrDefault()
      Returns the first element of a sequence, or a default value if the sequence contains no elements.

    • firstOrDefault

      @Nullable TSource firstOrDefault(Predicate1<TSource> predicate)
      Returns the first element of the sequence that satisfies a condition or a default value if no such element is found.

    • groupBy

      <TKey> Enumerable<Grouping<TKey,TSource>> groupBy(Function1<TSource,TKey> keySelector)
      Groups the elements of a sequence according to a specified key selector function.

    • groupBy

      <TKey> Enumerable<Grouping<TKey,TSource>> groupBy(Function1<TSource,TKey> keySelector, EqualityComparer<TKey> comparer)
      Groups the elements of a sequence according to a specified key selector function and compares the keys by using a specified comparer.

    • groupBy

      <TKey, TElement> Enumerable<Grouping<TKey,TElement>> groupBy(Function1<TSource,TKey> keySelector, Function1<TSource,TElement> elementSelector)
      Groups the elements of a sequence according to a specified key selector function and projects the elements for each group by using a specified function.

    • groupBy

      <TKey, TElement> Enumerable<Grouping<TKey,TElement>> groupBy(Function1<TSource,TKey> keySelector, Function1<TSource,TElement> elementSelector, EqualityComparer<TKey> comparer)
      Groups the elements of a sequence according to a key selector function. The keys are compared by using a comparer and each group's elements are projected by using a specified function.

    • groupBy

      <TKey, TResult> Enumerable<TResult> groupBy(Function1<TSource,TKey> keySelector, Function2<TKey,Enumerable<TSource>,TResult> resultSelector)
      Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key.

    • groupBy

      <TKey, TResult> Enumerable<TResult> groupBy(Function1<TSource,TKey> keySelector, Function2<TKey,Enumerable<TSource>,TResult> resultSelector, EqualityComparer<TKey> comparer)
      Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key. The keys are compared by using a specified comparer.

    • groupBy

      <TKey, TElement, TResult> Enumerable<TResult> groupBy(Function1<TSource,TKey> keySelector, Function1<TSource,TElement> elementSelector, Function2<TKey,Enumerable<TElement>,TResult> resultSelector)
      Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key. The elements of each group are projected by using a specified function.

    • groupBy

      <TKey, TElement, TResult> Enumerable<TResult> groupBy(Function1<TSource,TKey> keySelector, Function1<TSource,TElement> elementSelector, Function2<TKey,Enumerable<TElement>,TResult> resultSelector, EqualityComparer<TKey> comparer)
      Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key. Key values are compared by using a specified comparer, and the elements of each group are projected by using a specified function.

    • groupBy

      <TKey, TAccumulate, TResult> Enumerable<TResult> groupBy(Function1<TSource,TKey> keySelector, Function0<TAccumulate> accumulatorInitializer, Function2<TAccumulate,TSource,TAccumulate> accumulatorAdder, Function2<TKey,TAccumulate,TResult> resultSelector)
      Groups the elements of a sequence according to a specified key selector function, initializing an accumulator for each group and adding to it each time an element with the same key is seen. Creates a result value from each accumulator and its key using a specified function.

    • groupBy

      <TKey, TAccumulate, TResult> Enumerable<TResult> groupBy(Function1<TSource,TKey> keySelector, Function0<TAccumulate> accumulatorInitializer, Function2<TAccumulate,TSource,TAccumulate> accumulatorAdder, Function2<TKey,TAccumulate,TResult> resultSelector, EqualityComparer<TKey> comparer)
      Groups the elements of a sequence according to a specified key selector function, initializing an accumulator for each group and adding to it each time an element with the same key is seen. Creates a result value from each accumulator and its key using a specified function. Key values are compared by using a specified comparer.

    • sortedGroupBy

      <TKey, TAccumulate, TResult> Enumerable<TResult> sortedGroupBy(Function1<TSource,TKey> keySelector, Function0<TAccumulate> accumulatorInitializer, Function2<TAccumulate,TSource,TAccumulate> accumulatorAdder, Function2<TKey,TAccumulate,TResult> resultSelector, Comparator<TKey> comparator)
      Group keys are sorted already. Key values are compared by using a specified comparator. Groups the elements of a sequence according to a specified key selector function and initializing one accumulator at a time. Go over elements sequentially, adding to accumulator each time an element with the same key is seen. When key changes, creates a result value from the accumulator and then re-initializes the accumulator. In the case of NULL values in group keys, the comparator must be able to support NULL values by giving a consistent sort ordering.

    • groupJoin

      <TInner, TKey, TResult> Enumerable<TResult> groupJoin(Enumerable<TInner> inner, Function1<TSource,TKey> outerKeySelector, Function1<TInner,TKey> innerKeySelector, Function2<TSource,Enumerable<TInner>,TResult> resultSelector)
      Correlates the elements of two sequences based on equality of keys and groups the results. The default equality comparer is used to compare keys.

    • groupJoin

      <TInner, TKey, TResult> Enumerable<TResult> groupJoin(Enumerable<TInner> inner, Function1<TSource,TKey> outerKeySelector, Function1<TInner,TKey> innerKeySelector, Function2<TSource,Enumerable<TInner>,TResult> resultSelector, EqualityComparer<TKey> comparer)
      Correlates the elements of two sequences based on key equality and groups the results. A specified EqualityComparer<TSource> is used to compare keys.

    • intersect

      Enumerable<TSource> intersect(Enumerable<TSource> enumerable1)
      Produces the set intersection of two sequences by using the default equality comparer to compare values, eliminate duplicates. (Defined by Enumerable.)

    • intersect

      Enumerable<TSource> intersect(Enumerable<TSource> enumerable1, boolean all)
      Produces the set intersection of two sequences by using the default equality comparer to compare values, using all to indicate whether to eliminate duplicates. (Defined by Enumerable.)

    • intersect

      Enumerable<TSource> intersect(Enumerable<TSource> enumerable1, EqualityComparer<TSource> comparer)
      Produces the set intersection of two sequences by using the specified EqualityComparer<TSource> to compare values, eliminate duplicates.

    • intersect

      Enumerable<TSource> intersect(Enumerable<TSource> enumerable1, EqualityComparer<TSource> comparer, boolean all)
      Produces the set intersection of two sequences by using the specified EqualityComparer<TSource> to compare values, using all to indicate whether to eliminate duplicates.

    • into

      <C extends Collection<? super TSource>> C into(C sink)
      Copies the contents of this sequence into a collection.

    • removeAll

      <C extends Collection<? super TSource>> C removeAll(C sink)
      Removes the contents of this sequence from a collection.

    • hashJoin

      <TInner, TKey, TResult> Enumerable<TResult> hashJoin(Enumerable<TInner> inner, Function1<TSource,TKey> outerKeySelector, Function1<TInner,TKey> innerKeySelector, Function2<TSource,TInner,TResult> resultSelector)
      Correlates the elements of two sequences based on matching keys. The default equality comparer is used to compare keys.

    • hashJoin

      <TInner, TKey, TResult> Enumerable<TResult> hashJoin(Enumerable<TInner> inner, Function1<TSource,TKey> outerKeySelector, Function1<TInner,TKey> innerKeySelector, Function2<TSource,TInner,TResult> resultSelector, EqualityComparer<TKey> comparer)
      Correlates the elements of two sequences based on matching keys. A specified EqualityComparer<TSource> is used to compare keys.

    • hashJoin

      <TInner, TKey, TResult> Enumerable<TResult> hashJoin(Enumerable<TInner> inner, Function1<TSource,TKey> outerKeySelector, Function1<TInner,TKey> innerKeySelector, Function2<TSource,TInner,TResult> resultSelector, EqualityComparer<TKey> comparer, boolean generateNullsOnLeft, boolean generateNullsOnRight)
      Correlates the elements of two sequences based on matching keys, with optional outer join semantics. A specified EqualityComparer<TSource> is used to compare keys.

      A left join generates nulls on right, and vice versa:

      Join types
      Join type generateNullsOnLeft generateNullsOnRight
      INNERfalsefalse
      LEFTfalsetrue
      RIGHTtruefalse
      FULLtruetrue

    • hashJoin

      <TInner, TKey, TResult> Enumerable<TResult> hashJoin(Enumerable<TInner> inner, Function1<TSource,TKey> outerKeySelector, Function1<TInner,TKey> innerKeySelector, Function2<TSource,TInner,TResult> resultSelector, EqualityComparer<TKey> comparer, boolean generateNullsOnLeft, boolean generateNullsOnRight, Predicate2<TSource,TInner> predicate)
      Correlates the elements of two sequences based on matching keys, with optional outer join semantics. A specified EqualityComparer<TSource> is used to compare keys.

      A left join generates nulls on right, and vice versa:

      Join types
      Join type generateNullsOnLeft generateNullsOnRight
      INNERfalsefalse
      LEFTfalsetrue
      RIGHTtruefalse
      FULLtruetrue

      A predicate is used to filter the join result per-row

    • correlateJoin

      <TInner, TResult> Enumerable<TResult> correlateJoin(JoinType joinType, Function1<TSource,Enumerable<TInner>> inner, Function2<TSource,TInner,TResult> resultSelector)
      For each row of the current enumerable returns the correlated rows from the inner enumerable (nested loops join).
      Parameters:
      joinType - inner, left, semi or anti join type
      inner - generator of inner enumerable
      resultSelector - selector of the result. For semi/anti join inner argument is always null.

    • last

      TSource last()
      Returns the last element of a sequence. (Defined by Enumerable.)

    • last

      TSource last(Predicate1<TSource> predicate)
      Returns the last element of a sequence that satisfies a specified condition.

    • lastOrDefault

      @Nullable TSource lastOrDefault()
      Returns the last element of a sequence, or a default value if the sequence contains no elements.

    • lastOrDefault

      @Nullable TSource lastOrDefault(Predicate1<TSource> predicate)
      Returns the last element of a sequence that satisfies a condition or a default value if no such element is found.

    • longCount

      long longCount()
      Returns an long that represents the total number of elements in a sequence.

    • longCount

      long longCount(Predicate1<TSource> predicate)
      Returns an long that represents how many elements in a sequence satisfy a condition.

    • max

      @Nullable TSource max()
      Returns the maximum value in a generic sequence.

    • max

      @Nullable BigDecimal max(BigDecimalFunction1<TSource> selector)
      Invokes a transform function on each element of a sequence and returns the maximum Decimal value.

    • max

      @Nullable BigDecimal max(NullableBigDecimalFunction1<TSource> selector)
      Invokes a transform function on each element of a sequence and returns the maximum nullable Decimal value.

    • max

      double max(DoubleFunction1<TSource> selector)
      Invokes a transform function on each element of a sequence and returns the maximum Double value.

    • max

      @Nullable Double max(NullableDoubleFunction1<TSource> selector)
      Invokes a transform function on each element of a sequence and returns the maximum nullable Double value.

    • max

      int max(IntegerFunction1<TSource> selector)
      Invokes a transform function on each element of a sequence and returns the maximum int value.

    • max

      @Nullable Integer max(NullableIntegerFunction1<TSource> selector)
      Invokes a transform function on each element of a sequence and returns the maximum nullable int value. (Defined by Enumerable.)

    • max

      long max(LongFunction1<TSource> selector)
      Invokes a transform function on each element of a sequence and returns the maximum long value.

    • max

      @Nullable Long max(NullableLongFunction1<TSource> selector)
      Invokes a transform function on each element of a sequence and returns the maximum nullable long value. (Defined by Enumerable.)

    • max

      float max(FloatFunction1<TSource> selector)
      Invokes a transform function on each element of a sequence and returns the maximum Float value.

    • max

      @Nullable Float max(NullableFloatFunction1<TSource> selector)
      Invokes a transform function on each element of a sequence and returns the maximum nullable Float value.

    • max

      <TResult extends Comparable<TResult>> @Nullable TResult max(Function1<TSource,TResult> selector)
      Invokes a transform function on each element of a generic sequence and returns the maximum resulting value.

    • min

      @Nullable TSource min()
      Returns the minimum value in a generic sequence.

    • min

      @Nullable BigDecimal min(BigDecimalFunction1<TSource> selector)
      Invokes a transform function on each element of a sequence and returns the minimum Decimal value.

    • min

      @Nullable BigDecimal min(NullableBigDecimalFunction1<TSource> selector)
      Invokes a transform function on each element of a sequence and returns the minimum nullable Decimal value.

    • min

      double min(DoubleFunction1<TSource> selector)
      Invokes a transform function on each element of a sequence and returns the minimum Double value.

    • min

      @Nullable Double min(NullableDoubleFunction1<TSource> selector)
      Invokes a transform function on each element of a sequence and returns the minimum nullable Double value.

    • min

      int min(IntegerFunction1<TSource> selector)
      Invokes a transform function on each element of a sequence and returns the minimum int value.

    • min

      @Nullable Integer min(NullableIntegerFunction1<TSource> selector)
      Invokes a transform function on each element of a sequence and returns the minimum nullable int value. (Defined by Enumerable.)

    • min

      long min(LongFunction1<TSource> selector)
      Invokes a transform function on each element of a sequence and returns the minimum long value.

    • min

      @Nullable Long min(NullableLongFunction1<TSource> selector)
      Invokes a transform function on each element of a sequence and returns the minimum nullable long value. (Defined by Enumerable.)

    • min

      float min(FloatFunction1<TSource> selector)
      Invokes a transform function on each element of a sequence and returns the minimum Float value.

    • min

      @Nullable Float min(NullableFloatFunction1<TSource> selector)
      Invokes a transform function on each element of a sequence and returns the minimum nullable Float value.

    • min

      <TResult extends Comparable<TResult>> @Nullable TResult min(Function1<TSource,TResult> selector)
      Invokes a transform function on each element of a generic sequence and returns the minimum resulting value.

    • ofType

      <TResult> Enumerable<TResult> ofType(Class<TResult> clazz)
      Filters the elements of an Enumerable based on a specified type.

      Analogous to LINQ's Enumerable.OfType extension method.

      Type Parameters:
      TResult - Target type
      Parameters:
      clazz - Target type
      Returns:
      Collection of T2

    • orderBy

      <TKey extends Comparable> Enumerable<TSource> orderBy(Function1<TSource,TKey> keySelector)
      Sorts the elements of a sequence in ascending order according to a key.

    • orderBy

      <TKey> Enumerable<TSource> orderBy(Function1<TSource,TKey> keySelector, Comparator<TKey> comparator)
      Sorts the elements of a sequence in ascending order by using a specified comparer.

    • orderByDescending

      <TKey extends Comparable> Enumerable<TSource> orderByDescending(Function1<TSource,TKey> keySelector)
      Sorts the elements of a sequence in descending order according to a key.

    • orderByDescending

      <TKey> Enumerable<TSource> orderByDescending(Function1<TSource,TKey> keySelector, Comparator<TKey> comparator)
      Sorts the elements of a sequence in descending order by using a specified comparer.

    • reverse

      Enumerable<TSource> reverse()
      Inverts the order of the elements in a sequence.

    • select

      <TResult> Enumerable<TResult> select(Function1<TSource,TResult> selector)
      Projects each element of a sequence into a new form.

    • select

      <TResult> Enumerable<TResult> select(Function2<TSource,Integer,TResult> selector)
      Projects each element of a sequence into a new form by incorporating the element's index.

    • selectMany

      <TResult> Enumerable<TResult> selectMany(Function1<TSource,Enumerable<TResult>> selector)
      Projects each element of a sequence to an Enumerable<TSource> and flattens the resulting sequences into one sequence.

    • selectMany

      <TResult> Enumerable<TResult> selectMany(Function2<TSource,Integer,Enumerable<TResult>> selector)
      Projects each element of a sequence to an Enumerable<TSource>, and flattens the resulting sequences into one sequence. The index of each source element is used in the projected form of that element.

    • selectMany

      <TCollection, TResult> Enumerable<TResult> selectMany(Function2<TSource,Integer,Enumerable<TCollection>> collectionSelector, Function2<TSource,TCollection,TResult> resultSelector)
      Projects each element of a sequence to an Enumerable<TSource>, flattens the resulting sequences into one sequence, and invokes a result selector function on each element therein. The index of each source element is used in the intermediate projected form of that element.

    • selectMany

      <TCollection, TResult> Enumerable<TResult> selectMany(Function1<TSource,Enumerable<TCollection>> collectionSelector, Function2<TSource,TCollection,TResult> resultSelector)
      Projects each element of a sequence to an Enumerable<TSource>, flattens the resulting sequences into one sequence, and invokes a result selector function on each element therein.

    • sequenceEqual

      boolean sequenceEqual(Enumerable<TSource> enumerable1)
      Determines whether two sequences are equal by comparing the elements by using the default equality comparer for their type.

    • sequenceEqual

      boolean sequenceEqual(Enumerable<TSource> enumerable1, EqualityComparer<TSource> comparer)
      Determines whether two sequences are equal by comparing their elements by using a specified EqualityComparer<TSource>.

    • single

      TSource single()
      Returns the only element of a sequence, and throws an exception if there is not exactly one element in the sequence.

    • single

      TSource single(Predicate1<TSource> predicate)
      Returns the only element of a sequence that satisfies a specified condition, and throws an exception if more than one such element exists.

    • singleOrDefault

      @Nullable TSource singleOrDefault()
      Returns the only element of a sequence, or a default value if the sequence is empty; this method throws an exception if there is more than one element in the sequence.

    • singleOrDefault

      @Nullable TSource singleOrDefault(Predicate1<TSource> predicate)
      Returns the only element of a sequence that satisfies a specified condition or a default value if no such element exists; this method throws an exception if more than one element satisfies the condition.

    • skip

      Enumerable<TSource> skip(int count)
      Bypasses a specified number of elements in a sequence and then returns the remaining elements.

    • skipWhile

      Enumerable<TSource> skipWhile(Predicate1<TSource> predicate)
      Bypasses elements in a sequence as long as a specified condition is true and then returns the remaining elements.

    • skipWhile

      Enumerable<TSource> skipWhile(Predicate2<TSource,Integer> predicate)
      Bypasses elements in a sequence as long as a specified condition is true and then returns the remaining elements. The element's index is used in the logic of the predicate function.

    • sum

      BigDecimal sum(BigDecimalFunction1<TSource> selector)
      Computes the sum of the sequence of Decimal values that are obtained by invoking a transform function on each element of the input sequence.

    • sum

      BigDecimal sum(NullableBigDecimalFunction1<TSource> selector)
      Computes the sum of the sequence of nullable Decimal values that are obtained by invoking a transform function on each element of the input sequence.

    • sum

      double sum(DoubleFunction1<TSource> selector)
      Computes the sum of the sequence of Double values that are obtained by invoking a transform function on each element of the input sequence.

    • sum

      Double sum(NullableDoubleFunction1<TSource> selector)
      Computes the sum of the sequence of nullable Double values that are obtained by invoking a transform function on each element of the input sequence.

    • sum

      int sum(IntegerFunction1<TSource> selector)
      Computes the sum of the sequence of int values that are obtained by invoking a transform function on each element of the input sequence.

    • sum

      Integer sum(NullableIntegerFunction1<TSource> selector)
      Computes the sum of the sequence of nullable int values that are obtained by invoking a transform function on each element of the input sequence.

    • sum

      long sum(LongFunction1<TSource> selector)
      Computes the sum of the sequence of long values that are obtained by invoking a transform function on each element of the input sequence.

    • sum

      Long sum(NullableLongFunction1<TSource> selector)
      Computes the sum of the sequence of nullable long values that are obtained by invoking a transform function on each element of the input sequence.

    • sum

      float sum(FloatFunction1<TSource> selector)
      Computes the sum of the sequence of Float values that are obtained by invoking a transform function on each element of the input sequence.

    • sum

      Float sum(NullableFloatFunction1<TSource> selector)
      Computes the sum of the sequence of nullable Float values that are obtained by invoking a transform function on each element of the input sequence.

    • take

      Enumerable<TSource> take(int count)
      Returns a specified number of contiguous elements from the start of a sequence.

    • takeWhile

      Enumerable<TSource> takeWhile(Predicate1<TSource> predicate)
      Returns elements from a sequence as long as a specified condition is true.

    • takeWhile

      Enumerable<TSource> takeWhile(Predicate2<TSource,Integer> predicate)
      Returns elements from a sequence as long as a specified condition is true. The element's index is used in the logic of the predicate function.

    • toMap

      <TKey> Map<TKey,TSource> toMap(Function1<TSource,TKey> keySelector)
      Creates a Map<TKey, TValue> from an Enumerable<TSource> according to a specified key selector function.

      NOTE: Called toDictionary in LINQ.NET.

    • toMap

      <TKey> Map<TKey,TSource> toMap(Function1<TSource,TKey> keySelector, EqualityComparer<TKey> comparer)
      Creates a Map<TKey, TValue> from an Enumerable<TSource> according to a specified key selector function and key comparer.

    • toMap

      <TKey, TElement> Map<TKey,TElement> toMap(Function1<TSource,TKey> keySelector, Function1<TSource,TElement> elementSelector)
      Creates a Map<TKey, TValue> from an Enumerable<TSource> according to specified key selector and element selector functions.

    • toMap

      <TKey, TElement> Map<TKey,TElement> toMap(Function1<TSource,TKey> keySelector, Function1<TSource,TElement> elementSelector, EqualityComparer<TKey> comparer)
      Creates a Map<TKey, TValue> from an Enumerable<TSource> according to a specified key selector function, a comparer, and an element selector function.

    • toList

      List<TSource> toList()
      Creates a List<TSource> from an Enumerable<TSource>.

    • toLookup

      <TKey> Lookup<TKey,TSource> toLookup(Function1<TSource,TKey> keySelector)
      Creates a Lookup<TKey, TElement> from an Enumerable<TSource> according to a specified key selector function.

    • toLookup

      <TKey> Lookup<TKey,TSource> toLookup(Function1<TSource,TKey> keySelector, EqualityComparer<TKey> comparer)
      Creates a Lookup<TKey, TElement> from an Enumerable<TSource> according to a specified key selector function and key comparer.

    • toLookup

      <TKey, TElement> Lookup<TKey,TElement> toLookup(Function1<TSource,TKey> keySelector, Function1<TSource,TElement> elementSelector)
      Creates a Lookup<TKey, TElement> from an Enumerable<TSource> according to specified key selector and element selector functions.

    • toLookup

      <TKey, TElement> Lookup<TKey,TElement> toLookup(Function1<TSource,TKey> keySelector, Function1<TSource,TElement> elementSelector, EqualityComparer<TKey> comparer)
      Creates a Lookup<TKey, TElement> from an Enumerable<TSource> according to a specified key selector function, a comparer and an element selector function.

    • union

      Enumerable<TSource> union(Enumerable<TSource> source1)
      Produces the set union of two sequences by using the default equality comparer.

    • union

      Enumerable<TSource> union(Enumerable<TSource> source1, EqualityComparer<TSource> comparer)
      Produces the set union of two sequences by using a specified EqualityComparer<TSource>.

    • where

      Enumerable<TSource> where(Predicate1<TSource> predicate)
      Filters a sequence of values based on a predicate.

    • where

      Enumerable<TSource> where(Predicate2<TSource,Integer> predicate)
      Filters a sequence of values based on a predicate. Each element's index is used in the logic of the predicate function.

    • zip

      <T1, TResult> Enumerable<TResult> zip(Enumerable<T1> source1, Function2<TSource,T1,TResult> resultSelector)
      Applies a specified function to the corresponding elements of two sequences, producing a sequence of the results.