A RetroSearch Logo

Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Search Query:

Showing content from http://www.scala-lang.org/api/2.12.19/scala/collection/mutable/Map.html below:

Scala Standard Library 2.12.19 - scala.collection.mutable.Map

trait Map[K, V] extends Iterable[(K, V)] with collection.Map[K, V] with MapLike[K, V, Map[K, V]]

 

Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. Map
  2. MapLike
  3. Cloneable
  4. Cloneable
  5. Cloneable
  6. Shrinkable
  7. Builder
  8. Growable
  9. Clearable
  10. Map
  11. MapLike
  12. Subtractable
  13. PartialFunction
  14. Function1
  15. GenMap
  16. GenMapLike
  17. Iterable
  18. Iterable
  19. IterableLike
  20. Equals
  21. GenIterable
  22. GenIterableLike
  23. Traversable
  24. Mutable
  25. Traversable
  26. GenTraversable
  27. GenericTraversableTemplate
  28. TraversableLike
  29. GenTraversableLike
  30. Parallelizable
  31. TraversableOnce
  32. GenTraversableOnce
  33. FilterMonadic
  34. HasNewBuilder
  35. AnyRef
  36. Any
Implicitly
  1. by CollectionsHaveToParArray
  2. by MonadOps
  3. by any2stringadd
  4. by StringFormat
  5. by Ensuring
  6. by ArrowAssoc
  7. by alternateImplicit
Abstract Value Members
  1.  abstract def +=(kv: (K, V)): Map.this.type
  2.  abstract def -=(key: K): Map.this.type
  3.  abstract def get(key: K): Option[V]
  4.  abstract def iterator: Iterator[(K, V)]
