OVERVIEW |  PACKAGE | CONSTR |  FIELDS |  METHODS FRAMES    NO FRAMES INHERITED

scala.List

class List

sealed abstract class List[+ A]

 extends Seq[A]

A class representing an ordered collection of elements of type a. This class comes with two implementing case classes scala.Nil and scala.:: that implement the abstract members isEmpty, head and tail.
author
- Martin Odersky and others
version
- 1.0, 16/07/2003


Companion: List

Source: List.scala(445)

Direct Known Subclasses

::, Nil,

 Constructors

def this

 Fields

elements override def elements
Returns the elements in the list as an iterator [details]
return
- an iterator on the list elements.
 Iterator[A]
first def first
Returns the first element of this list [details]
return
- the first element of the list.
throws
Predef.UnsupportedOperationException - if the list is empty.
 A Seq
firstOption def firstOption
Returns as an option the first element of this list or None if list is empty [details]
return
- the first element as an option.
 Option[A] Seq
hasDefiniteSize def hasDefiniteSize
returns true iff this collection has a bound size [details]
Many APIs in this trait will not work on collections of unbound sizes.
Boolean Iterable
head abstract def head
Returns this first element of the list [details]
return
- the first element of this list.
throws
Predef.NoSuchElementException - if the list is empty.
 A
headOption def headOption Option[A] Seq
indices def indices
Creates a list with all indices in the list [details]
This is equivalent to a call to List.range(0, xs.length).
return
- a list of all indices in the list.
 List[Int]
init def init
Returns the list without its last element [details]
return
- the list without its last element.
throws
Predef.UnsupportedOperationException - if the list is empty.
 List[A]
isEmpty override abstract def isEmpty
Returns true if the list does not contain any elements [details]
return
- true, iff the list is empty.
 Boolean
last override def last
Returns the last element of this list [details]
return
- the last element of the list.
throws
Predef.NoSuchElementException - if the list is empty.
 A
lastOption def lastOption
Returns as an option the last element of this list or None if list is empty [details]
return
- the last element as an option.
 Option[A] Seq
length def length
Returns the number of elements in the list [details]
return
- the number of elements in the list.
 Int
mkString def mkString
Converts a collection into a flat String by each element's toString method [details]
note
- Will not terminate for infinite-sized collections.
 String Iterable
projection override def projection
returns a projection that can be used to call non-strict filter, map, and flatMap methods that build projections of the collection
Stream[A]
removeDuplicates def removeDuplicates
Removes redundant elements from the list [details]
Uses the method == to decide if two elements are identical.
return
- the list without doubles.
 List[A]
reverse override def reverse
A list consisting of all elements of this list in reverse order
List[A]
size def size
should always be length
Int Seq
stringPrefix protected override def stringPrefix
Defines the prefix of this object's toString representation
String
tail abstract def tail
Returns this list without its first element [details]
return
- this list without its first element.
throws
Predef.NoSuchElementException - if the list is empty.
 List[A]
toList override def toList
Overrides the method in Iterable for efficiency [details]
return
- the list itself
 List[A]
toSeq override def toSeq
Overridden for efficiency [details]
return
- the sequence itself
 Seq[A] Seq
toStream override def toStream
Returns a stream containing all of the elements in this iterable object [details]
note
- consider using projection for lazy behavior.
 Stream[A]

 Methods

!= final def !=(arg0 : Any) Boolean Any
!= final def !=(arg0 : Object) Boolean AnyRef
+ def +[B >: A](x : B)

Add an element x at the end of this list.

[details]
param
x - the element to append.
return
- the list with x added at the end.
 List[B]
++ override def ++[B >: A](that : Iterable[B])
Appends two list objects
List[B]
- def -[B >: A](x : B)
Computes the difference between this list and the given object x [details]
param
x - the object to remove from this list.
return
- this list without the elements of the given object x.
List[B]
-- def --[B >: A](that : List[B])
Computes the difference between this list and the given list that [details]
param
that - the list of elements to remove from this list.
return
- this list without the elements of the given list that.
List[B]
/: def /:[B](z : B)(op : (B, A) => B)
Similar to foldLeft but can be used as an operator with the order of list and zero arguments reversed [details]
That is, z /: xs is the same as xs foldLeft z
note
- Will not terminate for infinite-sized collections.
 B Iterable
