Top Description Inners Fields Methods
io.vavr.collection

public Interface List<T>

Additional top-level class in compilation unit: ListModule.

extends LinearSeq<T>
Known Direct Implementers
io.vavr.collection.List.Nil, io.vavr.collection.List.Cons
Type Parameters
<T>
Component type of the List
Imports
io.vavr.PartialFunction, .Tuple, .Tuple2, .Tuple3, io.vavr.collection.List.Nil, .ListModule.Combinations, .ListModule.SplitAt, io.vavr.control.Option, java.io.*, java.util.*, java.util.function.*, java.util.stream.Collector
An immutable List is an eager sequence of elements. Its immutability makes it suitable for concurrent programming.

A List is composed of a head element and a tail List.

There are two implementations of the List interface:

A List is a Stack in the sense that it stores elements allowing a last-in-first-out (LIFO) retrieval.

Stack API:

Methods to obtain a List: 

// factory methods
List.empty()                        // = List.of() = Nil.instance()
List.of(x)                          // = new Cons<>(x, Nil.instance())
List.of(Object...)                  // e.g. List.of(1, 2, 3)
List.ofAll(Iterable)                // e.g. List.ofAll(Stream.of(1, 2, 3)) = 1, 2, 3
List.ofAll(<primitive array>) // e.g. List.of(new int[] {1, 2, 3}) = 1, 2, 3

// int sequences
List.range(0, 3)              // = 0, 1, 2
List.rangeClosed(0, 3)        // = 0, 1, 2, 3
Note: A List is primarily a Seq and extends Stack for technical reasons (so Stack does not need to wrap List).

If operating on a List, please prefer

Factory method applications: 

List<Integer>       s1 = List.of(1);
List<Integer>       s2 = List.of(1, 2, 3);
                          // = List.of(new Integer[] {1, 2, 3});

List<int[]>         s3 = List.ofAll(1, 2, 3);
List<List<Integer>> s4 = List.ofAll(List.of(1, 2, 3));

List<Integer>       s5 = List.ofAll(1, 2, 3);
List<Integer>       s6 = List.ofAll(List.of(1, 2, 3));

// cuckoo's egg
List<Integer[]>     s7 = List.<Integer[]> of(new Integer[] {1, 2, 3});
Example: Converting a String to digits 

// = List(1, 2, 3)
List.of("123".toCharArray()).map(c -> Character.digit(c, 10))
See Okasaki, Chris: Purely Functional Data Structures (p. 7 ff.). Cambridge, 2003.
Author
Daniel Dietrich

Nested and Inner Type Summary

Modifier and TypeClass and Description
public static class
List.Cons<
Component type of the List.
T>

Non-empty List, consisting of a head and a tail.

public static class
List.Nil<
Component type of the List.
T>

Representation of the singleton empty List.

Field Summary

Modifier and TypeField and Description
public static final long
serialVersionUID

Hides io.vavr.collection.LinearSeq.serialVersionUID.

Method Summary

Modifier and TypeMethod and Description
public default List<T>
append(T
An element
element)

Implements io.vavr.collection.LinearSeq.append.

Appends an element to this.

public default List<T>
appendAll(Iterable<? extends T>
An Iterable of elements
elements)

Implements io.vavr.collection.LinearSeq.appendAll.

Appends all given elements to this.

public default List<T>
asJava()

Implements io.vavr.collection.Seq.asJava.

Creates an immutable java.util.List view on top of this Seq, i.e. calling mutators will result in UnsupportedOperationException at runtime.

public default List<T>
asJava(Consumer<? super List<T>>
A side-effecting unit of work that operates on an immutable java.util.List view.
action)

Implements io.vavr.collection.LinearSeq.asJava.

Creates an immutable java.util.List view on top of this Seq that is passed to the given action.

public default List<T>
asJavaMutable()

Implements io.vavr.collection.Seq.asJavaMutable.

Creates a mutable java.util.List view on top of this Seq, i.e. all mutator methods of the java.util.List are implemented.

