scala.collection.mutable

LinkedHashMap

class LinkedHashMap[A, B] extends Map[A, B] with MapLike[A, B, LinkedHashMap[A, B]] with HashTable[A]

This class implements mutable maps using a hashtable. The iterator and all traversal methods of this class visit elements in the order they were inserted.

A

the type of the keys contained in this hash map.

B

the type of the values assigned to keys in this hash map.

go to: companion
source: LinkedHashMap.scala
Inherited
  1. Hide All
  2. Show all
  1. HashTable
  2. Map
  3. MapLike
  4. Cloneable
  5. Shrinkable
  6. Builder
  7. Growable
  8. Map
  9. MapLike
  10. Subtractable
  11. PartialFunction
  12. Function1
  13. Iterable
  14. Iterable
  15. IterableLike
  16. Equals
  17. Traversable
  18. Mutable
  19. Traversable
  20. GenericTraversableTemplate
  21. TraversableLike
  22. TraversableOnce
  23. FilterMonadic
  24. HasNewBuilder
  25. AnyRef
  26. Any
Visibility
  1. Public
  2. All

Instance constructors

  1. new LinkedHashMap()

Type Members

  1. class DefaultKeySet extends Set[A]

    The implementation class of the set returned by keySet.

  2. class DefaultValuesIterable extends Iterable[B]

    The implementation class of the iterable returned by values.

  3. type Entry = LinkedEntry[A, B]

  4. type Self = LinkedHashMap[A, B]

    The type implementing this traversable

  5. class WithFilter extends FilterMonadic[A, Repr]

    A class supporting filtered operations.