:: def ::[B >: A](x : B)

Add an element x at the beginning of this list.

[details]
ex
- 1 :: List(2, 3) = List(2, 3).::(1) = List(1, 2, 3)
param
x - the element to prepend.
return
- the list with x added at the beginning.
 List[B]
::: def :::[B >: A](prefix : List[B])

Returns a list resulting from the concatenation of the given list prefix and this list.

[details]
ex
- List(1, 2) ::: List(3, 4) = List(3, 4).:::(List(1, 2)) = List(1, 2, 3, 4)
param
prefix - the list to concatenate at the beginning of this list.
return
- the concatenation of the two lists.
 List[B]
:\ def :\[B](z : B)(op : (A, B) => B)
An alias for foldRight [details]
That is, xs :\ z is the same as xs foldRight z
note
- Will not terminate for infinite-sized collections.
 B Iterable
== final def ==(arg0 : Object) Boolean AnyRef
== final def ==(arg0 : Any) Boolean Any
addString def addString(buf : StringBuilder, start : String, sep : String, end : String)
Write all elements of this string into given string builder [details]
note
- Will not terminate for infinite-sized collections.
param
buf - ...
return
- ...
 StringBuilder Iterable
addString def addString(buf : StringBuilder, sep : String) StringBuilder Iterable
andThen override def andThen[C](k : (B) => C)
(f andThen g)(x) == g(f(x))
PartialFunction[A, C] PartialFunction
apply def apply(n : Int)
Returns the n-th element of this list [details]
The first element (head of the list) is at position 0.
param
n - index of the element to return
return
- the element at position n in this list.
throws
Predef.NoSuchElementException - if the list is too short.
 A
asInstanceOf final def asInstanceOf[T0] T0 Any
break def break(p : (A) => Boolean)
Like span but with the predicate inverted
(List[A], List[A])
clone protected def clone Object AnyRef
compose def compose[A](g : (A) => T1)
(f compose g)(x) == f(g(x))
(A) => R Function1
concat override def concat[B >: A](that : Iterable[B])
Appends two iterable objects [details]
deprecated
- use ++ instead
return
- the new iterable object
 Seq[B] Seq
contains def contains(elem : Any)
Tests if the given value elem is a member of this sequence [details]
param
elem - element whose membership has to be tested.
return
- true iff there is an element of this sequence which is equal (w.r.t. ==) to elem.
Boolean Seq
containsSlice def containsSlice[B](that : Seq[B])
Is that a slice in this?
Boolean Seq
copyToArray def copyToArray[B >: A](xs : Array[B], start : Int)
Fills the given array xs with the elements of this sequence starting at position start [details]
note
- Will not terminate for infinite-sized collections.
param
xs - the array to fill.
start - starting index.
pre
- the array must be large enough to hold all elements.
 Unit Iterable
copyToBuffer def copyToBuffer[B >: A](dest : Buffer[B])
Copy all elements to a given buffer [details]
note
- Will not terminate if not finite.
- Will not terminate for infinite-sized collections.
param
dest - The buffer to which elements are copied
 Unit Iterable
count def count(p : (A) => Boolean)
Count the number of elements in the list which satisfy a predicate [details]
param
p - the predicate for which to count
return
- the number of elements satisfying the predicate p.
 Int
diff def diff[B >: A](that : List[B])
Computes the difference between this list and the given list that [details]
deprecated
- use -- instead
param
that - the list of elements to remove from this list.
return
- this list without the elements of the given list that.
List[B]
drop override def drop(n : Int)
Returns the list without its n first elements [details]
If this list has less than n elements, the empty list is returned.
param
n - the number of elements to drop.
return
- the list without its n first elements.
 List[A]
