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

Showing content from https://www.scala-lang.org/api/2.13.10/scala/collection/mutable/IndexedBuffer.html below:

Scala Standard Library 2.13.10 - scala.collection.mutable.IndexedBuffer



1. Alphabetic
2. By Inheritance

1. IndexedBuffer
2. Buffer
3. Shrinkable
4. Growable
5. Clearable
6. IndexedSeq
7. IndexedSeqOps
8. IndexedSeq
9. IndexedSeqOps
10. Seq
11. SeqOps
12. Cloneable
13. Cloneable
14. Seq
15. Equals
16. SeqOps
17. PartialFunction
18. Function1
19. Iterable
20. Iterable
21. IterableFactoryDefaults
22. IterableOps
23. IterableOnceOps
24. IterableOnce
25. AnyRef
26. Any

1. by UnliftOps
2. by iterableOnceExtensionMethods
3. by any2stringadd
4. by StringFormat
5. by Ensuring
6. by ArrowAssoc

1. Public
2. Protected

1.  final def !=(arg0: Any): Boolean
2.  final def ##: Int
3.  def +(other: String): String
4.  final def ++[B >: A](suffix: IterableOnce[B]): IndexedBuffer[B]
5.  final def ++:[B >: A](prefix: IterableOnce[B]): IndexedBuffer[B]
6.  final def ++=(xs: IterableOnce[A]): IndexedBuffer.this.type
7.  final def ++=:(elems: IterableOnce[A]): IndexedBuffer.this.type
8.  final def +:[B >: A](elem: B): IndexedBuffer[B]
9.  final def +=(elem: A): IndexedBuffer.this.type
10.  final def +=:(elem: A): IndexedBuffer.this.type
11.  final def --=(xs: IterableOnce[A]): IndexedBuffer.this.type
12.  final def -=(elem: A): IndexedBuffer.this.type
13.  def ->[B](y: B): (IndexedBuffer[A], B)
14.  final def :+[B >: A](elem: B): IndexedBuffer[B]
15.  final def :++[B >: A](suffix: IterableOnce[B]): IndexedBuffer[B]
16.  final def ==(arg0: Any): Boolean
17.  def addAll(xs: IterableOnce[A]): IndexedBuffer.this.type
18.  final def addString(b: StringBuilder): b.type
19.  final def addString(b: StringBuilder, sep: String): b.type
20.  def addString(b: StringBuilder, start: String, sep: String, end: String): b.type
21.  def andThen[C](k: PartialFunction[A, C]): PartialFunction[Int, C]
22.  def andThen[C](k: (A) => C): PartialFunction[Int, C]
23.  final def append(elem: A): IndexedBuffer.this.type
24.  final def appendAll(xs: IterableOnce[A]): IndexedBuffer.this.type
25.  def appended[B >: A](elem: B): IndexedBuffer[B]
26.  def appendedAll[B >: A](suffix: IterableOnce[B]): IndexedBuffer[B]
27.  def applyOrElse[A1 <: Int, B1 >: A](x: A1, default: (A1) => B1): B1
28.  final def asInstanceOf[T0]: T0
29.  def canEqual(that: Any): Boolean
30.  def className: String
31.  def clone(): IndexedBuffer[A]
32.  final def coll: IndexedBuffer.this.type
33.  def collect[B](pf: PartialFunction[A, B]): IndexedBuffer[B]
34.  def collectFirst[B](pf: PartialFunction[A, B]): Option[B]
35.  def combinations(n: Int): Iterator[IndexedBuffer[A]]
36.  def compose[R](k: PartialFunction[R, Int]): PartialFunction[R, A]
37.  def compose[A](g: (A) => Int): (A) => A
38.  final def concat[B >: A](suffix: IterableOnce[B]): IndexedBuffer[B]
39.  def contains[A1 >: A](elem: A1): Boolean
40.  def containsSlice[B >: A](that: collection.Seq[B]): Boolean
41.  def copyToArray[B >: A](xs: Array[B], start: Int, len: Int): Int
42.  def copyToArray[B >: A](xs: Array[B], start: Int): Int
43.  def copyToArray[B >: A](xs: Array[B]): Int
44.  def corresponds[B](that: collection.Seq[B])(p: (A, B) => Boolean): Boolean
45.  def corresponds[B](that: IterableOnce[B])(p: (A, B) => Boolean): Boolean
46.  def count(p: (A) => Boolean): Int
47.  def diff[B >: A](that: collection.Seq[B]): IndexedBuffer[A]
48.  def distinct: IndexedBuffer[A]
49.  def distinctBy[B](f: (A) => B): IndexedBuffer[A]
50.  def drop(n: Int): IndexedBuffer[A]
51.  def dropInPlace(n: Int): IndexedBuffer.this.type
52.  def dropRight(n: Int): IndexedBuffer[A]
53.  def dropRightInPlace(n: Int): IndexedBuffer.this.type
54.  def dropWhile(p: (A) => Boolean): IndexedBuffer[A]
55.  def dropWhileInPlace(p: (A) => Boolean): IndexedBuffer.this.type
56.  def elementWise: ElementWiseExtractor[Int, A]
57.  def empty: IndexedBuffer[A]
58.  def endsWith[B >: A](that: collection.Iterable[B]): Boolean
59.  def ensuring(cond: (IndexedBuffer[A]) => Boolean, msg: => Any): IndexedBuffer[A]
60.  def ensuring(cond: (IndexedBuffer[A]) => Boolean): IndexedBuffer[A]
61.  def ensuring(cond: Boolean, msg: => Any): IndexedBuffer[A]
62.  def ensuring(cond: Boolean): IndexedBuffer[A]
63.  final def eq(arg0: AnyRef): Boolean
64.  def equals(o: Any): Boolean
65.  def exists(p: (A) => Boolean): Boolean
66.  def filter(pred: (A) => Boolean): IndexedBuffer[A]
67.  def filterInPlace(p: (A) => Boolean): IndexedBuffer.this.type
68.  def filterNot(pred: (A) => Boolean): IndexedBuffer[A]
69.  def finalize(): Unit
70.  def find(p: (A) => Boolean): Option[A]
71.  def findLast(p: (A) => Boolean): Option[A]
72.  def flatMap[B](f: (A) => IterableOnce[B]): IndexedBuffer[B]
73.  def flatMapInPlace(f: (A) => IterableOnce[A]): IndexedBuffer.this.type
74.  def flatten[B](implicit asIterable: (A) => IterableOnce[B]): IndexedBuffer[B]
75.  def fold[A1 >: A](z: A1)(op: (A1, A1) => A1): A1
76.  def foldLeft[B](z: B)(op: (B, A) => B): B
77.  def foldRight[B](z: B)(op: (A, B) => B): B
78.  def forall(p: (A) => Boolean): Boolean
79.  def foreach[U](f: (A) => U): Unit
80.  def fromSpecific(coll: IterableOnce[A]): IndexedBuffer[A]
81.  final def getClass(): Class[_ <: AnyRef]
82.  def groupBy[K](f: (A) => K): immutable.Map[K, IndexedBuffer[A]]
83.  def groupMap[K, B](key: (A) => K)(f: (A) => B): immutable.Map[K, IndexedBuffer[B]]
84.  def groupMapReduce[K, B](key: (A) => K)(f: (A) => B)(reduce: (B, B) => B): immutable.Map[K, B]
85.  def grouped(size: Int): Iterator[IndexedBuffer[A]]
86.  def hashCode(): Int
87.  def head: A
88.  def headOption: Option[A]
89.  def indexOf[B >: A](elem: B): Int
90.  def indexOf[B >: A](elem: B, from: Int): Int
91.  def indexOfSlice[B >: A](that: collection.Seq[B]): Int
92.  def indexOfSlice[B >: A](that: collection.Seq[B], from: Int): Int
93.  def indexWhere(p: (A) => Boolean): Int
94.  def indexWhere(p: (A) => Boolean, from: Int): Int
95.  def indices: immutable.Range
96.  def init: IndexedBuffer[A]
97.  def inits: Iterator[IndexedBuffer[A]]
98.  def intersect[B >: A](that: collection.Seq[B]): IndexedBuffer[A]
99.  def isDefinedAt(idx: Int): Boolean
100.  def isEmpty: Boolean
101.  final def isInstanceOf[T0]: Boolean
102.  def isTraversableAgain: Boolean
103.  def iterableFactory: SeqFactory[IndexedBuffer]
104.  def iterator: Iterator[A]
105.  def knownSize: Int
106.  def last: A
107.  def lastIndexOf[B >: A](elem: B, end: Int = length - 1): Int
108.  def lastIndexOfSlice[B >: A](that: collection.Seq[B]): Int
109.  def lastIndexOfSlice[B >: A](that: collection.Seq[B], end: Int): Int
110.  def lastIndexWhere(p: (A) => Boolean): Int
111.  def lastIndexWhere(p: (A) => Boolean, end: Int): Int
112.  def lastOption: Option[A]
113.  def lazyZip[B](that: collection.Iterable[B]): LazyZip2[A, B, IndexedBuffer.this.type]
114.  final def lengthCompare(that: collection.Iterable[_]): Int
115.  final def lengthCompare(len: Int): Int
116.  final def lengthIs: SizeCompareOps
117.  def lift: (Int) => Option[A]
118.  def map[B](f: (A) => B): IndexedBuffer[B]
119.  def mapInPlace(f: (A) => A): IndexedBuffer.this.type
120.  def max[B >: A](implicit ord: math.Ordering[B]): A
121.  def maxBy[B](f: (A) => B)(implicit cmp: math.Ordering[B]): A
122.  def maxByOption[B](f: (A) => B)(implicit cmp: math.Ordering[B]): Option[A]
123.  def maxOption[B >: A](implicit ord: math.Ordering[B]): Option[A]
124.  def min[B >: A](implicit ord: math.Ordering[B]): A
125.  def minBy[B](f: (A) => B)(implicit cmp: math.Ordering[B]): A
126.  def minByOption[B](f: (A) => B)(implicit cmp: math.Ordering[B]): Option[A]
127.  def minOption[B >: A](implicit ord: math.Ordering[B]): Option[A]
128.  final def mkString: String
129.  final def mkString(sep: String): String
130.  final def mkString(start: String, sep: String, end: String): String
131.  final def ne(arg0: AnyRef): Boolean
132.  def newSpecificBuilder: Builder[A, IndexedBuffer[A]]
133.  def nonEmpty: Boolean
134.  final def notify(): Unit
135.  final def notifyAll(): Unit
136.  def occCounts[B](sq: collection.Seq[B]): Map[B, Int]
137.  def orElse[A1 <: Int, B1 >: A](that: PartialFunction[A1, B1]): PartialFunction[A1, B1]
138.  def padTo[B >: A](len: Int, elem: B): IndexedBuffer[B]
139.  def padToInPlace(len: Int, elem: A): IndexedBuffer.this.type
140.  def partition(p: (A) => Boolean): (IndexedBuffer[A], IndexedBuffer[A])
141.  def partitionMap[A1, A2](f: (A) => Either[A1, A2]): (IndexedBuffer[A1], IndexedBuffer[A2])
142.  def patch[B >: A](from: Int, other: IterableOnce[B], replaced: Int): IndexedBuffer[B]
143.  def patchInPlace(from: Int, patch: IterableOnce[A], replaced: Int): IndexedBuffer.this.type
144.  def permutations: Iterator[IndexedBuffer[A]]
145.  def prependAll(elems: IterableOnce[A]): IndexedBuffer.this.type
146.  def prepended[B >: A](elem: B): IndexedBuffer[B]
147.  def prependedAll[B >: A](prefix: IterableOnce[B]): IndexedBuffer[B]
148.  def product[B >: A](implicit num: math.Numeric[B]): B
149.  def reduce[B >: A](op: (B, B) => B): B
150.  def reduceLeft[B >: A](op: (B, A) => B): B
151.  def reduceLeftOption[B >: A](op: (B, A) => B): Option[B]
152.  def reduceOption[B >: A](op: (B, B) => B): Option[B]
153.  def reduceRight[B >: A](op: (A, B) => B): B
154.  def reduceRightOption[B >: A](op: (A, B) => B): Option[B]
155.  def reverse: IndexedBuffer[A]
156.  def reverseIterator: Iterator[A]
157.  def reversed: collection.Iterable[A]
158.  def runWith[U](action: (A) => U): (Int) => Boolean
159.  def sameElements[B >: A](that: IterableOnce[B]): Boolean
160.  def scan[B >: A](z: B)(op: (B, B) => B): IndexedBuffer[B]
161.  def scanLeft[B](z: B)(op: (B, A) => B): IndexedBuffer[B]
162.  def scanRight[B](z: B)(op: (A, B) => B): IndexedBuffer[B]
163.  def search[B >: A](elem: B, from: Int, to: Int)(implicit ord: math.Ordering[B]): SearchResult
164.  def search[B >: A](elem: B)(implicit ord: math.Ordering[B]): SearchResult
165.  def segmentLength(p: (A) => Boolean, from: Int): Int
166.  final def segmentLength(p: (A) => Boolean): Int
167.  final def size: Int
168.  final def sizeCompare(that: collection.Iterable[_]): Int
169.  final def sizeCompare(otherSize: Int): Int
170.  final def sizeIs: SizeCompareOps
171.  def slice(from: Int, until: Int): IndexedBuffer[A]
172.  def sliceInPlace(start: Int, end: Int): IndexedBuffer.this.type
173.  def sliding(size: Int, step: Int): Iterator[IndexedBuffer[A]]
174.  def sliding(size: Int): Iterator[IndexedBuffer[A]]
175.  def sortBy[B](f: (A) => B)(implicit ord: Ordering[B]): IndexedBuffer[A]
176.  def sortInPlace[B >: A]()(implicit ord: Ordering[B]): IndexedBuffer.this.type
177.  def sortInPlaceBy[B](f: (A) => B)(implicit ord: Ordering[B]): IndexedBuffer.this.type
178.  def sortInPlaceWith(lt: (A, A) => Boolean): IndexedBuffer.this.type
179.  def sortWith(lt: (A, A) => Boolean): IndexedBuffer[A]
180.  def sorted[B >: A](implicit ord: Ordering[B]): IndexedBuffer[A]
181.  def span(p: (A) => Boolean): (IndexedBuffer[A], IndexedBuffer[A])
182.  def splitAt(n: Int): (IndexedBuffer[A], IndexedBuffer[A])
183.  def startsWith[B >: A](that: IterableOnce[B], offset: Int = 0): Boolean
184.  def stepper[S <: Stepper[_]](implicit shape: StepperShape[A, S]): S with EfficientSplit
185.  def stringPrefix: String
186.  def subtractAll(xs: IterableOnce[A]): IndexedBuffer.this.type
187.  def subtractOne(x: A): IndexedBuffer.this.type
188.  def sum[B >: A](implicit num: math.Numeric[B]): B
189.  final def synchronized[T0](arg0: => T0): T0
190.  def tail: IndexedBuffer[A]
191.  def tails: Iterator[IndexedBuffer[A]]
192.  def take(n: Int): IndexedBuffer[A]
193.  def takeInPlace(n: Int): IndexedBuffer.this.type
194.  def takeRight(n: Int): IndexedBuffer[A]
195.  def takeRightInPlace(n: Int): IndexedBuffer.this.type
196.  def takeWhile(p: (A) => Boolean): IndexedBuffer[A]
197.  def takeWhileInPlace(p: (A) => Boolean): IndexedBuffer.this.type
198.  def tapEach[U](f: (A) => U): IndexedBuffer[A]
199.  def to[C1](factory: Factory[A, C1]): C1
200.  def toArray[B >: A](implicit arg0: ClassTag[B]): Array[B]
201.  final def toBuffer[B >: A]: Buffer[B]
202.  def toIndexedSeq: immutable.IndexedSeq[A]
203.  def toList: immutable.List[A]
204.  def toMap[K, V](implicit ev: <:<[A, (K, V)]): immutable.Map[K, V]
205.  def toSeq: immutable.Seq[A]
206.  def toSet[B >: A]: immutable.Set[B]
207.  def toString(): String
208.  def toVector: immutable.Vector[A]
209.  def transpose[B](implicit asIterable: (A) => collection.Iterable[B]): IndexedBuffer[IndexedBuffer[B]]
210.  def unapply(a: Int): Option[A]
211.  def unlift: PartialFunction[Int, B]
212.  def unzip[A1, A2](implicit asPair: (A) => (A1, A2)): (IndexedBuffer[A1], IndexedBuffer[A2])
213.  def unzip3[A1, A2, A3](implicit asTriple: (A) => (A1, A2, A3)): (IndexedBuffer[A1], IndexedBuffer[A2], IndexedBuffer[A3])
214.  def updated[B >: A](index: Int, elem: B): IndexedBuffer[B]
215.  def view: IndexedSeqView[A]
216.  final def wait(): Unit
217.  final def wait(arg0: Long, arg1: Int): Unit
218.  final def wait(arg0: Long): Unit
219.  def withFilter(p: (A) => Boolean): WithFilter[A, [_]IndexedBuffer[_]]
220.  def zip[B](that: IterableOnce[B]): IndexedBuffer[(A, B)]
221.  def zipAll[A1 >: A, B](that: collection.Iterable[B], thisElem: A1, thatElem: B): IndexedBuffer[(A1, B)]
222.  def zipWithIndex: IndexedBuffer[(A, Int)]

