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

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

Scala Standard Library 2.13.10 - scala.collection.BufferedIterator



1. Alphabetic
2. By Inheritance

1. BufferedIterator
2. Iterator
3. IterableOnceOps
4. IterableOnce
5. AnyRef
6. Any

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

1. Public
2. Protected

1.  abstract def hasNext: Boolean
2.  abstract def head: A
3.  abstract def next(): A

1.  final def !=(arg0: Any): Boolean
2.  final def ##: Int
3.  def +(other: String): String
4.  final def ++[B >: A](xs: => IterableOnce[B]): Iterator[B]
5.  def ->[B](y: B): (BufferedIterator[A], B)
6.  final def ==(arg0: Any): Boolean
7.  final def addString(b: mutable.StringBuilder): b.type
8.  final def addString(b: mutable.StringBuilder, sep: String): b.type
9.  def addString(b: mutable.StringBuilder, start: String, sep: String, end: String): b.type
10.  final def asInstanceOf[T0]: T0
11.  def buffered: BufferedIterator.this.type
12.  def clone(): AnyRef
13.  def collect[B](pf: PartialFunction[A, B]): Iterator[B]
14.  def collectFirst[B](pf: PartialFunction[A, B]): Option[B]
15.  def concat[B >: A](xs: => IterableOnce[B]): Iterator[B]
16.  def contains(elem: Any): Boolean
17.  def copyToArray[B >: A](xs: Array[B], start: Int, len: Int): Int
18.  def copyToArray[B >: A](xs: Array[B], start: Int): Int
19.  def copyToArray[B >: A](xs: Array[B]): Int
20.  def corresponds[B](that: IterableOnce[B])(p: (A, B) => Boolean): Boolean
21.  def count(p: (A) => Boolean): Int
22.  def distinct: Iterator[A]
23.  def distinctBy[B](f: (A) => B): Iterator[A]
24.  def drop(n: Int): Iterator[A]
25.  def dropWhile(p: (A) => Boolean): Iterator[A]
26.  def duplicate: (Iterator[A], Iterator[A])
27.  def ensuring(cond: (BufferedIterator[A]) => Boolean, msg: => Any): BufferedIterator[A]
28.  def ensuring(cond: (BufferedIterator[A]) => Boolean): BufferedIterator[A]
29.  def ensuring(cond: Boolean, msg: => Any): BufferedIterator[A]
30.  def ensuring(cond: Boolean): BufferedIterator[A]
31.  final def eq(arg0: AnyRef): Boolean
32.  def equals(arg0: AnyRef): Boolean
33.  def exists(p: (A) => Boolean): Boolean
34.  def filter(p: (A) => Boolean): Iterator[A]
35.  def filterNot(p: (A) => Boolean): Iterator[A]
36.  def finalize(): Unit
37.  def find(p: (A) => Boolean): Option[A]
38.  def flatMap[B](f: (A) => IterableOnce[B]): Iterator[B]
39.  def flatten[B](implicit ev: (A) => IterableOnce[B]): Iterator[B]
40.  def fold[A1 >: A](z: A1)(op: (A1, A1) => A1): A1
41.  def foldLeft[B](z: B)(op: (B, A) => B): B
42.  def foldRight[B](z: B)(op: (A, B) => B): B
43.  def forall(p: (A) => Boolean): Boolean
44.  def foreach[U](f: (A) => U): Unit
45.  final def getClass(): Class[_ <: AnyRef]
46.  def grouped[B >: A](size: Int): GroupedIterator[B]
47.  def hashCode(): Int
48.  def headOption: Option[A]
49.  def indexOf[B >: A](elem: B, from: Int): Int
50.  def indexOf[B >: A](elem: B): Int
51.  def indexWhere(p: (A) => Boolean, from: Int = 0): Int
52.  def isEmpty: Boolean
53.  final def isInstanceOf[T0]: Boolean
54.  def isTraversableAgain: Boolean
55.  final def iterator: Iterator[A]
56.  def knownSize: Int
57.  final def length: Int
58.  def map[B](f: (A) => B): Iterator[B]
59.  def max[B >: A](implicit ord: math.Ordering[B]): A
60.  def maxBy[B](f: (A) => B)(implicit cmp: math.Ordering[B]): A
61.  def maxByOption[B](f: (A) => B)(implicit cmp: math.Ordering[B]): Option[A]
62.  def maxOption[B >: A](implicit ord: math.Ordering[B]): Option[A]
63.  def min[B >: A](implicit ord: math.Ordering[B]): A
64.  def minBy[B](f: (A) => B)(implicit cmp: math.Ordering[B]): A
65.  def minByOption[B](f: (A) => B)(implicit cmp: math.Ordering[B]): Option[A]
66.  def minOption[B >: A](implicit ord: math.Ordering[B]): Option[A]
67.  final def mkString: String
68.  final def mkString(sep: String): String
69.  final def mkString(start: String, sep: String, end: String): String
70.  final def ne(arg0: AnyRef): Boolean
71.  def nextOption(): Option[A]
72.  def nonEmpty: Boolean
73.  final def notify(): Unit
74.  final def notifyAll(): Unit
75.  def padTo[B >: A](len: Int, elem: B): Iterator[B]
76.  def partition(p: (A) => Boolean): (Iterator[A], Iterator[A])
77.  def patch[B >: A](from: Int, patchElems: Iterator[B], replaced: Int): Iterator[B]
78.  def product[B >: A](implicit num: math.Numeric[B]): B
79.  def reduce[B >: A](op: (B, B) => B): B
80.  def reduceLeft[B >: A](op: (B, A) => B): B
81.  def reduceLeftOption[B >: A](op: (B, A) => B): Option[B]
82.  def reduceOption[B >: A](op: (B, B) => B): Option[B]
83.  def reduceRight[B >: A](op: (A, B) => B): B
84.  def reduceRightOption[B >: A](op: (A, B) => B): Option[B]
85.  def reversed: Iterable[A]
86.  def sameElements[B >: A](that: IterableOnce[B]): Boolean
87.  def scanLeft[B](z: B)(op: (B, A) => B): Iterator[B]
88.  def size: Int
89.  def slice(from: Int, until: Int): Iterator[A]
90.  def sliceIterator(from: Int, until: Int): Iterator[A]
91.  def sliding[B >: A](size: Int, step: Int = 1): GroupedIterator[B]
92.  def span(p: (A) => Boolean): (Iterator[A], Iterator[A])
93.  def splitAt(n: Int): (Iterator[A], Iterator[A])
94.  def stepper[S <: Stepper[_]](implicit shape: StepperShape[A, S]): S
95.  def sum[B >: A](implicit num: math.Numeric[B]): B
96.  final def synchronized[T0](arg0: => T0): T0
97.  def take(n: Int): Iterator[A]
98.  def takeWhile(p: (A) => Boolean): Iterator[A]
99.  def tapEach[U](f: (A) => U): Iterator[A]
100.  def to[C1](factory: Factory[A, C1]): C1
101.  def toArray[B >: A](implicit arg0: ClassTag[B]): Array[B]
102.  final def toBuffer[B >: A]: Buffer[B]
103.  def toIndexedSeq: immutable.IndexedSeq[A]
104.  def toList: immutable.List[A]
105.  def toMap[K, V](implicit ev: <:<[A, (K, V)]): immutable.Map[K, V]
106.  def toSeq: immutable.Seq[A]
107.  def toSet[B >: A]: immutable.Set[B]
108.  def toString(): String
109.  def toVector: immutable.Vector[A]
110.  final def wait(): Unit
111.  final def wait(arg0: Long, arg1: Int): Unit
112.  final def wait(arg0: Long): Unit
113.  def withFilter(p: (A) => Boolean): Iterator[A]
114.  def zip[B](that: IterableOnce[B]): Iterator[(A, B)]
115.  def zipAll[A1 >: A, B](that: IterableOnce[B], thisElem: A1, thatElem: B): Iterator[(A1, B)]
116.  def zipWithIndex: Iterator[(A, Int)]

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