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]
Add an element |
def
|
:::
[B >: A](prefix : List[B]) : List[B]
Returns a list resulting from the concatenation of the given
list |
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 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. |
def
|
partition
(p : (A) => Boolean) : (List[A], List[A])
Partition the list in two sub-lists according to a predicate.
|
override def
|
projection
: Stream[A]
returns a projection that can be used to call non-strict
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
(from : Int, until : Int) : List[A]
A sub-sequence of
len elements
starting at index from (non-strict) |
def
|
sort
(lt : (A, A) => Boolean) : List[A]
Sort the list according to the comparison function
|
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
: 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 |
Scala Library Documentation
|
|