Scala Library Documentation


scala/List.scala
]
sealed abstract
class
List[+A]
extends
Seq[A]a
. This class comes with two implementing case
classes scala.Nil
and scala.::
that
implement the abstract members isEmpty
,
head
and tail
.Method Summary  
def

:: [B >: A](x : B) : List[B] 
def

::: [B >: A](prefix : List[B]) : List[B] 
def

apply
(n : Int) : A
Returns the
n th element of this list. The first element
(head of the list) is at position 0. 
def

break
(p : (A) => Boolean) : (List[A], List[A])
Like
span but with the predicate inverted. 
def

count
(p : (A) => Boolean) : Int
Count the number of elements in the list which satisfy a predicate.

def

diff
[B >: A](that : List[B]) : List[B]
Computes the difference between this list and the given list
that . 
override def

drop
(n : Int) : List[A]
Returns the list without its
n first elements.
If this list has less than n elements, the empty list is returned. 
def

dropRight
(n : Int) : List[A]
Returns the list wihout its rightmost
n elements. 
override def

dropWhile
(p : (A) => Boolean) : List[A]
Returns the longest suffix of this list whose first element
does not satisfy the predicate
p . 
override def

elements
: Iterator[A]
Returns the elements in the list as an iterator

override def

exists
(p : (A) => Boolean) : Boolean
Tests the existence in this list of an element that satisfies the
predicate
p . 
override final def