public default List<T>
asJavaMutable(Consumer<? super List<T>>
A side-effecting unit of work that operates on a mutable java.util.List view.
action)

Implements io.vavr.collection.LinearSeq.asJavaMutable.

Creates a mutable java.util.List view on top of this Seq that is passed to the given action.

public default <R> List<R>
collect(PartialFunction<? super T, ? extends R>
A function that is not necessarily defined of all elements of this traversable.
partialFunction)

Implements io.vavr.collection.LinearSeq.collect.

Collects all elements that are in the domain of the given partialFunction by mapping the elements to type R.

public static <
Component type of the List.
T> Collector<T, ArrayList<T>, List<T>>

Returns:

A io.vavr.collection.List Collector.
collector()

Returns a java.util.stream.Collector which may be used in conjunction with java.util.stream.Stream#collect(java.util.stream.Collector) to obtain a List.

public default List<List<T>>
combinations()

Implements io.vavr.collection.LinearSeq.combinations.

Returns the union of all combinations from k = 0 to length().

public default List<List<T>>
combinations(int
Size of subsets
k)

Implements io.vavr.collection.LinearSeq.combinations.

Returns the k-combination of this traversable, i.e. all subset of this of k distinct elements.

public default Iterator<List<T>>
crossProduct(int
the number of cartesian multiplications
power)

Implements io.vavr.collection.LinearSeq.crossProduct.

Calculates the n-ary cartesian power (or cross product or simply product) of this.

public default List<T>
distinct()

Implements io.vavr.collection.LinearSeq.distinct.

Returns a new version of this which contains no duplicates.

public default List<T>
distinctBy(Comparator<? super T>
A comparator
comparator)

Implements io.vavr.collection.LinearSeq.distinctBy.

Returns a new version of this which contains no duplicates.

public default <U> List<T>
distinctBy(Function<? super T, ? extends U>
A key extractor
keyExtractor)

Implements io.vavr.collection.LinearSeq.distinctBy.

Returns a new version of this which contains no duplicates.

public default List<T>
drop(int
The number of elements to drop.
n)

Implements io.vavr.collection.LinearSeq.drop.

Drops the first n elements of this or all elements, if this length < n.

public default List<T>
dropRight(int
The number of elements to drop.
n)

Implements io.vavr.collection.LinearSeq.dropRight.

Drops the last n elements of this or all elements, if this length < n.

public default List<T>
dropRightUntil(Predicate<? super T>
A condition tested subsequently for this elements, starting from the end.
predicate)

Implements io.vavr.collection.LinearSeq.dropRightUntil.

Drops elements until the predicate holds for the current element, starting from the end.

public default List<T>
dropRightWhile(Predicate<? super T>
A condition tested subsequently for this elements, starting from the end.
predicate)

Implements io.vavr.collection.LinearSeq.dropRightWhile.

Drops elements while the predicate holds for the current element, starting from the end.

public default List<T>
dropUntil(Predicate<? super T>
A condition tested subsequently for this elements.
predicate)

Implements io.vavr.collection.LinearSeq.dropUntil.

Drops elements until the predicate holds for the current element.

public default List<T>
dropWhile(Predicate<? super T>
A condition tested subsequently for this elements.
predicate)

Implements io.vavr.collection.LinearSeq.dropWhile.

Drops elements while the predicate holds for the current element.

public static <
Component type of Nil, determined by type inference in the particular context.
T> List<T>

Returns:

The empty list.
empty()

Returns the single instance of Nil.

public static <
Component type of the List
T> List<T>

Returns:

A List of size n, where each element contains the result supplied by s.
fill(int
The number of elements in the List
n, Supplier<? extends T>
The Supplier computing element values
s)

Returns a List containing n values supplied by a given Supplier s.

public static <
Component type of the List
T> List<T>

Returns:

A List of size n, where each element is the given element.
fill(int
The number of elements in the List
n, T
The element
element)

Returns a List containing n times the given element

public default List<T>
filter(Predicate<? super T>
A predicate
predicate)

Implements io.vavr.collection.LinearSeq.filter.