Value Members

  1. def !=(arg0: AnyRef): Boolean

  2. def !=(arg0: Any): Boolean

    o != arg0 is the same as !(o == (arg0)).

  3. def ##(): Int

  4. def $asInstanceOf[T0](): T0

  5. def $isInstanceOf[T0](): Boolean

  6. def +[B1 >: B](elem1: (A, B1), elem2: (A, B1), elems: (A, B1)*): Map[A, B1]

    Creates a new map containing two or more key/value mappings and all the key/value mappings of this map.

  7. def +[B1 >: B](kv: (A, B1)): Map[A, B1]

    Creates a new map containing a new key/value mapping and all the key/value mappings of this map.

  8. def ++[B1 >: B](xs: TraversableOnce[(A, B1)]): Map[A, B1]

    Creates a new map containing the key/value mappings provided by the specified traversable object and all the key/value mappings of this map.

  9. def ++(that: TraversableOnce[(A, B)]): LinkedHashMap[(A, B)]

    [use case] Concatenates this linked hash map with the elements of a traversable collection.

  10. def ++[B >: (A, B), That](that: TraversableOnce[B])(implicit bf: CanBuildFrom[LinkedHashMap[A, B], B, That]): That

    Concatenates this linked hash map with the elements of a traversable collection.

  11. def ++=(xs: TraversableOnce[(A, B)]): Growable[(A, B)]

    adds all elements produced by a TraversableOnce to this linked hash map.

  12. def +=(kv: (A, B)): LinkedHashMap[A, B]

    Adds a new key/value pair to this map.

  13. def +=(elem1: (A, B), elem2: (A, B), elems: (A, B)*): Growable[(A, B)]

    adds two or more elements to this linked hash map.

  14. def -(elem1: A, elem2: A, elems: A*): LinkedHashMap[A, B]

    Creates a new map with all the key/value mappings of this map except mappings with keys equal to any of the two or more specified keys.

  15. def -(key: A): LinkedHashMap[A, B]

    Creates a new map with all the key/value mappings of this map except the key/value mapping with the specified key.

  16. def --(xs: TraversableOnce[A]): LinkedHashMap[A, B]

    Creates a new map with all the key/value mappings of this map except mappings with keys equal to any of those provided by the specified traversable object.

  17. def --=(xs: TraversableOnce[A]): Shrinkable[A]

    Removes all elements produced by an iterator from this linked hash map.

  18. def -=(key: A): LinkedHashMap[A, B]

    Removes a key from this map.

  19. def -=(elem1: A, elem2: A, elems: A*): Shrinkable[A]

    Removes two or more elements from this linked hash map.

  20. def /:[B](z: B)(op: (B, (A, B)) ⇒ B): B

    Applies a binary operator to a start value and all elements of this linked hash map, going left to right.

  21. def :\[B](z: B)(op: ((A, B), B) ⇒ B): B

    Applies a binary operator to all elements of this linked hash map and a start value, going right to left.

  22. def ==(arg0: AnyRef): Boolean

    o == arg0 is the same as if (o eq null) arg0 eq null else o.equals(arg0).

  23. def ==(arg0: Any): Boolean

    o == arg0 is the same as o.equals(arg0).

  24. def addEntry(e: LinkedEntry[A, B]): Unit

    Add entry to table pre: no entry with same key exists

  25. def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder

    Appends all bindings of this map to a string builder using start, end, and separator strings.

  26. def addString(b: StringBuilder): StringBuilder

    Appends all elements of this linked hash map to a string builder.

  27. def addString(b: StringBuilder, sep: String): StringBuilder

    Appends all elements of this linked hash map to a string builder using a separator string.

  28. def andThen[C](k: (B) ⇒ C): PartialFunction[A, C]

    Composes this partial function with a transformation function that gets applied to results of this partial function.

  29. def apply(key: A): B

    Retrieves the value which is associated with the given key.

  30. def asInstanceOf[T0]: T0

    This method is used to cast the receiver object to be of type T0.

  31. def canEqual(that: Any): Boolean

    Method called from equality methods, so that user-defined subclasses can refuse to be equal to other collections of the same kind.

  32. def clear(): Unit

    Removes all bindings from the map.

  33. def clearTable(): Unit

    Remove all entries from table

  34. def clone(): LinkedHashMap[A, B]

    This method creates and returns a copy of the receiver object.

  35. def collect[B](pf: PartialFunction[(A, B), B]): LinkedHashMap[B]

    [use case] Builds a new collection by applying a partial function to all elements of this linked hash map on which the function is defined.

  36. def collect[B, That](pf: PartialFunction[(A, B), B])(implicit bf: CanBuildFrom[LinkedHashMap[A, B], B, That]): That

    Builds a new collection by applying a partial function to all elements of this linked hash map on which the function is defined.

  37. def companion: GenericCompanion[Iterable[A][A]]

    The factory companion object that builds instances of class LinkedHashMap.

  38. def compose[A](g: (A) ⇒ A): (A) ⇒ B

    (f compose g)(x) == f(g(x))

  39. def contains(key: A): Boolean

    Tests whether this map contains a binding for a key.

  40. def copyToArray(xs: Array[(A, B)], start: Int, len: Int): Unit

    [use case] Copies elements of this linked hash map to an array.

  41. def copyToArray[B >: (A, B)](xs: Array[B], start: Int, len: Int): Unit

    Copies elements of this linked hash map to an array.

  42. def copyToArray(xs: Array[(A, B)]): Unit

    [use case] Copies values of this linked hash map to an array.

  43. def copyToArray[B >: (A, B)](xs: Array[B]): Unit

    Copies values of this linked hash map to an array.

  44. def copyToArray(xs: Array[(A, B)], start: Int): Unit

    [use case] Copies values of this linked hash map to an array.

  45. def copyToArray[B >: (A, B)](xs: Array[B], start: Int): Unit

    Copies values of this linked hash map to an array.

  46. def copyToBuffer[B >: (A, B)](dest: Buffer[B]): Unit

    Copies all elements of this linked hash map to a buffer.

  47. def count(p: ((A, B)) ⇒ Boolean): Int

    Counts the number of elements in the linked hash map which satisfy a predicate.

  48. def default(key: A): B

    Defines the default value computation for the map, returned when a key is not found The method implemented here throws an exception, but it might be overridden in subclasses.

  49. def drop(n: Int): LinkedHashMap[A, B]

    Selects all elements except first n ones.

  50. def dropRight(n: Int): LinkedHashMap[A, B]

    Selects all elements except last n ones.

  51. def dropWhile(p: ((A, B)) ⇒ Boolean): LinkedHashMap[A, B]

    Drops longest prefix of elements that satisfy a predicate.

  52. def elemEquals(key1: A, key2: A): Boolean

  53. def elemHashCode(key: A): Int

  54. def elements: Iterator[(A, B)]

  55. def empty: LinkedHashMap[A, B]

    The empty map of the same type as this map

  56. def entries: Iterator[LinkedEntry[A, B]]

    An iterator returning all entries

  57. def entriesIterator: Iterator[LinkedEntry[A, B]]

    An iterator returning all entries.

  58. def eq(arg0: AnyRef): Boolean

    This method is used to test whether the argument (arg0) is a reference to the receiver object (this).

  59. def equals(that: Any): Boolean

    Compares two maps structurally; i.

  60. def exists(p: ((A, B)) ⇒ Boolean): Boolean

    Tests whether a predicate holds for some of the elements of this linked hash map.

  61. def filter(p: ((A, B)) ⇒ Boolean): LinkedHashMap[A, B]

    Selects all elements of this linked hash map which satisfy a predicate.

  62. def filterKeys(p: (A) ⇒ Boolean): Map[A, B]

    Filters this map by retaining only keys satisfying a predicate.

  63. def filterNot(p: ((A, B)) ⇒ Boolean): LinkedHashMap[A, B]

    Returns a new map with all key/value pairs for which the predicate p returns true.

  64. def finalize(): Unit

    This method is called by the garbage collector on the receiver object when garbage collection determines that there are no more references to the object.

  65. def find(p: ((A, B)) ⇒ Boolean): Option[(A, B)]

    Finds the first element of the linked hash map satisfying a predicate, if any.

  66. def findEntry(key: A): LinkedEntry[A, B]

    Find entry with given key in table, null if not found.

  67. def first: (A, B)

  68. var firstEntry: LinkedEntry[A, B]

  69. def firstOption: Option[(A, B)]

    None if iterable is empty.

  70. def flatMap[B](f: ((A, B)) ⇒ Traversable[B]): LinkedHashMap[B]

    [use case] Builds a new collection by applying a function to all elements of this linked hash map and concatenating the results.

  71. def flatMap[B, That](f: ((A, B)) ⇒ Traversable[B])(implicit bf: CanBuildFrom[LinkedHashMap[A, B], B, That]): That

    Builds a new collection by applying a function to all elements of this linked hash map and concatenating the results.

  72. def flatten[B]: LinkedHashMap[B]

    [use case] Converts this linked hash map of traversable collections into a linked hash map in which all element collections are concatenated.

  73. def flatten[B](implicit asTraversable: ((A, B)) ⇒ Traversable[B]): Iterable[B]

    Converts this linked hash map of traversable collections into a linked hash map in which all element collections are concatenated.

  74. def foldLeft[B](z: B)(op: (B, (A, B)) ⇒ B): B

    Applies a binary operator to a start value and all elements of this linked hash map, going left to right.

  75. def foldRight[B](z: B)(op: ((A, B), B) ⇒ B): B

    Applies a binary operator to all elements of this linked hash map and a start value, going right to left.

  76. def forall(p: ((A, B)) ⇒ Boolean): Boolean

    Tests whether a predicate holds for all elements of this linked hash map.

  77. def foreach(f: ((A, B)) ⇒ Unit): Unit

    [use case] Applies a function f to all elements of this linked hash map.

  78. def foreach[U](f: ((A, B)) ⇒ U): Unit

    Applies a function f to all elements of this linked hash map.

  79. def foreachEntry[C](f: (LinkedEntry[A, B]) ⇒ C): Unit

  80. def genericBuilder[B]: Builder[B, Iterable[B]]

    The generic builder that builds instances of LinkedHashMap at arbitrary element types.

  81. def get(key: A): Option[B]

    Optionally returns the value associated with a key.

  82. def getClass(): java.lang.Class[_ <: java.lang.Object]

    Returns a representation that corresponds to the dynamic class of the receiver object.

  83. def getOrElse(key: A, default: ⇒ B): B

    [use case] Returns the value associated with a key, or a default value if the key is not contained in the map.

  84. def getOrElse[B1 >: B](key: A, default: ⇒ B1): B1

    Returns the value associated with a key, or a default value if the key is not contained in the map.

  85. def getOrElseUpdate(key: A, op: ⇒ B): B

    If given key is already in this map, returns associated value.

  86. def groupBy[K](f: ((A, B)) ⇒ K): Map[K, LinkedHashMap[A, B]]

    Partitions this linked hash map into a map of linked hash maps according to some discriminator function.

  87. def grouped(size: Int): Iterator[LinkedHashMap[A, B]]

    Partitions elements in fixed size linked hash maps.

  88. def hasDefiniteSize: Boolean

    Tests whether this linked hash map is known to have a finite size.

  89. def hashCode(): Int

    Returns a hash code value for the object.

  90. def head: (A, B)

    Selects the first element of this linked hash map.

  91. def headOption: Option[(A, B)]

    Optionally selects the first element.

  92. def improve(hcode: Int): Int

  93. def index(hcode: Int): Int

  94. def init: LinkedHashMap[A, B]

    Selects all elements except the last.

  95. def initialSize: Int

    The initial size of the hash table.

  96. def initialThreshold: Int

    The initial threshold

  97. def isDefinedAt(key: A): Boolean

    Tests whether this map contains a binding for a key.

  98. def isEmpty: Boolean

    Tests whether the map is empty.

  99. def isInstanceOf[T0]: Boolean

    This method is used to test whether the dynamic type of the receiver object is T0.

  100. def isTraversableAgain: Boolean

    Tests whether this linked hash map can be repeatedly traversed.

  101. def iterator: Iterator[(A, B)]

    Creates a new iterator over all key/value pairs of this map

  102. def keySet: Set[A]

    Collects all keys of this map in a set.

  103. def keys: Iterable[A]

    Creates an iterator for all keys.

  104. def keysIterator: Iterator[A]

    Creates an iterator for all keys.

  105. def last: (A, B)

    Selects the last element.

  106. var lastEntry: LinkedEntry[A, B]

  107. def lastOption: Option[(A, B)]

    Optionally selects the last element.

  108. def lift: (A) ⇒ Option[B]

    Turns this partial function into an plain function returning an Option result.

  109. def loadFactor: Int

    The load factor for the hash table (in 0.

  110. val loadFactorDenum: Int

  111. def map[B](f: ((A, B)) ⇒ B): LinkedHashMap[B]

    [use case] Builds a new collection by applying a function to all elements of this linked hash map.

  112. def map[B, That](f: ((A, B)) ⇒ B)(implicit bf: CanBuildFrom[LinkedHashMap[A, B], B, That]): That

    Builds a new collection by applying a function to all elements of this linked hash map.

  113. def mapElements[C](f: (B) ⇒ C): Map[A, C]

  114. def mapResult[NewTo](f: (LinkedHashMap[A, B]) ⇒ NewTo): Builder[(A, B), NewTo]

    Creates a new builder by applying a transformation function to the results of this builder.

  115. def mapValues[C](f: (B) ⇒ C): Map[A, C]

    Transforms this map by applying a function to every retrieved value.

  116. def max: (A, B)

    [use case] Finds the largest element.

  117. def max[B >: (A, B)](implicit cmp: Ordering[B]): (A, B)

    Finds the largest element.

  118. def min: (A, B)

    [use case] Finds the smallest element.

  119. def min[B >: (A, B)](implicit cmp: Ordering[B]): (A, B)

    Finds the smallest element.

  120. def mkString: String

    Displays all elements of this linked hash map in a string.

  121. def mkString(sep: String): String

    Displays all elements of this linked hash map in a string using a separator string.

  122. def mkString(start: String, sep: String, end: String): String

    Displays all elements of this linked hash map in a string using start, end, and separator strings.

  123. def ne(arg0: AnyRef): Boolean

    o.ne(arg0) is the same as !(o.eq(arg0)).

  124. def newBuilder: Builder[(A, B), LinkedHashMap[A, B]]

    A common implementation of newBuilder for all mutable maps in terms of empty.

  125. def nonEmpty: Boolean

    Tests whether the linked hash map is not empty.

  126. def notify(): Unit

    Wakes up a single thread that is waiting on the receiver object's monitor.

  127. def notifyAll(): Unit

    Wakes up all threads that are waiting on the receiver object's monitor.

  128. def orElse[A1 <: A, B1 >: B](that: PartialFunction[A1, B1]): PartialFunction[A1, B1]

    Composes this partial function with a fallback partial function which gets applied where this partial function is not defined.

  129. def partition(p: ((A, B)) ⇒ Boolean): (LinkedHashMap[A, B], LinkedHashMap[A, B])

    Partitions this linked hash map in two linked hash maps according to a predicate.

  130. def product: Int

    [use case] Multiplies up the elements of this collection.

  131. def product[B >: (A, B)](implicit num: Numeric[B]): B

    Multiplies up the elements of this collection.

  132. def projection: IterableView[(A, B), LinkedHashMap[A, B]]

    returns a projection that can be used to call non-strict filter,map, and flatMap methods that build projections of the collection.

  133. def put(key: A, value: B): Option[B]

    Adds a new key/value pair to this map and optionally returns previously bound value.

  134. def reduceLeft[B >: (A, B)](op: (B, (A, B)) ⇒ B): B

    Applies a binary operator to all elements of this linked hash map, going left to right.

  135. def reduceLeftOption[B >: (A, B)](op: (B, (A, B)) ⇒ B): Option[B]

    Optionally applies a binary operator to all elements of this linked hash map, going left to right.

  136. def reduceRight[B >: (A, B)](op: ((A, B), B) ⇒ B): B

    Applies a binary operator to all elements of this linked hash map, going right to left.

  137. def reduceRightOption[B >: (A, B)](op: ((A, B), B) ⇒ B): Option[B]

    Optionally applies a binary operator to all elements of this linked hash map, going right to left.

  138. def remove(key: A): Option[B]

    Removes a key from this map, returning the value associated previously with that key as an option.

  139. def removeEntry(key: A): LinkedEntry[A, B]

    Remove entry from table if present.

  140. def removeKey(key: A): Option[B]

    If given key is defined in this map, remove it and return associated value as an Option.

  141. def repr: LinkedHashMap[A, B]

    The collection of type linked hash map underlying this TraversableLike object.

  142. def result(): LinkedHashMap[A, B]

    The result when this map is used as a builder

  143. def retain(p: (A, B) ⇒ Boolean): MapLike[A, B, LinkedHashMap[A, B]]

    Retains only those mappings for which the predicate p returns true.

  144. def reversed: List[(A, B)]

  145. def sameElements(that: Iterable[(A, B)]): Boolean

    [use case] Checks if the other iterable collection contains the same elements in the same order as this linked hash map.

  146. def sameElements[B >: (A, B)](that: Iterable[B]): Boolean

    Checks if the other iterable collection contains the same elements in the same order as this linked hash map.

  147. def scanLeft[B, That](z: B)(op: (B, (A, B)) ⇒ B)(implicit bf: CanBuildFrom[LinkedHashMap[A, B], B, That]): That

    Produces a collection containing cummulative results of applying the operator going left to right.

  148. def scanRight[B, That](z: B)(op: ((A, B), B) ⇒ B)(implicit bf: CanBuildFrom[LinkedHashMap[A, B], B, That]): That

    Produces a collection containing cummulative results of applying the operator going right to left.

  149. def size: Int

    The size of this linked hash map.

  150. def sizeHint(coll: scala.collection.TraversableLike[_, _], delta: Int = 0): Unit

    Gives a hint that one expects the result of this builder to have the same size as the given collection, plus some delta.

  151. def sizeHint(size: Int): Unit

    Gives a hint how many elements are expected to be added when the next result is called.

  152. def sizeHintBounded(size: Int, boundingColl: scala.collection.TraversableLike[_, _]): Unit

    Gives a hint how many elements are expected to be added when the next result is called, together with an upper bound given by the size of some other collection.

  153. def slice(from: Int, until: Int): LinkedHashMap[A, B]

    Selects an interval of elements.

  154. def sliding[B >: (A, B)](size: Int, step: Int): Iterator[LinkedHashMap[A, B]]

  155. def sliding[B >: (A, B)](size: Int): Iterator[LinkedHashMap[A, B]]

    Groups elements in fixed size blocks by passing a "sliding window" over them (as opposed to partitioning them, as is done in grouped.

  156. def span(p: ((A, B)) ⇒ Boolean): (LinkedHashMap[A, B], LinkedHashMap[A, B])

    Splits this linked hash map into a prefix/suffix pair according to a predicate.

  157. def splitAt(n: Int): (LinkedHashMap[A, B], LinkedHashMap[A, B])

    Splits this linked hash map into two at a given position.

  158. def stringPrefix: String

    Defines the prefix of this object's toString representation.

  159. def sum: Int

    [use case] Sums up the elements of this collection.

  160. def sum[B >: (A, B)](implicit num: Numeric[B]): B

    Sums up the elements of this collection.

  161. def synchronized[T0](arg0: T0): T0

  162. var table: Array[HashEntry[A, LinkedEntry[A, B]]]

    The actual hash table.

  163. var tableSize: Int

    The number of mappings contained in this hash table.

  164. def tail: LinkedHashMap[A, B]

    Selects all elements except the first.

  165. def take(n: Int): LinkedHashMap[A, B]

    Selects first n elements.

  166. def takeRight(n: Int): LinkedHashMap[A, B]

    Selects last n elements.

  167. def takeWhile(p: ((A, B)) ⇒ Boolean): LinkedHashMap[A, B]

    Takes longest prefix of elements that satisfy a predicate.

  168. def thisCollection: Iterable[(A, B)]

    The underlying collection seen as an instance of LinkedHashMap.

  169. var threshold: Int

    The next size value at which to resize (capacity * load factor).

  170. def toArray: Array[(A, B)]

    [use case] Converts this linked hash map to an array.

  171. def toArray[B >: (A, B)](implicit arg0: ClassManifest[B]): Array[B]

    Converts this linked hash map to an array.

  172. def toBuffer[B >: (A, B)]: Buffer[B]

    Converts this linked hash map to a mutable buffer.

  173. def toCollection(repr: LinkedHashMap[A, B]): Iterable[(A, B)]

    A conversion from collections of type Repr to LinkedHashMap objects.

  174. def toIndexedSeq[B >: (A, B)]: IndexedSeq[B]

    Converts this linked hash map to an indexed sequence.

  175. def toIterable: Iterable[(A, B)]

    Converts this linked hash map to an iterable collection.

  176. def toIterator: Iterator[(A, B)]

    Returns an Iterator over the elements in this linked hash map.

  177. def toList: List[(A, B)]

    Converts this linked hash map to a list.

  178. def toMap[T, U](implicit ev: <:<[(A, B), (T, U)]): Map[T, U]

    Converts this linked hash map to a map.

  179. def toSeq: Seq[(A, B)]

    Converts this linked hash map to a sequence.

  180. def toSet[B >: (A, B)]: Set[B]

    Converts this linked hash map to a set.

  181. def toStream: Stream[(A, B)]

    Converts this linked hash map to a stream.

  182. def toString(): String

    Converts this linked hash map to a string.

  183. def toTraversable: Traversable[(A, B)]

    Converts this linked hash map to an unspecified Traversable.

  184. def transform(f: (A, B) ⇒ B): MapLike[A, B, LinkedHashMap[A, B]]

    Applies a transformation function to all values contained in this map.

  185. def transpose[B](implicit asTraversable: ((A, B)) ⇒ Traversable[B]): Iterable[Iterable[B]]

    Transposes this linked hash map of traversable collections into a linked hash map of linked hash maps.

  186. def unzip[A1, A2](implicit asPair: ((A, B)) ⇒ (A1, A2)): (Iterable[A1], Iterable[A2])

    Converts this linked hash map of pairs into two collections of the first and second halfs of each pair.

  187. def update(key: A, value: B): Unit

    Adds a new key/value pair to this map.

  188. def updated[B1 >: B](key: A, value: B1): Map[A, B1]

    Creates a new map consisting of all key/value pairs of the current map plus a new pair of a given key and value.

  189. def values: Iterable[B]

    Collects all values of this map in an iterable collection.

  190. def valuesIterator: Iterator[B]

    Creates an iterator for all values in this map.

  191. def view(from: Int, until: Int): IterableView[(A, B), LinkedHashMap[A, B]]

    Creates a non-strict view of a slice of this linked hash map.

  192. def view: IterableView[(A, B), LinkedHashMap[A, B]]

    Creates a non-strict view of this linked hash map.

  193. def wait(): Unit

  194. def wait(arg0: Long, arg1: Int): Unit

  195. def wait(arg0: Long): Unit

  196. def withFilter(p: ((A, B)) ⇒ Boolean): FilterMonadic[(A, B), LinkedHashMap[A, B]]

    Creates a non-strict filter of this linked hash map.

  197. def zip[B](that: Iterable[B]): LinkedHashMap[((A, B), B)]

    [use case] Returns a linked hash map formed from this linked hash map and another iterable collection by combining corresponding elements in pairs.

  198. def zip[A1 >: (A, B), B, That](that: Iterable[B])(implicit bf: CanBuildFrom[LinkedHashMap[A, B], (A1, B), That]): That

    Returns a linked hash map formed from this linked hash map and another iterable collection by combining corresponding elements in pairs.

  199. def zipAll[B](that: Iterable[B], thisElem: (A, B), thatElem: B): LinkedHashMap[((A, B), B)]

    [use case] Returns a linked hash map formed from this linked hash map and another iterable collection by combining corresponding elements in pairs.

  200. def zipAll[B, A1 >: (A, B), That](that: Iterable[B], thisElem: A1, thatElem: B)(implicit bf: CanBuildFrom[LinkedHashMap[A, B], (A1, B), That]): That

    Returns a linked hash map formed from this linked hash map and another iterable collection by combining corresponding elements in pairs.

  201. def zipWithIndex: LinkedHashMap[((A, B), Int)]

    [use case] Zips this linked hash map with its indices.

  202. def zipWithIndex[A1 >: (A, B), That](implicit bf: CanBuildFrom[LinkedHashMap[A, B], (A1, Int), That]): That

    Zips this linked hash map with its indices.