| OVERVIEW | PACKAGE | CONSTR | FIELDS | METHODS | FRAMES NO FRAMES | INHERITED |
class ConcurrentLinkedList[A]
extends
Seq[A]
def this
|
| elements |
def elements
|
Iterator[A] | |
| first |
def first
|
A | Seq |
| firstOption |
def firstOption
|
Option[A] | Seq |
| hasDefiniteSize |
def hasDefiniteSize
|
Boolean | Iterable |
| headOption |
def headOption
|
Option[A] | Seq |
| isEmpty |
override def isEmpty
|
Boolean | Seq |
| last |
def last
|
A | Seq |
| lastOption |
def lastOption
|
Option[A] | Seq |
| length |
def length
This operation is not generally useful, because there is never any
guarantee that the result is current
|
Int | |
| mkString |
def mkString
|
String | Iterable |
| projection |
override def projection
|
Projection[A] | Seq |
| reverse |
def reverse
|
Seq[A] | Seq |
| size |
def size
|
Int | Seq |
| stringPrefix |
protected def stringPrefix
|
String | Collection |
| toList |
def toList
|
List[A] | Iterable |
| toSeq |
override def toSeq
|
Seq[A] | Seq |
| toStream |
def toStream
|
Stream[A] | Iterable |
| != |
final def !=(arg0 : Object)
|
Boolean | AnyRef |
| != |
final def !=(arg0 : Any)
|
Boolean | Any |
| ++ |
override def ++[B >: A](arg0 : Iterable[B])
|
Seq[B] | Seq |
| += |
def +=(elem : A)
Appends an element
[details]
Appended elements are guaranteed to appear in the
list eventually, in the order that they were added, but an iteration
immediately following an append is not guaranteed to return the new
element yet.
|
Unit | |
| -= |
def -=(elem : A)
Deletes the first matching node
[details]
This is safe w.r.t. concurrent appends
and iterations, but is synchronized to protect it from itself.
|
Unit | |
| /: |
def /:[B](arg0 : B)
|
B | Iterable |
| :\ |
def :\[B](arg0 : B)
|
B | Iterable |
| == |
final def ==(arg0 : Any)
|
Boolean | Any |
| == |
final def ==(arg0 : Object)
|
Boolean | AnyRef |
| addString |
def addString(arg0 : StringBuilder, arg1 : String)
|
StringBuilder | Iterable |
| addString |
def addString(arg0 : StringBuilder, arg1 : String, arg2 : String, arg3 : String)
|
StringBuilder | Iterable |
| andThen |
override def andThen[C](arg0 : (B) => C)
|
PartialFunction[A, C] | PartialFunction |
| apply |
def apply(n : Int)
|
A | |
| asInstanceOf |
final def asInstanceOf[T0]
|
T0 | Any |
| clear |
def clear
|
Unit | |
| clone |
protected def clone
|
Object | AnyRef |
| compose |
def compose[A](arg0 : (A) => T1)
|
(A) => R | Function1 |
| concat |
override def concat[B >: A](arg0 : Iterable[B])
|
Seq[B] | Seq |
| contains |
def contains(arg0 : Any)
|
Boolean | Seq |
| containsSlice |
def containsSlice[B](arg0 : Seq[B])
|
Boolean | Seq |
| copyToArray |
def copyToArray[B >: A](arg0 : Array[B], arg1 : Int)
|
Unit | Iterable |
| copyToBuffer |
def copyToBuffer[B >: A](arg0 : Buffer[B])
|
Unit | Iterable |
| drop |
override def drop(arg0 : Int)
|
Seq[A] | Seq |
| dropWhile |
override def dropWhile(arg0 : (A) => Boolean)
|
Seq[A] | Seq |
| endsWith |
def endsWith[B](arg0 : Seq[B])
|
Boolean | Seq |
| eq |
final def eq(arg0 : Object)
|
Boolean | AnyRef |
| equals |
def equals(arg0 : Any)
|
Boolean | AnyRef |
| equalsWith |
def equalsWith[B](arg0 : Seq[B])
|
Boolean | Seq |
| exists |
def exists(arg0 : (A) => Boolean)
|
Boolean | Iterable |
| filter |
override def filter(arg0 : (A) => Boolean)
|
Seq[A] | Seq |
| finalize |
protected def finalize
|
Unit | AnyRef |
| find |
def find(arg0 : (A) => Boolean)
|
Option[A] | Iterable |
| findIndexOf |
def findIndexOf(arg0 : (A) => Boolean)
|
Int | Iterable |
| flatMap |
override def flatMap[B](arg0 : (A) => Iterable[B])
|
Seq[B] | Seq |
| foldLeft |
def foldLeft[B](arg0 : B)
|
B | Iterable |
| foldRight |
def foldRight[B](arg0 : B)
|
B | Iterable |
| forall |
def forall(arg0 : (A) => Boolean)
|
Boolean | Iterable |
| foreach |
def foreach(arg0 : (A) => Unit)
|
Unit | Iterable |
| getClass |
final def getClass
|
Class[Any] | AnyRef |
| hashCode |
def hashCode
|
Int | AnyRef |
| indexOf |
def indexOf[B >: A](arg0 : B)
|
Int | Iterable |
| indexOf |
def indexOf[B >: A](arg0 : Seq[B])
|
Int | Seq |
| isDefinedAt |
def isDefinedAt(arg0 : Int)
|
Boolean | Seq |
| isInstanceOf |
final def isInstanceOf[T0]
|
Boolean | Any |
| lastIndexOf |
def lastIndexOf[B >: A](arg0 : B)
|
Int | Seq |
| lengthCompare |
def lengthCompare(arg0 : Int)
|
Int | Seq |
| map |
override def map[B](arg0 : (A) => B)
|
Seq[B] | Seq |
| mkString |
def mkString(arg0 : String)
|
String | Iterable |
| mkString |
def mkString(arg0 : String, arg1 : String, arg2 : String)
|
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](arg0 : PartialFunction[A1, B1])
|
PartialFunction[A1, B1] | PartialFunction |
| partition |
def partition(arg0 : (A) => Boolean)
|
(Iterable[A], Iterable[A]) | Iterable |
| reduceLeft |
def reduceLeft[B >: A](arg0 : (B, A) => B)
|
B | Iterable |
| reduceRight |
def reduceRight[B >: A](arg0 : (A, B) => B)
|
B | Iterable |
| sameElements |
def sameElements[B >: A](arg0 : Iterable[B])
|
Boolean | Iterable |
| slice |
def slice(arg0 : Int)
|
Seq[A] | Seq |
| slice |
def slice(arg0 : Int, arg1 : Int)
|
Seq[A] | Seq |
| startsWith |
def startsWith[B](arg0 : Seq[B])
|
Boolean | Seq |
| subseq |
def subseq(arg0 : Int, arg1 : Int)
|
Seq[A] | Seq |
| synchronized |
final def synchronized[T0](arg0 : T0)
|
T0 | AnyRef |
| take |
override def take(arg0 : Int)
|
Seq[A] | Seq |
| takeWhile |
override def takeWhile(arg0 : (A) => Boolean)
|
Seq[A] | Seq |
| toArray |
override def toArray[B >: A]
|
Array[B] | Seq |
| toString |
override def toString
|
String | Collection |
| wait |
final def wait(arg0 : Long, arg1 : Int)
|
Unit | AnyRef |
| wait |
final def wait
|
Unit | AnyRef |
| wait |
final def wait(arg0 : Long)
|
Unit | AnyRef |
| OVERVIEW | PACKAGE | CONSTR | FIELDS | METHODS | FRAMES NO FRAMES | INHERITED |