Returns a new traversable consisting of all elements which satisfy the given predicate.

public default <U> List<U>
flatMap(Function<? super T, ? extends Iterable<? extends U>>
A mapper
mapper)

Implements io.vavr.collection.LinearSeq.flatMap.

FlatMaps this Traversable.

public default T
get(int
an index
index)

Implements io.vavr.collection.Seq.get.

Returns the element at the specified index.

public default <C> Map<C, List<T>>
groupBy(Function<? super T, ? extends C>
A function which classifies elements into classes
classifier)

Implements io.vavr.collection.LinearSeq.groupBy.

Groups this elements by classifying the elements.

public default Iterator<List<T>>
grouped(int
a positive block size
size)

Implements io.vavr.collection.LinearSeq.grouped.

Groups this Traversable into fixed size blocks.

public default boolean
hasDefiniteSize()

Implements io.vavr.collection.Traversable.hasDefiniteSize.

Checks if this Traversable is known to have a finite size.

public default int
indexOf(T
an element
element, int
start index
from)

Implements io.vavr.collection.Seq.indexOf.

Returns the index of the first occurrence of the given element after or at some start index or -1 if this does not contain the given element.

public default List<T>
init()

Implements io.vavr.collection.LinearSeq.init.

Dual of tail(), returning all elements except the last.

public default Option<List<T>>
initOption()

Implements io.vavr.collection.LinearSeq.initOption.

Dual of tailOption(), returning all elements except the last as Option.

public default List<T>
insert(int
an index
index, T
an element
element)

Implements io.vavr.collection.LinearSeq.insert.

Inserts the given element at the specified index.

public default List<T>
insertAll(int
an index
index, Iterable<? extends T>
An Iterable of elements
elements)

Implements io.vavr.collection.LinearSeq.insertAll.

Inserts the given elements at the specified index.

public default List<T>
intersperse(T
An element.
element)

Implements io.vavr.collection.LinearSeq.intersperse.

Inserts an element between all elements of this Traversable.

public default boolean

Returns:

false
isAsync()

Implements io.vavr.Value.isAsync.

A List is computed synchronously.

public boolean
isEmpty()

Redeclares as abstract: io.vavr.collection.Traversable.isEmpty.

Checks if this Traversable is empty.

public default boolean

Returns:

false
isLazy()

Implements io.vavr.Value.isLazy.

A List is computed eagerly.

public default boolean
isTraversableAgain()

Implements io.vavr.collection.Traversable.isTraversableAgain.

Checks if this Traversable can be repeatedly traversed.

public default T
last()

Implements io.vavr.collection.Traversable.last.

Dual of head(), returning the last element.

public default int
lastIndexOf(T
an element
element, int
the end index
end)

Implements io.vavr.collection.Seq.lastIndexOf.

Returns the index of the last occurrence of the given element before or at a given end index or -1 if this does not contain the given element.

public default List<T>
leftPadTo(int
the target length
length, T
the padding element
element)

Implements io.vavr.collection.Seq.leftPadTo.

A copy of this sequence with an element prepended until a given target length is reached.

public int
length()

Redeclares io.vavr.collection.Traversable.length.

Computes the number of elements of this Traversable.

public default <U> List<U>
map(Function<? super T, ? extends U>
A mapper.
mapper)

Implements io.vavr.collection.LinearSeq.map.

Maps the elements of this Traversable to elements of a new type preserving their order, if any.

public static <
Component type of the List.
T> List<T>

Returns:

the given list instance as narrowed type List<T>.
narrow(List<? extends T>
A List.
list)

Narrows a widened List<?

public static <
The component type
T> List<T>

Returns:

A new List instance containing the given element
of(T
An element.
element)

Returns a singleton List, i.e. a List of one element.

public static <
Component type of the List.
T> List<T>

Returns:

A list containing the given elements in the same order.
of(T...
Zero or more elements.
elements)

Creates a List of the given elements.

public static <
Component type of the List.
T> List<T>

Returns:

A list containing the given elements in the same order.
ofAll(Iterable<? extends T>
An Iterable of elements.
elements)