Concrete Value Members
  1.  final def !=(arg0: Any): Boolean
  2.  final def ##(): Int
  3.  def +[V1 >: V](elem1: (K, V1), elem2: (K, V1), elems: (K, V1)*): Map[K, V1]
  4.  def +[V1 >: V](kv: (K, V1)): Map[K, V1]
  5.  def ++[V1 >: V](xs: GenTraversableOnce[(K, V1)]): Map[K, V1]
  6.  def ++[B >: (K, V), That](that: GenTraversableOnce[B])(implicit bf: CanBuildFrom[Map[K, V], B, That]): That
  7.  def ++:[B >: (K, V), That](that: collection.Traversable[B])(implicit bf: CanBuildFrom[Map[K, V], B, That]): That
  8.  def ++:[B](that: TraversableOnce[B]): Map[B]
  9.  def ++=(xs: TraversableOnce[(K, V)]): Map.this.type
  10.  def +=(elem1: (K, V), elem2: (K, V), elems: (K, V)*): Map.this.type
  11.  def -(elem1: K, elem2: K, elems: K*): Map[K, V]
  12.  def -(key: K): Map[K, V]
  13.  def --(xs: GenTraversableOnce[K]): Map[K, V]
  14.  def --=(xs: TraversableOnce[K]): Map.this.type
  15.  def -=(elem1: K, elem2: K, elems: K*): Map.this.type
  16.  def ->[B](y: B): (Map[K, V], B)
  17.  final def ==(arg0: Any): Boolean
  18.  def addString(b: scala.StringBuilder, start: String, sep: String, end: String): scala.StringBuilder
  19.  def addString(b: scala.StringBuilder): scala.StringBuilder
  20.  def addString(b: scala.StringBuilder, sep: String): scala.StringBuilder
  21.  def aggregate[B](z: ⇒ B)(seqop: (B, (K, V)) ⇒ B, combop: (B, B) ⇒ B): B
  22.  def andThen[C](k: (V) ⇒ C): PartialFunction[K, C]
  23.  def apply(key: K): V
  24.  def applyOrElse[K1 <: K, V1 >: V](x: K1, default: (K1) ⇒ V1): V1
  25.  final def asInstanceOf[T0]: T0
  26.  def canEqual(that: Any): Boolean
  27.  def clear(): Unit
  28.  def clone(): Map[K, V]
  29.  def collect[B](pf: PartialFunction[A, B]): Map[B]
  30.  def collectFirst[B](pf: PartialFunction[(K, V), B]): Option[B]
  31.  def companion: GenericCompanion[Iterable]
  32.  def compose[A](g: (A) ⇒ K): (A) ⇒ V
  33.  def contains(key: K): Boolean
  34.  def copyToArray(xs: Array[A], start: Int, len: Int): Unit
  35.  def copyToArray(xs: Array[A]): Unit
  36.  def copyToArray(xs: Array[A], start: Int): Unit
  37.  def copyToBuffer[B >: (K, V)](dest: Buffer[B]): Unit
  38.  def count(p: ((K, V)) ⇒ Boolean): Int
  39.  def default(key: K): V
  40.  def drop(n: Int): Map[K, V]
  41.  def dropRight(n: Int): Map[K, V]
  42.  def dropWhile(p: ((K, V)) ⇒ Boolean): Map[K, V]
  43.  def empty: Map[K, V]
  44.  def ensuring(cond: (Map[K, V]) ⇒ Boolean, msg: ⇒ Any): Map[K, V]
  45.  def ensuring(cond: (Map[K, V]) ⇒ Boolean): Map[K, V]
  46.  def ensuring(cond: Boolean, msg: ⇒ Any): Map[K, V]
  47.  def ensuring(cond: Boolean): Map[K, V]
  48.  final def eq(arg0: AnyRef): Boolean
  49.  def equals(that: Any): Boolean
  50.  def exists(p: ((K, V)) ⇒ Boolean): Boolean
  51.  def filter(p: ((K, V)) ⇒ Boolean): Map[K, V]
  52.  def filterKeys(p: (K) ⇒ Boolean): collection.Map[K, V]
  53.  def filterNot(p: ((K, V)) ⇒ Boolean): Map[K, V]
  54.  def finalize(): Unit
  55.  def find(p: ((K, V)) ⇒ Boolean): Option[(K, V)]
  56.  def flatMap[B](f: (A) ⇒ GenTraversableOnce[B]): Map[B]
  57.  def flatten[B]: Map[B]
  58.  def fold[A1 >: (K, V)](z: A1)(op: (A1, A1) ⇒ A1): A1
  59.  def foldLeft[B](z: B)(op: (B, (K, V)) ⇒ B): B
  60.  def foldRight[B](z: B)(op: ((K, V), B) ⇒ B): B
  61.  def forall(p: ((K, V)) ⇒ Boolean): Boolean
  62.  def foreach(f: ((K, V)) ⇒ Unit): Unit
  63.  def genericBuilder[B]: Builder[B, Iterable[B]]
  64.  final def getClass(): Class[_]
  65.  def getOrElse(key: K, default: ⇒ V): V
  66.  def getOrElseUpdate(key: K, op: ⇒ V): V
  67.  def groupBy[K](f: ((K, V)) ⇒ K): immutable.Map[K, Map[K, V]]
  68.  def grouped(size: Int): Iterator[Map[K, V]]
  69.  def hasDefiniteSize: Boolean
  70.  def hashCode(): Int
  71.  def head: (K, V)
  72.  def headOption: Option[(K, V)]
  73.  def init: Map[K, V]
  74.  def inits: Iterator[Map[K, V]]
  75.  def isDefinedAt(key: K): Boolean
  76.  def isEmpty: Boolean
  77.  final def isInstanceOf[T0]: Boolean
  78.  final def isTraversableAgain: Boolean
  79.  def keySet: collection.Set[K]
  80.  def keys: collection.Iterable[K]
  81.  def keysIterator: Iterator[K]
  82.  def last: (K, V)
  83.  def lastOption: Option[(K, V)]
  84.  def lift: (K) ⇒ Option[V]
  85.  def map[B](f: (A) ⇒ B): Map[B]
  86.  def mapResult[NewTo](f: (Map[K, V]) ⇒ NewTo): Builder[(K, V), NewTo]
  87.  def mapValues[W](f: (V) ⇒ W): collection.Map[K, W]
  88.  def max: A
  89.  def maxBy[B](f: (A) ⇒ B): A
  90.  def min: A
  91.  def minBy[B](f: (A) ⇒ B): A
  92.  def mkString: String
  93.  def mkString(sep: String): String
  94.  def mkString(start: String, sep: String, end: String): String
  95.  final def ne(arg0: AnyRef): Boolean
  96.  def newBuilder: Builder[(K, V), Map[K, V]]
  97.  def nonEmpty: Boolean
  98.  final def notify(): Unit
  99.  final def notifyAll(): Unit
  100.  def orElse[A1 <: K, B1 >: V](that: PartialFunction[A1, B1]): PartialFunction[A1, B1]
  101.  def par: ParMap[K, V]
  102.  def parCombiner: Combiner[(K, V), ParMap[K, V]]
  103.  def partition(p: ((K, V)) ⇒ Boolean): (Map[K, V], Map[K, V])
  104.  def product: A
  105.  def put(key: K, value: V): Option[V]
  106.  def reduce[A1 >: (K, V)](op: (A1, A1) ⇒ A1): A1
  107.  def reduceLeft[B >: (K, V)](op: (B, (K, V)) ⇒ B): B
  108.  def reduceLeftOption[B >: (K, V)](op: (B, (K, V)) ⇒ B): Option[B]
  109.  def reduceOption[A1 >: (K, V)](op: (A1, A1) ⇒ A1): Option[A1]
  110.  def reduceRight[B >: (K, V)](op: ((K, V), B) ⇒ B): B
  111.  def reduceRightOption[B >: (K, V)](op: ((K, V), B) ⇒ B): Option[B]
  112.  def remove(key: K): Option[V]
  113.  def repr: Map[K, V]
  114.  def result(): Map[K, V]
  115.  def retain(p: (K, V) ⇒ Boolean): Map.this.type
  116.  def reversed: List[(K, V)]
  117.  def runWith[U](action: (V) ⇒ U): (K) ⇒ Boolean
  118.  def sameElements(that: GenIterable[A]): Boolean
  119.  def scan[B >: (K, V), That](z: B)(op: (B, B) ⇒ B)(implicit cbf: CanBuildFrom[Map[K, V], B, That]): That
  120.  def scanLeft[B, That](z: B)(op: (B, (K, V)) ⇒ B)(implicit bf: CanBuildFrom[Map[K, V], B, That]): That
  121.  def scanRight[B, That](z: B)(op: ((K, V), B) ⇒ B)(implicit bf: CanBuildFrom[Map[K, V], B, That]): That
  122.  def seq: Map[K, V]
  123.  def size: Int
  124.  def sizeHint(coll: TraversableLike[_, _], delta: Int): Unit
  125.  def sizeHint(coll: TraversableLike[_, _]): Unit
  126.  def sizeHint(size: Int): Unit
  127.  def sizeHintBounded(size: Int, boundingColl: TraversableLike[_, _]): Unit
  128.  def sizeHintIfCheap: Int
  129.  def slice(from: Int, until: Int): Map[K, V]
  130.  def sliding(size: Int, step: Int): Iterator[Map[K, V]]
  131.  def sliding(size: Int): Iterator[Map[K, V]]
  132.  def span(p: ((K, V)) ⇒ Boolean): (Map[K, V], Map[K, V])
  133.  def splitAt(n: Int): (Map[K, V], Map[K, V])
  134.  def stringPrefix: String
  135.  def sum: A
  136.  final def synchronized[T0](arg0: ⇒ T0): T0
  137.  def tail: Map[K, V]
  138.  def tails: Iterator[Map[K, V]]
  139.  def take(n: Int): Map[K, V]
  140.  def takeRight(n: Int): Map[K, V]
  141.  def takeWhile(p: ((K, V)) ⇒ Boolean): Map[K, V]
  142.  def thisCollection: collection.Iterable[(K, V)]
  143.  def to[Col[_]]: Col[A]
  144.  def toArray: Array[A]
  145.  def toBuffer[E >: (K, V)]: Buffer[E]
  146.  def toCollection(repr: Map[K, V]): collection.Iterable[(K, V)]
  147.  def toIndexedSeq: immutable.IndexedSeq[(K, V)]
  148.  def toIterable: collection.Iterable[(K, V)]
  149.  def toIterator: Iterator[(K, V)]
  150.  def toList: List[(K, V)]
  151.  def toMap[T, U]: collection.Map[T, U]
  152.  def toParArray: ParArray[T]
  153.  def toSeq: collection.Seq[(K, V)]
  154.  def toSet[B >: (K, V)]: immutable.Set[B]
  155.  def toStream: immutable.Stream[(K, V)]
  156.  def toString(): String
  157.  def toTraversable: collection.Traversable[(K, V)]
  158.  def toVector: Vector[(K, V)]
  159.  def transform(f: (K, V) ⇒ V): Map.this.type
  160.  def transpose[B](implicit asTraversable: ((K, V)) ⇒ GenTraversableOnce[B]): Iterable[Iterable[B]]
  161.  def unzip[A1, A2](implicit asPair: ((K, V)) ⇒ (A1, A2)): (Iterable[A1], Iterable[A2])
  162.  def unzip3[A1, A2, A3](implicit asTriple: ((K, V)) ⇒ (A1, A2, A3)): (Iterable[A1], Iterable[A2], Iterable[A3])
  163.  def update(key: K, value: V): Unit
  164.  def updated[V1 >: V](key: K, value: V1): Map[K, V1]
  165.  def values: collection.Iterable[V]
  166.  def valuesIterator: Iterator[V]
  167.  def view(from: Int, until: Int): IterableView[(K, V), Map[K, V]]
  168.  def view: IterableView[(K, V), Map[K, V]]
  169.  final def wait(): Unit
  170.  final def wait(arg0: Long, arg1: Int): Unit
  171.  final def wait(arg0: Long): Unit
  172.  def withDefault(d: (K) ⇒ V): Map[K, V]
  173.  def withDefaultValue(d: V): Map[K, V]
  174.  def withFilter(p: ((K, V)) ⇒ Boolean): FilterMonadic[(K, V), Map[K, V]]
  175.  def zip[B](that: GenIterable[B]): Map[(A, B)]
  176.  def zipAll[B](that: collection.Iterable[B], thisElem: A, thatElem: B): Map[(A, B)]
  177.  def zipWithIndex: Map[(A, Int)]
  178.  def →[B](y: B): (Map[K, V], B)
Deprecated Value Members
  1.  def /:[B](z: B)(op: (B, (K, V)) ⇒ B): B
  2.  def :\[B](z: B)(op: ((K, V), B) ⇒ B): B
  3.  def formatted(fmtstr: String): String

Inherited from java.lang.Cloneable

Inherited from (K) ⇒ V

Inherited by implicit conversion MonadOps from Map[K, V] to MonadOps[(K, V)] Inherited by implicit conversion Ensuring from Map[K, V] to Ensuring[Map[K, V]] Inherited by implicit conversion ArrowAssoc from Map[K, V] to ArrowAssoc[Map[K, V]]

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4