Scala Library
|
|
scala/List.scala
]
sealed abstract
class
List[+A]
extends
Seq[A] with
Producta
. 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] |
override def
|
++
[B >: A](that : Iterable[B]) : List[B]
Appends two list objects.
|
def
|
-
[B >: A](x : B) : List[B]
Computes the difference between this list and the given object
x . |
def
|
--
[B >: A](that : List[B]) : List[B]
Computes the difference between this list and the given list
that . |
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]
Concatenate the elements of this list. The elements of this list
should be a
Iterables .
Note: The compiler might not be able to infer the type parameter. |
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
Result of comparing
length with operand l .
returns x where
x < 0 iff this.length < l
x == 0 iff this.length == l
x > 0 iff this.length > that .
This method is used by matching streams against right-ignoring (...,_*) patterns.
This method does not call List.length , it works for O(l) ,
not for O(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 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, A) => B) : B
Combines the elements of this list together using the binary
operator
op , from left to right |
override def
|
reduceRight
[B >: A](f : (A, 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]
Returns a stream containing all of the elements in 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 Product | |
productElement (abstract), productArity (abstract), productPrefix |
Methods inherited from Seq | |
size, concat, lastOption, first, firstOption, headOption, isDefinedAt, lastIndexOf, findIndexOf, indexOf, slice, contains, subseq, toArray, toSeq, equalsWith, startsWith, startsWith, endsWith, indexOf, containsSlice |
Methods inherited from Collection | |
toString |
Methods inherited from Iterable | |
/:, :\, copyToBuffer, sameElements, mkString, mkString, mkString, addString, 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
length
with operand l
.
returns x
where
x < 0
iff this.length < l
x == 0
iff this.length == l
x > 0
iff this.length > that
.
This method is used by matching streams against right-ignoring (...,_*) patterns.
This method does not call List.length
, it works for O(l)
,
not for O(length)
.
Add an element x
at the beginning of this list.
x -
the element to prepend.x
added at the beginning.1 :: List(2, 3) = List(2, 3).::(1) = List(1, 2, 3)
def
+[B >: A](x : B) : List[B]
Add an element x
at the end of this list.
l + e
with l ::: List(e)
.x -
the element to append.x
added at the end.
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
elementsn -
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 sub-lists 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, a0), a1) ...), an)
if the list is
[a0, a1, ..., an]
.f
, from right to left, and starting with
the value z
.f(a0, f(a1, f(..., f(an, z)...)))
if the list is [a0, a1, ..., an]
.op
, from left to rightop -
The operator to applyop(... op(a0,a1), ..., an)
if the list has elements
a0, a1, ..., an
.op
, from right to leftop -
The operator to applya0 op (... op (an-1 op an)...)
if the list has elements a0, a1, ...,
an
.f
to each element of
this list, then concatenates the results.f -
the function to apply on each element.f(a0) ::: ... ::: f(an)
if this list is [a0, ..., an]
.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((a0,b0), ..., (amin(m,n),bmin(m,n)))
when
List(a0, ..., am)
zip List(b0, ..., bn)
is invoked.List((a0,0), (a1,1), ...)
where ai
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((a0,b0), ..., (an,bn), (elem,bn+1),
..., {elem,bm})
when [a0, ..., an] zip
[b0, ..., bm]
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
.--
insteadthat
.that -
the list of elements to remove from this list.that
.x
.x -
the object to remove from this list.x
.Iterables
.
Note: The compiler might not be able to infer the type parameter.f -
An implicit conversion to an Iterable
instance.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
|
|