Creates a List of the given elements.

public static <
Component type of the Stream.
T> List<T>

Returns:

A List containing the given elements in the same order.
ofAll(Stream<? extends T>
A java.util.stream.Stream
javaStream)

Creates a List that contains the elements of the given java.util.stream.Stream.

public static List<Boolean>

Returns:

A new List of Boolean values
ofAll(boolean...
boolean values
elements)

Creates a List from boolean values.

public static List<Byte>

Returns:

A new List of Byte values
ofAll(byte...
byte values
elements)

Creates a List from byte values.

public static List<Character>

Returns:

A new List of Character values
ofAll(char...
char values
elements)

Creates a List from char values.

public static List<Double>

Returns:

A new List of Double values
ofAll(double...
double values
elements)

Creates a List from double values.

public static List<Float>

Returns:

A new List of Float values
ofAll(float...
a float values
elements)

Creates a List from float values.

public static List<Integer>

Returns:

A new List of Integer values
ofAll(int...
int values
elements)

Creates a List from int values.

public static List<Long>

Returns:

A new List of Long values
ofAll(long...
long values
elements)

Creates a List from long values.

public static List<Short>

Returns:

A new List of Short values
ofAll(short...
short values
elements)

Creates a List from short values.

public default List<T>
orElse(Iterable<? extends T>
An alternative Traversable
other)

Implements io.vavr.collection.LinearSeq.orElse.

Returns this Traversable if it is nonempty, otherwise return the alternative.

public default List<T>
orElse(Supplier<? extends Iterable<? extends T>>
An alternative Traversable supplier
supplier)

Implements io.vavr.collection.LinearSeq.orElse.

Returns this Traversable if it is nonempty, otherwise return the result of evaluating supplier.

public default List<T>
padTo(int
the target length
length, T
the padding element
element)

Implements io.vavr.collection.LinearSeq.padTo.

A copy of this sequence with an element appended until a given target length is reached.

public default Tuple2<List<T>, List<T>>
partition(Predicate<? super T>
A predicate which classifies an element if it is in the first or the second traversable.
predicate)

Implements io.vavr.collection.LinearSeq.partition.

Creates a partition of this Traversable by splitting this elements in two in distinct traversables according to a predicate.

public default List<T>
patch(int
the index of the first replaced element
from, Iterable<? extends T>
sequence for replacement
that, int
the number of elements to drop in the original list
replaced)

Implements io.vavr.collection.LinearSeq.patch.

Produces a new list where a slice of elements in this list is replaced by another sequence.

public default T

Returns:

the first element
peek()

Returns the head element without modifying the List.

public default List<T>

Returns:

this List
peek(Consumer<? super T>
A Consumer
action)

Implements io.vavr.collection.LinearSeq.peek.

Performs an action on the head element of this List.

public default Option<T>

Returns:

None if this List is empty, otherwise a Some containing the head element
peekOption()

Returns the head element without modifying the List.

public default List<List<T>>
permutations()

Implements io.vavr.collection.LinearSeq.permutations.

Computes all unique permutations.

public default List<T>

Returns:

the elements of this List without the head element
pop()

Removes the head element from this List.

public default Tuple2<T, List<T>>

Returns:

a tuple containing the head element and the remaining elements of this List
pop2()

Removes the head element from this List.

public default Option<Tuple2<T, List<T>>>

Returns:

None if this List is empty, otherwise Some Tuple containing the head element and the remaining elements of this List
pop2Option()

Removes the head element from this List.

public default Option<List<T>>

Returns:

None if this List is empty, otherwise a Some containing the elements of this List without the head element
popOption()

Removes the head element from this List.

public default List<T>
prepend(T
An element
element)

Implements io.vavr.collection.LinearSeq.prepend.

Prepends an element to this.

public default List<T>
prependAll(Iterable<? extends T>
An Iterable of elements
elements)

Implements io.vavr.collection.LinearSeq.prependAll.

Prepends all given elements to this.

public default List<T>

Returns:

a new List instance, containing the new element on top of this List
push(T
The new element
element)

Pushes a new element on top of this List.

public default List<T>

Returns:

a new List instance, containing the new elements on top of this List
push(T...
Elements, may be empty
elements)

Pushes the given elements on top of this List.

public default List<T>

Returns:

a new List instance, containing the new elements on top of this List
pushAll(Iterable<T>
An Iterable of elements, may be empty
elements)

Pushes the given elements on top of this List.

public static List<Character>
range(char from, char toExclusive)

public static List<Integer>

Returns:

a range of int values as specified or the empty range if from >= toExclusive
range(int
the first number
from, int
the last number + 1
toExclusive)

Creates a List of int numbers starting from from, extending to toExclusive - 1.

public static List<Long>

Returns:

a range of long values as specified or the empty range if from >= toExclusive
range(long
the first number
from, long
the last number + 1
toExclusive)

Creates a List of long numbers starting from from, extending to toExclusive - 1.

public static List<Character>
rangeBy(char from, char toExclusive, int step)

public static List<Double>
rangeBy(double from, double toExclusive, double step)

public static List<Integer>

Returns:

a range of long values as specified or the empty range if
from >= toInclusive and step > 0 or
from <= toInclusive and step < 0
rangeBy(int
the first number
from, int
the last number + 1
toExclusive, int
the step
step)

Creates a List of int numbers starting from from, extending to toExclusive - 1, with step.

public static List<Long>

Returns:

a range of long values as specified or the empty range if
from >= toInclusive and step > 0 or
from <= toInclusive and step < 0
rangeBy(long
the first number
from, long
the last number + 1
toExclusive, long
the step
step)

Creates a List of long numbers starting from from, extending to toExclusive - 1, with step.

public static List<Character>
rangeClosed(char from, char toInclusive)

public static List<Integer>

Returns:

a range of int values as specified or the empty range if from > toInclusive
rangeClosed(int
the first number
from, int
the last number
toInclusive)

Creates a List of int numbers starting from from, extending to toInclusive.

public static List<Long>

Returns:

a range of long values as specified or the empty range if from > toInclusive
rangeClosed(long
the first number
from, long
the last number
toInclusive)

Creates a List of long numbers starting from from, extending to toInclusive.

public static List<Character>
rangeClosedBy(char from, char toInclusive, int step)

public static List<Double>
rangeClosedBy(double from, double toInclusive, double step)

public static List<Integer>

Returns:

a range of int values as specified or the empty range if
from > toInclusive and step > 0 or
from < toInclusive and step < 0
rangeClosedBy(int
the first number
from, int
the last number
toInclusive, int
the step
step)

Creates a List of int numbers starting from from, extending to toInclusive, with step.

public static List<Long>

Returns:

a range of int values as specified or the empty range if
from > toInclusive and step > 0 or
from < toInclusive and step < 0
rangeClosedBy(long
the first number
from, long
the last number
toInclusive, long
the step
step)

Creates a List of long numbers starting from from, extending to toInclusive, with step.

public default List<T>
reject(Predicate<? super T>
A predicate
predicate)

Implements io.vavr.collection.LinearSeq.reject.

Returns a new traversable consisting of all elements which do not satisfy the given predicate.

public default List<T>
remove(T
An element to be removed from this Seq.
element)

Implements io.vavr.collection.LinearSeq.remove.

Removes the first occurrence of the given element.

public default List<T>
removeAll(T
An element to be removed from this Seq.
element)

Implements io.vavr.collection.LinearSeq.removeAll.

Removes all occurrences of the given element.

public default List<T>
removeAll(Iterable<? extends T>
Elements to be removed from this Seq.
elements)

Implements io.vavr.collection.LinearSeq.removeAll, io.vavr.collection.LinearSeq.removeAll.

Removes all occurrences of the given elements.

public default List<T>
removeAll(Predicate<? super T>
the predicate used to test elements
predicate)

Implements io.vavr.collection.LinearSeq.removeAll, io.vavr.collection.LinearSeq.removeAll.