dropRight def dropRight(n : Int)
Returns the list wihout its rightmost n elements [details]
param
n - the number of elements to take
return
- the suffix of length n of the list
 List[A]
dropWhile override def dropWhile(p : (A) => Boolean)
Returns the longest suffix of this list whose first element does not satisfy the predicate p [details]
param
p - the test predicate.
return
- the longest suffix of the list whose first element does not satisfy the predicate p.
List[A]
endsWith def endsWith[B](that : Seq[B])
[details]
return
- true if this sequence end with that sequence
see
- String.endsWith
 Boolean Seq
eq final def eq(arg0 : Object) Boolean AnyRef
equals def equals(arg0 : Any) Boolean AnyRef
equalsWith def equalsWith[B](that : Seq[B])(f : (A, B) => Boolean) Boolean Seq
exists override def exists(p : (A) => Boolean)
Tests the existence in this list of an element that satisfies the predicate p [details]
param
p - the test predicate.
return
- true iff there exists an element in this list that satisfies the predicate p.
Boolean
filter override final def filter(p : (A) => Boolean)
Returns all the elements of this list that satisfy the predicate p [details]
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
param
p - the predicate used to filter the list.
return
- the elements of this list satisfying p.
 List[A]
finalize protected def finalize Unit AnyRef
find override def find(p : (A) => Boolean)
Find and return the first element of the list satisfying a predicate, if any [details]
param
p - the predicate
return
- the first element in the list satisfying p, or None if none exists.
Option[A]
findIndexOf def findIndexOf(p : (A) => Boolean)
Returns index of the first element satisying a predicate, or -1 [details]
note
- may not terminate for infinite-sized collections.
param
p - the predicate
return
- the index of the first element satisfying p, or -1 if such an element does not exist
Int Iterable
flatMap override final def flatMap[B](f : (A) => Iterable[B])
Applies the given function f to each element of this list, then concatenates the results [details]
param
f - the function to apply on each element.
return
- f(a0) ::: ... ::: f(an) if this list is [a0, ..., an].
List[B]
flatten def flatten[B](implicit f : (A) => Iterable[B]) List[B]
foldLeft override def foldLeft[B](z : B)(f : (B, A) => B)
Combines the elements of this list together using the binary function f, from left to right, and starting with the value z [details]
return
- f(... (f(f(z, a0), a1) ...), an) if the list is [a0, a1, ..., an].
B
foldRight override def foldRight[B](z : B)(f : (A, B) => B)
Combines the elements of this list together using the binary function f, from right to left, and starting with the value z [details]
return
- f(a0, f(a1, f(..., f(an, z)...))) if the list is [a0, a1, ..., an].
B
forall override def forall(p : (A) => Boolean)
Tests if the predicate p is satisfied by all elements in this list [details]
param
p - the test predicate.
return
- true iff all elements of this list satisfy the predicate p.
Boolean
foreach override final def foreach(f : (A) => Unit)
Apply the given function f to each element of this list (while respecting the order of the elements) [details]
param
f - the treatment to apply to each element.
 Unit
getClass final def getClass Class[Any] AnyRef
hashCode def hashCode Int AnyRef
indexOf def indexOf[B >: A](that : Seq[B])
[details]
return
- -1 if that not contained in this, otherwise the index where that is contained
see
- String.indexOf
 Int Seq
indexOf def indexOf[B >: A](elem : B)
Returns the index of the first occurence of the specified object in this iterable object [details]
note
- may not terminate for infinite-sized collections.
param
elem - element to search for.
return
- the index in this sequence of the first occurence of the specified element, or -1 if the sequence does not contain this element.
Int Iterable
intersect def intersect[B >: A](that : List[B])
Computes the intersection between this list and the given list that [details]
param
that - the list to intersect.
return
- the list of elements contained both in this list and in the given list that.
List[B]
isDefinedAt def isDefinedAt(x : Int)
Is this partial function defined for the index x? [details]
param
x - ..
return
- true, iff x is a legal sequence index.
 Boolean Seq