filter
(p : (A) => Boolean) : List[A]
Returns all the elements of this list that satisfy the
predicate
p . The order of the elements is preserved.
It is guarenteed that the receiver list itself is returned iff all its
elements satisfy the predicate `p'. Hence the following equality is valid:
(xs filter p) eq xs == xs forall p 
override def

find
(p : (A) => Boolean) : Option[A]
Find and return the first element of the list satisfying a
predicate, if any.

override final def

flatMap
[B](f : (A) => Iterable[B]) : List[B]
Applies the given function
f to each element of
this list, then concatenates the results. 
def

flatten
[B](implicit f : (A) => Iterable[B]) : List[B]

override def

foldLeft
[B](z : B)(f : (B, A) => B) : B
Combines the elements of this list together using the binary
function
f , from left to right, and starting with
the value z . 
override def

foldRight
[B](z : B)(f : (A, B) => B) : B
Combines the elements of this list together using the binary
function
f , from right to left, and starting with
the value z . 
override def

forall
(p : (A) => Boolean) : Boolean
Tests if the predicate
p is satisfied by all elements
in this list. 
override final def

foreach
(f : (A) => Unit) : Unit
Apply the given function
f to each element of this list
(while respecting the order of the elements). 
abstract def

head
: A
Returns this first element of the list.

def

indices
: List[Int]
Creates a list with all indices in the list. This is
equivalent to a call to
List.range(0, xs.length) . 
def

init
: List[A]
Returns the list without its last element.

def

intersect
[B >: A](that : List[B]) : List[B]
Computes the intersection between this list and the given list
that . 
override abstract def

isEmpty
: Boolean
Returns true if the list does not contain any elements.

override def

last
: A
Returns the last element of this list.

def

length
: Int
Returns the number of elements in the list.

override def

lengthCompare
(l : Int) : Int
returns length  l, without calling length

override final def

map
[B](f : (A) => B) : List[B]
Returns the list resulting from applying the given function
f to each
element of this list. 
override def

partition
(p : (A) => Boolean) : (List[A], List[A])
Partition the list in two sublists according to a predicate.

override def

projection
: Stream[A]
returns a projection that can be used to call nonstrict
filter ,
map , and flatMap methods that build projections
of the collection. 
override def

reduceLeft
[B >: A](f : (B, B) => B) : B
Combines the elements of this list together using the binary
operator
op , from left to right 
override def

reduceRight
[B >: A](f : (B, B) => B) : B
Combines the elements of this list together using the binary
operator
op , from right to left 
def

remove
(p : (A) => Boolean) : List[A]
Removes all elements of the list which satisfy the predicate
p . This is like filter with the
predicate inversed. 
def

removeDuplicates
: List[A]
Removes redundant elements from the list. Uses the method
==
to decide if two elements are identical. 
override def

reverse
: List[A]
A list consisting of all elements of this list in reverse order.

def

reverseMap
[B](f : (A) => B) : List[B]
Apply a function to all the elements of the list, and return the
reversed list of results. This is equivalent to a call to
map
followed by a call to reverse , but more efficient. 
def

reverse_:::
[B >: A](prefix : List[B]) : List[B]
Reverse the given prefix and append the current list to that.
This function is equivalent to an application of
reverse
on the prefix followed by a call to ::: , but more
efficient (and tail recursive). 
override def

slice
(start : Int, end : Int) : List[A]
Returns the list with elements belonging to the given index range.

def

sort (lt : (A, A) => Boolean) : List[A] 
def

span
(p : (A) => Boolean) : (List[A], List[A])
Returns the longest prefix of the list whose elements all satisfy
the given predicate, and the rest of the list.

def

splitAt
(n : Int) : (List[A], List[A])
Split the list at a given point and return the two parts thus
created.

protected override def

stringPrefix
: java.lang.String
Defines the prefix of this object's
toString representation. 
abstract def

tail
: List[A]
Returns this list without its first element.

override def

take
(n : Int) : List[A]
Returns the
n first elements of this list, or else the whole
list, if it has less than n elements. 
def

takeRight
(n : Int) : List[A]
Returns the rightmost
n elements from this list. 
override def

takeWhile
(p : (A) => Boolean) : List[A]
Returns the longest prefix of this list whose elements satisfy
the predicate
p . 
override def

toList
: List[A]
Overrides the method in Iterable for efficiency.

override def

toStream
: Stream[A]
Create a stream which contains all the elements of this iterable object.

def

union
[B >: A](that : List[B]) : List[B]
Computes the union of this list and the given list
that . 
def

zip
[B](that : List[B]) : List[(A, B)]
Returns a list formed from this list and the specified list
that by associating each element of the former with
the element at the same position in the latter.
If one of the two lists is longer than the other, its remaining elements are ignored. 
def

zipAll
[B, C >: A, D >: B](that : List[B], thisElem : C, thatElem : D) : List[(C, D)]
Returns a list formed from this list and the specified list
that by associating each element of the former with
the element at the same position in the latter. 
def

zipWithIndex
: List[(A, Int)]
Returns a list that pairs each element of this list
with its index, counting from 0.

Methods inherited from Seq  
size, concat, lastOption, headOption, ++, isDefinedAt, lastIndexOf, contains, subseq, toArray, equalsWith, startsWith, endsWith, indexOf, containsSlice 
Methods inherited from Collection  
toString 
Methods inherited from Iterable  
findIndexOf, indexOf, /:, :\, copyToBuffer, sameElements, mkString, mkString, mkString, addString, addString, copyToArray, hasDefiniteSize 
Methods inherited from PartialFunction  
orElse, andThen 
Methods inherited from Function1  
compose 
Methods inherited from AnyRef  
getClass, hashCode, equals, clone, notify, notifyAll, wait, wait, wait, finalize, ==, !=, eq, ne, synchronized 
Methods inherited from Any  
==, !=, isInstanceOf, asInstanceOf 
Method Details 
override abstract
def
isEmpty : Boolean
true
, iff the list is empty.abstract
def
head : A
Add an element x
at the beginning of this list.
x 
the element to append.x
appended at the beginning.1 :: List(2, 3) = List(2, 3).::(1) = List(1, 2, 3)
Returns a list resulting from the concatenation of the given
list prefix
and this list.
prefix 
the list to concatenate at the beginning of this list.List(1, 2) ::: List(3, 4) = List(3, 4).:::(List(1, 2)) = List(1, 2, 3, 4)
reverse
on the prefix followed by a call to :::
, but more
efficient (and tail recursive).prefix 
the prefix to reverse and then prepend
def
length : Int
List.range(0, xs.length)
.override
def
last : A
n
first elements of this list, or else the whole
list, if it has less than n
elements.n 
the number of elements to take.n
first elements of this list.start 
the start position of the list slice.end 
the end position (exclusive) of the list slice.n
first elements.
If this list has less than n
elements, the empty list is returned.n 
the number of elements to drop.n
first elements.n
elements from this list.n 
the number of elements to taken
of the listn
elements.n 
the number of elements to taken
of the listn 
the position at which to splitn
elements, and the other elements.p
.p 
the test predicate.p
.p
.p 
the test predicate.p
.p 
the test predicatep
, and the rest of the list.span
but with the predicate inverted.n
th element of this list. The first element
(head of the list) is at position 0.n 
index of the element to returnn
in this list.f
to each
element of this list.f 
function to apply to each element.[f(a0), ..., f(an)]
if this list is [a0, ..., an]
.map
followed by a call to reverse
, but more efficient.f 
the function to apply to each elements.f
to each element of this list
(while respecting the order of the elements).f 
the treatment to apply to each element.p
. The order of the elements is preserved.
It is guarenteed that the receiver list itself is returned iff all its
elements satisfy the predicate `p'. Hence the following equality is valid:
(xs filter p) eq xs == xs forall pp 
the predicate used to filter the list.p
.p
. This is like filter
with the
predicate inversed.p 
the predicate to use to test elementsp
p 
the predicate on which to partitionp
and the list of all elements which do not.
The relative order of the elements in the sublists is the
same as in the original list.
Sort the list according to the comparison function
<(e1: a, e2: a) => Boolean
,
which should be true iff e1
is smaller than
e2
.
lt 
the comparison function<(e1: a, e2: a) => Boolean
.List("Steve", "Tom", "John", "Bob") .sort((e1, e2) => (e1 compareTo e2) < 0) = List("Bob", "John", "Steve", "Tom")
p 
the predicate for which to countp
.p
is satisfied by all elements
in this list.p 
the test predicate.true
iff all elements of this list satisfy the predicate p
.p
.p 
the test predicate.true
iff there exists an element in this list that satisfies the predicate p
.p 
the predicatep
, or None
if none exists.f
, from left to right, and starting with
the value z
.f(... (f(f(z, a_{0}), a_{1}) ...), a_{n})
if the list is
[a_{0}, a_{1}, ..., a_{n}]
.f
, from right to left, and starting with
the value z
.f(a_{0}, f(a_{1}, f(..., f(a_{n}, z)...)))
if the list is [a_{0}, a1, ..., a_{n}]
.op
, from left to rightop 
The operator to applyop(... op(a_{0},a_{1}), ..., a_{n})
if the list has elements
a_{0}, a_{1}, ..., a_{n}
.op
, from right to leftop 
The operator to applya_{0} op (... op (a_{n1} op a_{n})...)
if the list has elements a_{0}, a_{1}, ...,
a_{n}
.f
to each element of
this list, then concatenates the results.f 
the function to apply on each element.f(a_{0}) ::: ... ::: f(a_{n})
if this list is [a_{0}, ..., a_{n}]
.that
by associating each element of the former with
the element at the same position in the latter.
If one of the two lists is longer than the other, its remaining elements are ignored.List((a_{0},b_{0}), ..., (a_{min(m,n)},b_{min(m,n)}))
when
List(a_{0}, ..., a_{m})
zip List(b_{0}, ..., b_{n})
is invoked.List((a_{0},0), (a_{1},1), ...)
where a_{i}
are the elements of this list.that
by associating each element of the former with
the element at the same position in the latter.that 
list that
may have a different length as the self list.thisElem 
element thisElem
is used to fill up the resulting list if the self list is shorter than
that
thatElem 
element thatElem
is used to fill up the resulting list if that
is shorter than
the self listList((a_{0},b_{0}), ..., (a_{n},b_{n}), (elem,b_{n+1}),
..., {elem,b_{m}})
when [a_{0}, ..., a_{n}] zip
[b_{0}, ..., b_{m}]
is
invoked where m > n
.that
.that 
the list of elements to add to the list.that
.that
.that 
the list of elements to remove from this list.that
.that
.that 
the list to intersect.that
.==
to decide if two elements are identical.protected override
def
stringPrefix : java.lang.String
toString
representation.filter
,
map
, and flatMap
methods that build projections
of the collection.projection
for lazy behavior.
Scala Library Documentation