Deprecated

Returns a new Seq consisting of all elements which do not satisfy the given predicate.

public default List<T>
removeAt(int
position of element to remove
index)

Implements io.vavr.collection.LinearSeq.removeAt.

Removes the element at the specified position in this sequence.

public default List<T>
removeFirst(Predicate<T>
an predicate
predicate)

Implements io.vavr.collection.LinearSeq.removeFirst.

Removes the first occurrence that satisfy predicate

public default List<T>
removeLast(Predicate<T>
an predicate
predicate)

Implements io.vavr.collection.LinearSeq.removeLast.

Removes the last occurrence that satisfy predicate

public default List<T>
replace(T
An element to be substituted.
currentElement, T
A replacement for currentElement.
newElement)

Implements io.vavr.collection.LinearSeq.replace.

Replaces the first occurrence (if exists) of the given currentElement with newElement.

public default List<T>
replaceAll(T
An element to be substituted.
currentElement, T
A replacement for currentElement.
newElement)

Implements io.vavr.collection.LinearSeq.replaceAll.

Replaces all occurrences of the given currentElement with newElement.

public default List<T>
retainAll(Iterable<? extends T>
Elements to be kept.
elements)

Implements io.vavr.collection.LinearSeq.retainAll.

Keeps all occurrences of the given elements from this.

public default List<T>
reverse()

Implements io.vavr.collection.LinearSeq.reverse.

Reverses the order of elements.

public default List<T>
rotateLeft(int
distance of left rotation
n)

Implements io.vavr.collection.LinearSeq.rotateLeft.

Circular rotates the elements by the specified distance to the left direction.

public default List<T>
rotateRight(int
distance of right rotation
n)

Implements io.vavr.collection.LinearSeq.rotateRight.

Circular rotates the elements by the specified distance to the right direction.

public default List<T>
scan(T
neutral element for the operator op
zero, BiFunction<? super T, ? super T, ? extends T>
the associative operator for the scan
operation)

Implements io.vavr.collection.LinearSeq.scan.

Computes a prefix scan of the elements of the collection.

public default <U> List<U>
scanLeft(U
the initial value
zero, BiFunction<? super U, ? super T, ? extends U>
the binary operator applied to the intermediate result and the element
operation)

Implements io.vavr.collection.LinearSeq.scanLeft.

Produces a collection containing cumulative results of applying the operator going left to right.

public default <U> List<U>
scanRight(U
the initial value
zero, BiFunction<? super T, ? super U, ? extends U>
the binary operator applied to the intermediate result and the element
operation)

Implements io.vavr.collection.LinearSeq.scanRight.

Produces a collection containing cumulative results of applying the operator going right to left.

public default List<T>
shuffle()

Implements io.vavr.collection.LinearSeq.shuffle.

Randomize the order of the elements in the current sequence.

public default List<T>
slice(int
the beginning index, inclusive
beginIndex, int
the end index, exclusive
endIndex)

Implements io.vavr.collection.LinearSeq.slice.

Returns a Seq that is a slice of this.

public default Iterator<List<T>>
slideBy(Function<? super T, ?>
A function which classifies elements into classes
classifier)

Implements io.vavr.collection.LinearSeq.slideBy.

Slides a non-overlapping window of a variable size over this Traversable.

public default Iterator<List<T>>
sliding(int
a positive window size
size)

Implements io.vavr.collection.LinearSeq.sliding.

Slides a window of a specific size and step size 1 over this Traversable by calling sliding(int, int).

public default Iterator<List<T>>
sliding(int
a positive window size
size, int
a positive step size
step)

Implements io.vavr.collection.LinearSeq.sliding.

Slides a window of a specific size and step size over this Traversable.

public default <U extends Comparable<? super U>> List<T>
sortBy(Function<? super T, ? extends U>
A mapper
mapper)

Implements io.vavr.collection.LinearSeq.sortBy.

Sorts this elements by comparing the elements in a different domain, using the given mapper.

public default <U> List<T>
sortBy(Comparator<? super U>
A comparator
comparator, Function<? super T, ? extends U>
A mapper
mapper)