isInstanceOf final def isInstanceOf[T0] Boolean Any
lastIndexOf def lastIndexOf[B >: A](elem : B)
Returns the index of the last occurence of the specified element in this sequence, or -1 if the sequence does not contain this element [details]
param
elem - element to search for.
return
- the index in this sequence of the last occurence of the specified element, or -1 if the sequence does not contain this element.
Int Seq
lengthCompare override def lengthCompare(l : Int)
returns length - l, without calling length
Int
map override final def map[B](f : (A) => B)
Returns the list resulting from applying the given function f to each element of this list [details]
param
f - function to apply to each element.
return
- [f(a0), ..., f(an)] if this list is [a0, ..., an].
 List[B]
mkString def mkString(start : String, sep : String, end : String)
Returns a string representation of this iterable object [details]
The resulting string begins with the string start and is finished by the string end. Inside, the string representations of elements (w.r.t. the method toString()) are separated by the string sep.
ex
- List(1, 2, 3).mkString("(", "; ", ")") = "(1; 2; 3)"
note
- Will not terminate for infinite-sized collections.
param
sep - separator string.
start - starting string.
end - ending string.
return
- a string representation of this iterable object.
 String Iterable
mkString def mkString(sep : String)
Returns a string representation of this iterable object [details]
The string representations of elements (w.r.t. the method toString()) are separated by the string sep.
note
- Will not terminate for infinite-sized collections.
param
sep - separator string.
return
- a string representation of this iterable object.
 String Iterable
ne final def ne(arg0 : Object) Boolean AnyRef
notify final def notify Unit AnyRef
notifyAll final def notifyAll Unit AnyRef
orElse def orElse[A1 <: A, B1 >: B](that : PartialFunction[A1, B1]) PartialFunction[A1, B1] PartialFunction
partition override def partition(p : (A) => Boolean)
Partition the list in two sub-lists according to a predicate [details]
param
p - the predicate on which to partition
return
- a pair of lists: the list of all elements which satisfy p 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.
(List[A], List[A])
reduceLeft override def reduceLeft[B >: A](f : (B, A) => B)
Combines the elements of this list together using the binary operator op, from left to right [details]
param
op - The operator to apply
return
- op(... op(a0,a1), ..., an) if the list has elements a0, a1, ..., an.
throws
Predef.UnsupportedOperationException - if the list is empty.
 B
reduceRight override def reduceRight[B >: A](f : (A, B) => B)
Combines the elements of this list together using the binary operator op, from right to left [details]
param
op - The operator to apply
return
- a0 op (... op (an-1 op an)...) if the list has elements a0, a1, ..., an.
throws
Predef.UnsupportedOperationException - if the list is empty.
 B
remove def remove(p : (A) => Boolean)
Removes all elements of the list which satisfy the predicate p [details]
This is like filter with the predicate inversed.
param
p - the predicate to use to test elements
return
- the list without all elements which satisfy p
 List[A]
reverseMap def reverseMap[B](f : (A) => B)
Apply a function to all the elements of the list, and return the reversed list of results [details]
This is equivalent to a call to map followed by a call to reverse, but more efficient.
param
f - the function to apply to each elements.
return
- the reversed list of results.
 List[B]
reverse_::: def reverse_:::[B >: A](prefix : List[B])
Reverse the given prefix and append the current list to that [details]
This function is equivalent to an application of reverse on the prefix followed by a call to :::, but more efficient (and tail recursive).
param
prefix - the prefix to reverse and then prepend
return
- the concatenation of the reversed prefix and the current list.
 List[B]
sameElements def sameElements[B >: A](that : Iterable[B])
Checks if the other iterable object contains the same elements [details]
note
- will not terminate for infinite-sized collections.
param
that - the other iterable object
return
- true, iff both iterable objects contain the same elements.
 Boolean Iterable