1.  final def +=(elem1: A, elem2: A, elems: A*): IndexedBuffer.this.type
2.  def -=(elem1: A, elem2: A, elems: A*): IndexedBuffer.this.type
3.  def /:[B](z: B)(op: (B, A) => B): B
4.  final def /:[B](z: B)(op: (B, A) => B): B
5.  def :\[B](z: B)(op: (A, B) => B): B
6.  final def :\[B](z: B)(op: (A, B) => B): B
7.  def aggregate[B](z: => B)(seqop: (B, A) => B, combop: (B, B) => B): B
8.  final def append(elems: A*): IndexedBuffer.this.type
9.  def collectFirst[B](f: PartialFunction[A, B]): Option[B]
10.  def companion: IterableFactory[[_]IndexedBuffer[_]]
11.  def copyToBuffer(dest: Buffer[A]): Unit
12.  final def copyToBuffer[B >: A](dest: Buffer[B]): Unit
13.  def count(f: (A) => Boolean): Int
14.  def exists(f: (A) => Boolean): Boolean
15.  def filter(f: (A) => Boolean): Iterator[A]
16.  def find(p: (A) => Boolean): Option[A]
17.  def flatMap[B](f: (A) => IterableOnce[B]): IterableOnce[B]
18.  def fold[A1 >: A](z: A1)(op: (A1, A1) => A1): A1
19.  def foldLeft[B](z: B)(op: (B, A) => B): B
20.  def foldRight[B](z: B)(op: (A, B) => B): B
21.  def forall(f: (A) => Boolean): Boolean
22.  def foreach[U](f: (A) => U): Unit
23.  def formatted(fmtstr: String): String
24.  def hasDefiniteSize: Boolean
25.  def isEmpty: Boolean
26.  def map[B](f: (A) => B): IterableOnce[B]
27.  def max(implicit ord: math.Ordering[A]): A
28.  def maxBy[B](f: (A) => B)(implicit cmp: math.Ordering[B]): A
29.  def min(implicit ord: math.Ordering[A]): A
30.  def minBy[B](f: (A) => B)(implicit cmp: math.Ordering[B]): A
31.  def mkString: String
32.  def mkString(sep: String): String
33.  def mkString(start: String, sep: String, end: String): String
34.  def nonEmpty: Boolean
35.  final def prefixLength(p: (A) => Boolean): Int
36.  final def prepend(elems: A*): IndexedBuffer.this.type
37.  def product(implicit num: math.Numeric[A]): A
38.  def reduce(f: (A, A) => A): A
39.  def reduceLeft(f: (A, A) => A): A
40.  def reduceLeftOption(f: (A, A) => A): Option[A]
41.  def reduceOption(f: (A, A) => A): Option[A]
42.  def reduceRight(f: (A, A) => A): A
43.  def reduceRightOption(f: (A, A) => A): Option[A]
44.  final def repr: IndexedBuffer[A]
45.  def reverseMap[B](f: (A) => B): IndexedBuffer[B]
46.  def sameElements[B >: A](that: IterableOnce[B]): Boolean
47.  def seq: IndexedBuffer.this.type
48.  def size: Int
49.  def sum(implicit num: math.Numeric[A]): A
50.  def to[C1](factory: Factory[A, C1]): C1
51.  def toArray[B >: A](implicit arg0: ClassTag[B]): Array[B]
52.  def toBuffer[B >: A]: Buffer[B]
53.  def toIndexedSeq: collection.IndexedSeq[A]
54.  final def toIterable: collection.Iterable[A]
55.  final def toIterable: IndexedBuffer.this.type
56.  def toIterator: Iterator[A]
57.  final def toIterator: Iterator[A]
58.  def toList: immutable.List[A]
59.  def toMap[K, V](implicit ev: <:<[A, (K, V)]): immutable.Map[K, V]
60.  def toSeq: immutable.Seq[A]
61.  def toSet[B >: A]: immutable.Set[B]
62.  def toStream: immutable.Stream[A]
63.  final def toStream: immutable.Stream[A]
64.  final def toTraversable: collection.Traversable[A]
65.  final def toTraversable: collection.Traversable[A]
66.  def toVector: immutable.Vector[A]
67.  final def transform(f: (A) => A): IndexedBuffer.this.type
68.  def trimEnd(n: Int): Unit
69.  def trimStart(n: Int): Unit
70.  final def union[B >: A](that: collection.Seq[B]): IndexedBuffer[B]
71.  def view(from: Int, until: Int): IndexedSeqView[A]
72.  def withFilter(f: (A) => Boolean): Iterator[A]
73.  def →[B](y: B): (IndexedBuffer[A], B)

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