Implements io.vavr.collection.LinearSeq.sortBy.

Sorts this elements by comparing the elements in a different domain, using the given mapper.

public default List<T>
sorted()

Implements io.vavr.collection.LinearSeq.sorted.

Sorts this elements according to their natural order.

public default List<T>
sorted(Comparator<? super T>
A comparator
comparator)

Implements io.vavr.collection.LinearSeq.sorted.

Sorts this elements according to the provided Comparator.

public default Tuple2<List<T>, List<T>>
span(Predicate<? super T>
A predicate.
predicate)

Implements io.vavr.collection.LinearSeq.span.

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.

public default Tuple2<List<T>, List<T>>
splitAt(int
An index.
n)

Implements io.vavr.collection.Seq.splitAt.

Splits a Seq at the specified index.

public default Tuple2<List<T>, List<T>>
splitAt(Predicate<? super T>
An predicate
predicate)

Implements io.vavr.collection.Seq.splitAt.

Splits a sequence at the first element which satisfies the Predicate, e.g. Tuple(init, element+tail).

public default Tuple2<List<T>, List<T>>
splitAtInclusive(Predicate<? super T>
An predicate
predicate)

Implements io.vavr.collection.Seq.splitAtInclusive.

Splits a sequence at the first element which satisfies the Predicate, e.g. Tuple(init+element, tail).

public default String
stringPrefix()

Implements io.vavr.Value.stringPrefix.

Returns the name of this Value type, which is used by toString().

public default List<T>
subSequence(int
the beginning index, inclusive
beginIndex)

Implements io.vavr.collection.LinearSeq.subSequence.

Returns a Seq that is a subsequence of this.

public default List<T>
subSequence(int
the beginning index, inclusive
beginIndex, int
the end index, exclusive
endIndex)

Implements io.vavr.collection.LinearSeq.subSequence.

Returns a Seq that is a subsequence of this.

public static <
Component type of the List
T> List<T>

Returns:

A List consisting of elements f(0),f(1), ..., f(n - 1)
tabulate(int
The number of elements in the List
n, Function<? super Integer, ? extends T>
The Function computing element values
f)

Returns a List containing n values of a given Function f over a range of integer values from 0 to n - 1.

public List<T>
tail()

Redeclares io.vavr.collection.LinearSeq.tail.

Drops the first element of a non-empty Traversable.

public default Option<List<T>>
tailOption()

Implements io.vavr.collection.LinearSeq.tailOption.

Drops the first element of a non-empty Traversable and returns an Option.

public default List<T>
take(int
The number of elements to take.
n)

Implements io.vavr.collection.LinearSeq.take.

Takes the first n elements of this or all elements, if this length < n.

public default List<T>
takeRight(int
The number of elements to take.
n)

Implements io.vavr.collection.LinearSeq.takeRight.

Takes the last n elements of this or all elements, if this length < n.

public default List<T>
takeRightUntil(Predicate<? super T>
A condition tested subsequently for this elements, starting from the end.
predicate)

Implements io.vavr.collection.LinearSeq.takeRightUntil.

Takes elements until the predicate holds for the current element, starting from the end.

public default List<T>
takeRightWhile(Predicate<? super T>
A condition tested subsequently for this elements, starting from the end.
predicate)

Implements io.vavr.collection.LinearSeq.takeRightWhile.

Takes elements while the predicate holds for the current element, starting from the end.

public default List<T>
takeUntil(Predicate<? super T>
A condition tested subsequently for this elements.
predicate)

Implements io.vavr.collection.LinearSeq.takeUntil.

Takes elements until the predicate holds for the current element.

public default List<T>
takeWhile(Predicate<? super T>
A condition tested subsequently for the contained elements.
predicate)

Implements io.vavr.collection.LinearSeq.takeWhile.

Takes elements while the predicate holds for the current element.

public default <
Type of transformation result
U> U

Returns:

An instance of type U
transform(Function<? super List<T>, ? extends U>
A transformation
f)

