T
- component typepublic interface LinearSeq<T> extends Seq<T>
Efficient head()
, tail()
, and isEmpty()
methods are characteristic for linear sequences.
λ.Memoized
Modifier and Type | Field and Description |
---|---|
static long |
serialVersionUID |
Modifier and Type | Method and Description |
---|---|
LinearSeq<T> |
append(T element)
Appends an element to this.
|
LinearSeq<T> |
appendAll(Iterable<? extends T> elements)
Appends all given elements to this.
|
LinearSeq<? extends LinearSeq<T>> |
combinations()
Returns the union of all combinations from k = 0 to length().
|
LinearSeq<? extends LinearSeq<T>> |
combinations(int k)
Returns the k-combination of this traversable, i.e.
|
Iterator<? extends LinearSeq<T>> |
crossProduct(int power)
Calculates the n-ary cartesian power (or cross product or simply product) of this.
|
LinearSeq<T> |
distinct()
Returns a new version of this which contains no duplicates.
|
LinearSeq<T> |
distinctBy(Comparator<? super T> comparator)
Returns a new version of this which contains no duplicates.
|
<U> LinearSeq<T> |
distinctBy(Function<? super T,? extends U> keyExtractor)
Returns a new version of this which contains no duplicates.
|
LinearSeq<T> |
drop(long n)
Drops the first n elements of this or all elements, if this length < n.
|
LinearSeq<T> |
dropRight(long n)
Drops the last n elements of this or all elements, if this length < n.
|
LinearSeq<T> |
dropUntil(Predicate<? super T> predicate)
Drops elements until the predicate holds for the current element.
|
LinearSeq<T> |
dropWhile(Predicate<? super T> predicate)
Drops elements while the predicate holds for the current element.
|
LinearSeq<T> |
filter(Predicate<? super T> predicate)
Returns a new traversable consisting of all elements which satisfy the given predicate.
|
<U> LinearSeq<U> |
flatMap(Function<? super T,? extends Iterable<? extends U>> mapper)
FlatMaps this Traversable.
|
<C> Map<C,? extends LinearSeq<T>> |
groupBy(Function<? super T,? extends C> classifier)
Groups this elements by classifying the elements.
|
Iterator<? extends LinearSeq<T>> |
grouped(long size)
Groups this
Traversable into fixed size blocks. |
default int |
indexWhere(Predicate<? super T> predicate,
int from)
Finds index of the first element satisfying some predicate after or at
some start index.
|
LinearSeq<T> |
init()
Dual of Traversable.tail(), returning all elements except the last.
|
Option<? extends LinearSeq<T>> |
initOption()
Dual of Traversable.tailOption(), returning all elements except the last as
Option . |
LinearSeq<T> |
insert(int index,
T element)
Inserts the given element at the specified index.
|
LinearSeq<T> |
insertAll(int index,
Iterable<? extends T> elements)
Inserts the given elements at the specified index.
|
LinearSeq<T> |
intersperse(T element)
Inserts an element between all elements of this Traversable.
|
default int |
lastIndexOfSlice(Iterable<? extends T> that,
int end)
Finds last index before or at a given end index where this sequence contains a given sequence as a slice.
|
default int |
lastIndexWhere(Predicate<? super T> predicate,
int end)
Finds index of last element satisfying some predicate before or at given
end index.
|
<U> LinearSeq<U> |
map(Function<? super T,? extends U> mapper)
Maps the elements of this
Traversable to elements of a new type preserving their order, if any. |
static <T> LinearSeq<T> |
narrow(LinearSeq<? extends T> linearSeq)
Narrows a widened
LinearSeq<? extends T> to LinearSeq<T>
by performing a type safe-cast. |
LinearSeq<T> |
padTo(int length,
T element)
A copy of this sequence with an element appended until a given target length is reached.
|
Tuple2<? extends LinearSeq<T>,? extends LinearSeq<T>> |
partition(Predicate<? super T> predicate)
Creates a partition of this
Traversable by splitting this elements in two in distinct tarversables
according to a predicate. |
LinearSeq<T> |
patch(int from,
Iterable<? extends T> that,
int replaced)
Produces a new list where a slice of elements in this list is replaced by another sequence.
|
LinearSeq<T> |
peek(Consumer<? super T> action)
Performs the given
action on the first element if this is an eager implementation. |
LinearSeq<? extends LinearSeq<T>> |
permutations()
Computes all unique permutations.
|
LinearSeq<T> |
prepend(T element)
Prepends an element to this.
|
LinearSeq<T> |
prependAll(Iterable<? extends T> elements)
Prepends all given elements to this.
|
LinearSeq<T> |
remove(T element)
Removes the first occurrence of the given element.
|
LinearSeq<T> |
removeAll(Iterable<? extends T> elements)
Removes all occurrences of the given elements.
|
LinearSeq<T> |
removeAll(T element)
Removes all occurrences of the given element.
|
LinearSeq<T> |
removeAt(int index)
Removes the element at the specified position in this sequence.
|
LinearSeq<T> |
removeFirst(Predicate<T> predicate)
Removes the first occurrence that satisfy predicate
|
LinearSeq<T> |
removeLast(Predicate<T> predicate)
Removes the last occurrence that satisfy predicate
|
LinearSeq<T> |
replace(T currentElement,
T newElement)
Replaces the first occurrence (if exists) of the given currentElement with newElement.
|
LinearSeq<T> |
replaceAll(T currentElement,
T newElement)
Replaces all occurrences of the given currentElement with newElement.
|
LinearSeq<T> |
retainAll(Iterable<? extends T> elements)
Keeps all occurrences of the given elements from this.
|
LinearSeq<T> |
reverse()
Reverses the order of elements.
|
default Iterator<T> |
reverseIterator()
An iterator yielding elements in reversed order.
|
LinearSeq<T> |
scan(T zero,
BiFunction<? super T,? super T,? extends T> operation)
Computes a prefix scan of the elements of the collection.
|
<U> LinearSeq<U> |
scanLeft(U zero,
BiFunction<? super U,? super T,? extends U> operation)
Produces a collection containing cumulative results of applying the
operator going left to right.
|
<U> LinearSeq<U> |
scanRight(U zero,
BiFunction<? super T,? super U,? extends U> operation)
Produces a collection containing cumulative results of applying the
operator going right to left.
|
default int |
search(T element)
Searches this sequence for a specific element using a linear search.
|
default int |
search(T element,
Comparator<? super T> comparator)
Searches this sequence for a specific element using a linear search.
|
default int |
segmentLength(Predicate<? super T> predicate,
int from)
Computes length of longest segment whose elements all satisfy some predicate.
|
LinearSeq<T> |
slice(long beginIndex,
long endIndex)
Returns a Seq that is a slice of this.
|
Iterator<? extends LinearSeq<T>> |
sliding(long size)
Slides a window of a specific
size and step size 1 over this Traversable by calling
Traversable.sliding(long, long) . |
Iterator<? extends LinearSeq<T>> |
sliding(long size,
long step)
Slides a window of a specific
size and step size over this Traversable . |
<U> LinearSeq<T> |
sortBy(Comparator<? super U> comparator,
Function<? super T,? extends U> mapper)
Sorts this elements by comparing the elements in a different domain, using the given
mapper . |
<U extends Comparable<? super U>> |
sortBy(Function<? super T,? extends U> mapper)
Sorts this elements by comparing the elements in a different domain, using the given
mapper . |
LinearSeq<T> |
sorted()
Sorts this elements according to their natural order.
|
LinearSeq<T> |
sorted(Comparator<? super T> comparator)
Sorts this elements according to the provided
Comparator . |
Tuple2<? extends LinearSeq<T>,? extends LinearSeq<T>> |
span(Predicate<? super T> predicate)
Returns a tuple where the first element is the longest prefix of elements that satisfy the given
predicate and the second element is the remainder. |
LinearSeq<T> |
subSequence(int beginIndex)
Returns a Seq that is a subsequence of this.
|
LinearSeq<T> |
subSequence(int beginIndex,
int endIndex)
Returns a Seq that is a subsequence of this.
|
LinearSeq<T> |
tail()
Drops the first element of a non-empty Traversable.
|
Option<? extends LinearSeq<T>> |
tailOption()
Drops the first element of a non-empty Traversable and returns an
Option . |
LinearSeq<T> |
take(long n)
Takes the first n elements of this or all elements, if this length < n.
|
LinearSeq<T> |
takeRight(long n)
Takes the last n elements of this or all elements, if this length < n.
|
LinearSeq<T> |
takeUntil(Predicate<? super T> predicate)
Takes elements until the predicate holds for the current element.
|
LinearSeq<T> |
takeWhile(Predicate<? super T> predicate)
Takes elements while the predicate holds for the current element.
|
<U> LinearSeq<U> |
unit(Iterable<? extends U> iterable) |
<T1,T2> Tuple2<? extends LinearSeq<T1>,? extends LinearSeq<T2>> |
unzip(Function<? super T,Tuple2<? extends T1,? extends T2>> unzipper)
Unzips this elements by mapping this elements to pairs which are subsequently split into two distinct
sets.
|
LinearSeq<T> |
update(int index,
T element)
Updates the given element at the specified index.
|
<U> LinearSeq<Tuple2<T,U>> |
zip(Iterable<? extends U> that)
Returns a traversable formed from this traversable and another Iterable collection by combining
corresponding elements in pairs.
|
<U> LinearSeq<Tuple2<T,U>> |
zipAll(Iterable<? extends U> that,
T thisElem,
U thatElem)
Returns a traversable formed from this traversable and another Iterable by combining corresponding elements in
pairs.
|
LinearSeq<Tuple2<T,Long>> |
zipWithIndex()
Zips this traversable with its indices.
|
apply, containsSlice, crossProduct, crossProduct, endsWith, foldRight, get, indexOf, indexOf, indexOfSlice, indexOfSlice, indexWhere, iterator, lastIndexOf, lastIndexOf, lastIndexOfSlice, lastIndexWhere, narrow, prefixLength, splitAt, splitAt, splitAtInclusive, startsWith, startsWith, unzip3
average, containsAll, count, existsUnique, find, findLast, foldLeft, get, hasDefiniteSize, hash, head, headOption, isEmpty, isSingleValued, isTraversableAgain, iterator, last, lastOption, length, max, maxBy, maxBy, min, minBy, minBy, mkString, mkString, mkString, narrow, nonEmpty, product, reduceLeft, reduceLeftOption, reduceRight, reduceRightOption, size, sum
fold, reduce, reduceOption
contains, corresponds, eq, equals, exists, forAll, forEach, getOption, getOrElse, getOrElse, getOrElseThrow, getOrElseTry, hashCode, narrow, out, out, stderr, stdout, stringPrefix, toArray, toCharSeq, toJavaArray, toJavaArray, toJavaCollection, toJavaList, toJavaList, toJavaMap, toJavaMap, toJavaOptional, toJavaSet, toJavaSet, toJavaStream, toLeft, toLeft, toList, toMap, toOption, toQueue, toRight, toRight, toSet, toStack, toStream, toString, toTree, toTry, toTry, toVector
spliterator
andThen, arity, compose, curried, identity, lift, memoized, of, reversed, tupled
isMemoized
static final long serialVersionUID
static <T> LinearSeq<T> narrow(LinearSeq<? extends T> linearSeq)
LinearSeq<? extends T>
to LinearSeq<T>
by performing a type safe-cast. This is eligible because immutable/read-only
collections are covariant.T
- Component type of the LinearSeq
.linearSeq
- A LinearSeq
.linearSeq
instance as narrowed type LinearSeq<T>
.LinearSeq<T> append(T element)
Seq
LinearSeq<T> appendAll(Iterable<? extends T> elements)
Seq
LinearSeq<? extends LinearSeq<T>> combinations()
Seq
Examples:
[].combinations() = [[]]
[1,2,3].combinations() = [
[], // k = 0
[1], [2], [3], // k = 1
[1,2], [1,3], [2,3], // k = 2
[1,2,3] // k = 3
]
combinations
in interface Seq<T>
LinearSeq<? extends LinearSeq<T>> combinations(int k)
Seq
combinations
in interface Seq<T>
k
- Size of subsetsIterator<? extends LinearSeq<T>> crossProduct(int power)
Seq
Example:
// = ((A,A), (A,B), (A,C), ..., (B,A), (B,B), ..., (Z,Y), (Z,Z))
CharSeq.rangeClosed('A', 'Z').crossProduct(2);
crossProduct
in interface Seq<T>
power
- the number of cartesian multiplicationsLinearSeq<T> distinct()
Traversable
equals
.LinearSeq<T> distinctBy(Comparator<? super T> comparator)
Traversable
comparator
.distinctBy
in interface Seq<T>
distinctBy
in interface Traversable<T>
comparator
- A comparatorTraversable
containing this elements without duplicates<U> LinearSeq<T> distinctBy(Function<? super T,? extends U> keyExtractor)
Traversable
equals
.
The elements of the result are determined in the order of their occurrence - first match wins.
distinctBy
in interface Seq<T>
distinctBy
in interface Traversable<T>
U
- key typekeyExtractor
- A key extractorTraversable
containing this elements without duplicatesLinearSeq<T> drop(long n)
Traversable
LinearSeq<T> dropRight(long n)
Traversable
LinearSeq<T> dropUntil(Predicate<? super T> predicate)
Traversable
Note: This is essentially the same as dropWhile(predicate.negate())
. It is intended to be used with
method references, which cannot be negated directly.
LinearSeq<T> dropWhile(Predicate<? super T> predicate)
Traversable
dropWhile
in interface Seq<T>
dropWhile
in interface Traversable<T>
predicate
- A condition tested subsequently for this elements starting with the first.LinearSeq<T> filter(Predicate<? super T> predicate)
Traversable
<U> LinearSeq<U> flatMap(Function<? super T,? extends Iterable<? extends U>> mapper)
Traversable
<C> Map<C,? extends LinearSeq<T>> groupBy(Function<? super T,? extends C> classifier)
Traversable
Iterator<? extends LinearSeq<T>> grouped(long size)
Traversable
Traversable
into fixed size blocks.
Let length be the length of this Iterable. Then grouped is defined as follows:
this.isEmpty()
, the resulting Iterator
is empty.size <= length
, the resulting Iterator
will contain length / size
blocks of size
size
and maybe a non-empty block of size length % size
, if there are remaining elements.size > length
, the resulting Iterator
will contain one block of size length
.
[].grouped(1) = []
[].grouped(0) throws
[].grouped(-1) throws
[1,2,3,4].grouped(2) = [[1,2],[3,4]]
[1,2,3,4,5].grouped(2) = [[1,2],[3,4],[5]]
[1,2,3,4].grouped(5) = [[1,2,3,4]]
Please note that grouped(int)
is a special case of Traversable.sliding(long, long), i.e.
grouped(size)
is the same as sliding(size, size)
.default int indexWhere(Predicate<? super T> predicate, int from)
Seq
indexWhere
in interface Seq<T>
predicate
- the predicate used to test elements.from
- the start index>= from
of the first element of this Seq that
satisfies the given predicate
, or -1
, if none exists.LinearSeq<T> init()
Traversable
Option<? extends LinearSeq<T>> initOption()
Traversable
Option
.initOption
in interface Seq<T>
initOption
in interface Traversable<T>
Some(traversable)
or None
if this is empty.LinearSeq<T> insert(int index, T element)
Seq
LinearSeq<T> insertAll(int index, Iterable<? extends T> elements)
Seq
LinearSeq<T> intersperse(T element)
Seq
intersperse
in interface Seq<T>
element
- An element.default int lastIndexOfSlice(Iterable<? extends T> that, int end)
Seq
lastIndexOfSlice
in interface Seq<T>
that
- the sequence to testend
- the end indexdefault int lastIndexWhere(Predicate<? super T> predicate, int end)
Seq
lastIndexWhere
in interface Seq<T>
predicate
- the predicate used to test elements.end
- the maximum index of the search<= end
of the last element of this Seq that
satisfies the given predicate
, or -1
, if none exists.<U> LinearSeq<U> map(Function<? super T,? extends U> mapper)
Traversable
Traversable
to elements of a new type preserving their order, if any.LinearSeq<T> padTo(int length, T element)
Seq
LinearSeq<T> patch(int from, Iterable<? extends T> that, int replaced)
Seq
Tuple2<? extends LinearSeq<T>,? extends LinearSeq<T>> partition(Predicate<? super T> predicate)
Traversable
Traversable
by splitting this elements in two in distinct tarversables
according to a predicate.partition
in interface Seq<T>
partition
in interface Traversable<T>
predicate
- A predicate which classifies an element if it is in the first or the second traversable.Traversable
contains all elements that satisfy the given predicate
, the second Traversable
contains all elements that don't. The original order of elements is preserved.LinearSeq<T> peek(Consumer<? super T> action)
Value
action
on the first element if this is an eager implementation.
Performs the given action
on all elements (the first immediately, successive deferred),
if this is a lazy implementation.LinearSeq<? extends LinearSeq<T>> permutations()
Seq
Example:
[].permutations() = []
[1,2,3].permutations() = [
[1,2,3],
[1,3,2],
[2,1,3],
[2,3,1],
[3,1,2],
[3,2,1]
]
permutations
in interface Seq<T>
LinearSeq<T> prepend(T element)
Seq
LinearSeq<T> prependAll(Iterable<? extends T> elements)
Seq
prependAll
in interface Seq<T>
elements
- An Iterable of elementsLinearSeq<T> remove(T element)
Seq
LinearSeq<T> removeFirst(Predicate<T> predicate)
Seq
removeFirst
in interface Seq<T>
predicate
- an predicateLinearSeq<T> removeLast(Predicate<T> predicate)
Seq
removeLast
in interface Seq<T>
predicate
- an predicateLinearSeq<T> removeAt(int index)
Seq
LinearSeq<T> removeAll(T element)
Seq
LinearSeq<T> removeAll(Iterable<? extends T> elements)
Seq
LinearSeq<T> replace(T currentElement, T newElement)
Traversable
replace
in interface Seq<T>
replace
in interface Traversable<T>
currentElement
- An element to be substituted.newElement
- A replacement for currentElement.LinearSeq<T> replaceAll(T currentElement, T newElement)
Traversable
replaceAll
in interface Seq<T>
replaceAll
in interface Traversable<T>
currentElement
- An element to be substituted.newElement
- A replacement for currentElement.LinearSeq<T> retainAll(Iterable<? extends T> elements)
Traversable
LinearSeq<T> reverse()
Seq
default Iterator<T> reverseIterator()
Seq
Note: xs.reverseIterator()
is the same as xs.reverse().iterator()
but might
be more efficient.
reverseIterator
in interface Seq<T>
LinearSeq<T> scan(T zero, BiFunction<? super T,? super T,? extends T> operation)
Traversable
scan
in interface Seq<T>
scan
in interface Traversable<T>
zero
- neutral element for the operator opoperation
- the associative operator for the scan<U> LinearSeq<U> scanLeft(U zero, BiFunction<? super U,? super T,? extends U> operation)
Traversable
scanLeft
in interface Seq<T>
scanLeft
in interface Traversable<T>
U
- the type of the elements in the resulting collectionzero
- the initial valueoperation
- the binary operator applied to the intermediate result and the element<U> LinearSeq<U> scanRight(U zero, BiFunction<? super T,? super U,? extends U> operation)
Traversable
scanRight
in interface Seq<T>
scanRight
in interface Traversable<T>
U
- the type of the elements in the resulting collectionzero
- the initial valueoperation
- the binary operator applied to the intermediate result and the elementdefault int segmentLength(Predicate<? super T> predicate, int from)
Seq
segmentLength
in interface Seq<T>
predicate
- the predicate used to test elements.from
- the index where the search starts.LinearSeq<T> slice(long beginIndex, long endIndex)
Seq
beginIndex
and extends to the element at index endIndex - 1
.
Examples:
List.of(1, 2, 3, 4).slice(1, 3); // = (2, 3)
List.of(1, 2, 3, 4).slice(0, 4); // = (1, 2, 3, 4)
List.of(1, 2, 3, 4).slice(2, 2); // = ()
List.of(1, 2).slice(1, 0); // = ()
List.of(1, 2).slice(-10, 10); // = (1, 2)
See also Seq.subSequence(int, int)
which throws in some cases instead of returning a sequence.Iterator<? extends LinearSeq<T>> sliding(long size)
Traversable
size
and step size 1 over this Traversable
by calling
Traversable.sliding(long, long)
.Iterator<? extends LinearSeq<T>> sliding(long size, long step)
Traversable
size
and step
size over this Traversable
.
Examples:
[].sliding(1,1) = []
[1,2,3,4,5].sliding(2,3) = [[1,2],[4,5]]
[1,2,3,4,5].sliding(2,4) = [[1,2],[5]]
[1,2,3,4,5].sliding(2,5) = [[1,2]]
[1,2,3,4].sliding(5,3) = [[1,2,3,4],[4]]
LinearSeq<T> sorted()
Seq
Comparable
, a java.lang.ClassCastException
may be thrown.LinearSeq<T> sorted(Comparator<? super T> comparator)
Seq
Comparator
. If this elements are not
Comparable
, a java.lang.ClassCastException
may be thrown.<U extends Comparable<? super U>> LinearSeq<T> sortBy(Function<? super T,? extends U> mapper)
Seq
mapper
.<U> LinearSeq<T> sortBy(Comparator<? super U> comparator, Function<? super T,? extends U> mapper)
Seq
mapper
.Tuple2<? extends LinearSeq<T>,? extends LinearSeq<T>> span(Predicate<? super T> predicate)
Traversable
predicate
and the second element is the remainder.LinearSeq<T> subSequence(int beginIndex)
Seq
beginIndex
and extends to the end of this Seq.
Examples:
List.of(1, 2).subSequence(0); // = (1, 2)
List.of(1, 2).subSequence(1); // = (2)
List.of(1, 2).subSequence(2); // = ()
List.of(1, 2).subSequence(10); // throws IndexOutOfBoundsException
List.of(1, 2).subSequence(-10); // throws IndexOutOfBoundsException
See also Seq.drop(long)
which is similar but does not throw.subSequence
in interface Seq<T>
beginIndex
- the beginning index, inclusiveLinearSeq<T> subSequence(int beginIndex, int endIndex)
Seq
beginIndex
and extends to the element at index endIndex - 1
.
Examples:
List.of(1, 2, 3, 4).subSequence(1, 3); // = (2, 3)
List.of(1, 2, 3, 4).subSequence(0, 4); // = (1, 2, 3, 4)
List.of(1, 2, 3, 4).subSequence(2, 2); // = ()
List.of(1, 2).subSequence(1, 0); // throws IndexOutOfBoundsException
List.of(1, 2).subSequence(-10, 1); // throws IndexOutOfBoundsException
List.of(1, 2).subSequence(0, 10); // throws IndexOutOfBoundsException
See also Seq.slice(long, long)
which returns an empty sequence instead of throwing.subSequence
in interface Seq<T>
beginIndex
- the beginning index, inclusiveendIndex
- the end index, exclusiveLinearSeq<T> tail()
Traversable
Option<? extends LinearSeq<T>> tailOption()
Traversable
Option
.tailOption
in interface Seq<T>
tailOption
in interface Traversable<T>
Some(traversable)
or None
if this is empty.LinearSeq<T> take(long n)
Traversable
The result is equivalent to sublist(0, max(0, min(length(), n)))
but does not throw if n < 0
or
n > length()
.
In the case of n < 0
the empty instance is returned, in the case of n > length()
this is returned.
LinearSeq<T> takeRight(long n)
Traversable
The result is equivalent to sublist(max(0, min(length(), length() - n)), n)
, i.e. takeRight will not
throw if n < 0
or n > length()
.
In the case of n < 0
the empty instance is returned, in the case of n > length()
this is returned.
LinearSeq<T> takeUntil(Predicate<? super T> predicate)
Traversable
Note: This is essentially the same as takeWhile(predicate.negate())
. It is intended to be used with
method references, which cannot be negated directly.
LinearSeq<T> takeWhile(Predicate<? super T> predicate)
Traversable
<T1,T2> Tuple2<? extends LinearSeq<T1>,? extends LinearSeq<T2>> unzip(Function<? super T,Tuple2<? extends T1,? extends T2>> unzipper)
Traversable
unzip
in interface Seq<T>
unzip
in interface Traversable<T>
T1
- 1st element type of a pair returned by unzipperT2
- 2nd element type of a pair returned by unzipperunzipper
- a function which converts elements of this to pairsLinearSeq<T> update(int index, T element)
Seq
<U> LinearSeq<Tuple2<T,U>> zip(Iterable<? extends U> that)
Traversable
The length of the returned traversable is the minimum of the lengths of this traversable and that
iterable.
zip
in interface Seq<T>
zip
in interface Traversable<T>
U
- The type of the second half of the returned pairs.that
- The Iterable providing the second half of each result pair.that
iterable.<U> LinearSeq<Tuple2<T,U>> zipAll(Iterable<? extends U> that, T thisElem, U thatElem)
Traversable
The length of the returned traversable is the maximum of the lengths of this traversable and that
iterable.
Special case: if this traversable is shorter than that elements, and that elements contains duplicates, the resulting traversable may be shorter than the maximum of the lengths of this and that because a traversable contains an element at most once.
If this Traversable is shorter than that, thisElem values are used to fill the result. If that is shorter than this Traversable, thatElem values are used to fill the result.
zipAll
in interface Seq<T>
zipAll
in interface Traversable<T>
U
- The type of the second half of the returned pairs.that
- The Iterable providing the second half of each result pair.thisElem
- The element to be used to fill up the result if this traversable is shorter than that.thatElem
- The element to be used to fill up the result if that is shorter than this traversable.LinearSeq<Tuple2<T,Long>> zipWithIndex()
Traversable
zipWithIndex
in interface Seq<T>
zipWithIndex
in interface Traversable<T>
default int search(T element)
search
in interface Seq<T>
element
- the element to findClassCastException
- if T cannot be cast to Comparable<? super T>
default int search(T element, Comparator<? super T> comparator)
search
in interface Seq<T>
element
- the element to findcomparator
- the comparator by which this sequence is orderedCopyright © 2016. All Rights Reserved.