slice override def slice(start : Int, end : Int)
Returns the list with elements belonging to the given index range [details]
param
end - the end position (exclusive) of the list slice.
start - the start position of the list slice.
return
- the list with elements belonging to the given index range.
 List[A]
slice def slice(from : Int)
A sub-sequence starting at index from and extending up to the length of the current sequence (non-strict) [details]
param
from - The index of the first element of the slice
throws
IndexOutOfBoundsException - if from < 0
 Seq[A] Seq
sort def sort(lt : (A, A) => Boolean)

Sort the list according to the comparison function <(e1: a, e2: a) => Boolean, which should be true iff e1 is smaller than e2.

[details]
ex
- 
      List("Steve", "Tom", "John", "Bob")
        .sort((e1, e2) => (e1 compareTo e2) < 0) =
      List("Bob", "John", "Steve", "Tom")
param
lt - the comparison function
return
- a list sorted according to the comparison function <(e1: a, e2: a) => Boolean.
List[A]
span def span(p : (A) => Boolean)
Returns the longest prefix of the list whose elements all satisfy the given predicate, and the rest of the list [details]
param
p - the test predicate
return
- a pair consisting of the longest prefix of the list whose elements all satisfy p, and the rest of the list.
(List[A], List[A])
splitAt def splitAt(n : Int)
Split the list at a given point and return the two parts thus created [details]
param
n - the position at which to split
return
- a pair of lists composed of the first n elements, and the other elements.
(List[A], List[A])
startsWith def startsWith[B](that : Seq[B])
[details]
return
- true if this sequence start with that sequences
see
- String.startsWith
 Boolean Seq
subseq def subseq(from : Int, end : Int)
Returns a subsequence starting from index from consisting of len elements [details]
deprecated
- use slice instead
 Seq[A] Seq
synchronized final def synchronized[T0](arg0 : T0) T0 AnyRef
take override def take(n : Int)
Returns the n first elements of this list, or else the whole list, if it has less than n elements [details]
param
n - the number of elements to take.
return
- the n first elements of this list.
 List[A]
takeRight def takeRight(n : Int)
Returns the rightmost n elements from this list [details]
param
n - the number of elements to take
return
- the suffix of length n of the list
 List[A]
takeWhile override def takeWhile(p : (A) => Boolean)
Returns the longest prefix of this list whose elements satisfy the predicate p [details]
param
p - the test predicate.
return
- the longest prefix of this list whose elements satisfy the predicate p.
List[A]
toArray override def toArray[B >: A]
Converts this sequence to a fresh Array with length elements
Array[B] Seq
toString override def toString String Collection
union def union[B >: A](that : List[B])
Computes the union of this list and the given list that [details]
param
that - the list of elements to add to the list.
return
- a list without doubles containing the elements of this list and those of the given list that.
List[B]
wait final def wait(arg0 : Long) Unit AnyRef
wait final def wait Unit AnyRef
wait final def wait(arg0 : Long, arg1 : Int) Unit AnyRef
zip def zip[B](that : List[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 [details]
If one of the two lists is longer than the other, its remaining elements are ignored.
return
- List((a0,b0), ..., (amin(m,n),bmin(m,n))) when List(a0, ..., am) zip List(b0, ..., bn) is invoked.
List[(A, B)]
zipAll def zipAll[B, C >: A, D >: B](that : List[B], thisElem : C, thatElem : 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 [details]
param
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 list
that - list that may have a different length as the self list.
return
- List((a0,b0), ..., (an,bn), (elem,bn+1), ..., {elem,bm}) when [a0, ..., an] zip [b0, ..., bm] is invoked where m > n.
List[(C, D)]
zipWithIndex def zipWithIndex
Returns a list that pairs each element of this list with its index, counting from 0 [details]
return
- the list List((a0,0), (a1,1), ...) where ai are the elements of this list.
List[(A, Int)]
OVERVIEW |  PACKAGE | CONSTR |  FIELDS |  METHODS FRAMES    NO FRAMES INHERITED
Copyright (c) 2008. All Rights Reserved.