Transforms this List.

public static <
matrix element type
T> List<List<T>>

Returns:

a transposed List matrix.
transpose(List<List<T>>
to be transposed.
matrix)

Transposes the rows and columns of a List matrix.

public static <
type of seeds and unfolded values
T> List<T>

Returns:

a list with the values built up by the iteration
unfold(T
the start value for the iteration
seed, Function<? super T, Option<Tuple2<? extends T, ? extends T>>>
the function to get the next step of the iteration
f)

Creates a list from a seed value and a function.

public static <
type of seeds
T,
type of unfolded values
U> List<U>

Returns:

a list with the values built up by the iteration
unfoldLeft(T
the start value for the iteration
seed, Function<? super T, Option<Tuple2<? extends T, ? extends U>>>
the function to get the next step of the iteration
f)

Creates a list from a seed value and a function.

public static <
type of seeds
T,
type of unfolded values
U> List<U>

Returns:

a list with the values built up by the iteration
unfoldRight(T
the start value for the iteration
seed, Function<? super T, Option<Tuple2<? extends U, ? extends T>>>
the function to get the next step of the iteration
f)

Creates a list from a seed value and a function.

public default <T1, T2> Tuple2<List<T1>, List<T2>>
unzip(Function<? super T, Tuple2<? extends T1, ? extends T2>>
a function which converts elements of this to pairs
unzipper)

Implements io.vavr.collection.LinearSeq.unzip.

Unzips this elements by mapping this elements to pairs which are subsequently split into two distinct sets.

public default <T1, T2, T3> Tuple3<List<T1>, List<T2>, List<T3>>
unzip3(Function<? super T, Tuple3<? extends T1, ? extends T2, ? extends T3>>
a function which converts elements of this to pairs
unzipper)

Implements io.vavr.collection.Seq.unzip3.

Unzips this elements by mapping this elements to triples which are subsequently split into three distinct sets.

public default List<T>
update(int
an index
index, T
an element
element)

Implements io.vavr.collection.LinearSeq.update.

Updates the given element at the specified index.

public default List<T>
update(int
an index
index, Function<? super T, ? extends T>
a function transforming the previous value
updater)

Implements io.vavr.collection.LinearSeq.update, io.vavr.collection.LinearSeq.update.

Updates the given element at the specified index using the specified function.

public default <U> List<Tuple2<T, U>>
zip(Iterable<? extends U>
The Iterable providing the second half of each result pair.
that)

Implements io.vavr.collection.LinearSeq.zip.

Returns a traversable formed from this traversable and another Iterable collection by combining corresponding elements in pairs.

public default <U> List<Tuple2<T, U>>
zipAll(Iterable<? extends U>
The Iterable providing the second half of each result pair.
that, T
The element to be used to fill up the result if this traversable is shorter than that.
thisElem, U
The element to be used to fill up the result if that is shorter than this traversable.
thatElem)

Implements io.vavr.collection.LinearSeq.zipAll.

Returns a traversable formed from this traversable and another Iterable by combining corresponding elements in pairs.

public default <U, R> List<R>
zipWith(Iterable<? extends U>
The Iterable providing the second parameter of the mapper.
that, BiFunction<? super T, ? super U, ? extends R>
a mapper.
mapper)

Implements io.vavr.collection.LinearSeq.zipWith.

Returns a traversable formed from this traversable and another Iterable collection by mapping elements.

public default List<Tuple2<T, Integer>>
zipWithIndex()

Implements io.vavr.collection.LinearSeq.zipWithIndex.

Zips this traversable with its indices.

public default <U> List<U>
zipWithIndex(BiFunction<? super T, ? super Integer, ? extends U>
a mapper.
mapper)

Implements io.vavr.collection.LinearSeq.zipWithIndex.

Zips this traversable with its indices by applying mapper provided.

Inherited from io.vavr.collection.LinearSeq:
asPartialFunctionindexOfSliceindexWhereisDefinedAtlastIndexOfSlicelastIndexWherenarrowreverseIteratorsearchsearchsegmentLength