Scala Standard Library 2.13.15 - scala.collection.Iterator (original) (raw)

trait Iterator[+A] extends IterableOnce[A] with IterableOnceOps[A, Iterator, Iterator[A]]

 

Ordering

1. Alphabetic
2. By Inheritance

Inherited

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

Implicitly

1. by iterableOnceExtensionMethods

2. by any2stringadd

3. by StringFormat

4. by Ensuring

5. by ArrowAssoc

6. Hide All

7. Show All

Visibility

1. Public
2. Protected

Abstract Value Members

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

Concrete Value Members

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): (Iterator[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[A]
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: (Iterator[A]) => Boolean, msg: => Any): Iterator[A]
28.  def ensuring(cond: (Iterator[A]) => Boolean): Iterator[A]
29.  def ensuring(cond: Boolean, msg: => Any): Iterator[A]
30.  def ensuring(cond: Boolean): Iterator[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 indexOf[B >: A](elem: B, from: Int): Int
49.  def indexOf[B >: A](elem: B): Int
50.  def indexWhere(p: (A) => Boolean, from: Int = 0): Int
51.  def isEmpty: Boolean
52.  final def isInstanceOf[T0]: Boolean
53.  def isTraversableAgain: Boolean
54.  final def iterator: Iterator[A]
55.  def knownSize: Int
56.  final def length: Int
57.  def map[B](f: (A) => B): Iterator[B]
58.  def max[B >: A](implicit ord: math.Ordering[B]): A
59.  def maxBy[B](f: (A) => B)(implicit ord: math.Ordering[B]): A
60.  def maxByOption[B](f: (A) => B)(implicit ord: math.Ordering[B]): Option[A]
61.  def maxOption[B >: A](implicit ord: math.Ordering[B]): Option[A]
62.  def min[B >: A](implicit ord: math.Ordering[B]): A
63.  def minBy[B](f: (A) => B)(implicit ord: math.Ordering[B]): A
64.  def minByOption[B](f: (A) => B)(implicit ord: math.Ordering[B]): Option[A]
65.  def minOption[B >: A](implicit ord: math.Ordering[B]): Option[A]
66.  final def mkString: String
67.  final def mkString(sep: String): String
68.  final def mkString(start: String, sep: String, end: String): String
69.  final def ne(arg0: AnyRef): Boolean
70.  def nextOption(): Option[A]
71.  def nonEmpty: Boolean
72.  final def notify(): Unit
73.  final def notifyAll(): Unit
74.  def padTo[B >: A](len: Int, elem: B): Iterator[B]
75.  def partition(p: (A) => Boolean): (Iterator[A], Iterator[A])
76.  def patch[B >: A](from: Int, patchElems: Iterator[B], replaced: Int): Iterator[B]
77.  def product[B >: A](implicit num: math.Numeric[B]): B
78.  def reduce[B >: A](op: (B, B) => B): B
79.  def reduceLeft[B >: A](op: (B, A) => B): B
80.  def reduceLeftOption[B >: A](op: (B, A) => B): Option[B]
81.  def reduceOption[B >: A](op: (B, B) => B): Option[B]
82.  def reduceRight[B >: A](op: (A, B) => B): B
83.  def reduceRightOption[B >: A](op: (A, B) => B): Option[B]
84.  def reversed: Iterable[A]
85.  def sameElements[B >: A](that: IterableOnce[B]): Boolean
86.  def scanLeft[B](z: B)(op: (B, A) => B): Iterator[B]
87.  def size: Int
88.  def slice(from: Int, until: Int): Iterator[A]
89.  def sliceIterator(from: Int, until: Int): Iterator[A]
90.  def sliding[B >: A](size: Int, step: Int = 1): GroupedIterator[B]
91.  def span(p: (A) => Boolean): (Iterator[A], Iterator[A])
92.  def splitAt(n: Int): (Iterator[A], Iterator[A])
93.  def stepper[S <: Stepper[_]](implicit shape: StepperShape[A, S]): S
94.  def sum[B >: A](implicit num: math.Numeric[B]): B
95.  final def synchronized[T0](arg0: => T0): T0
96.  def take(n: Int): Iterator[A]
97.  def takeWhile(p: (A) => Boolean): Iterator[A]
98.  def tapEach[U](f: (A) => U): Iterator[A]
99.  def to[C1](factory: Factory[A, C1]): C1
100.  def toArray[B >: A](implicit arg0: ClassTag[B]): Array[B]
101.  final def toBuffer[B >: A]: Buffer[B]
102.  def toIndexedSeq: immutable.IndexedSeq[A]
103.  def toList: immutable.List[A]
104.  def toMap[K, V](implicit ev: <:<[A, (K, V)]): immutable.Map[K, V]
105.  def toSeq: immutable.Seq[A]
106.  def toSet[B >: A]: immutable.Set[B]
107.  def toString(): String
108.  def toVector: immutable.Vector[A]
109.  final def wait(): Unit
110.  final def wait(arg0: Long, arg1: Int): Unit
111.  final def wait(arg0: Long): Unit
112.  def withFilter(p: (A) => Boolean): Iterator[A]
113.  def zip[B](that: IterableOnce[B]): Iterator[(A, B)]
114.  def zipAll[A1 >: A, B](that: IterableOnce[B], thisElem: A1, thatElem: B): Iterator[(A1, B)]
115.  def zipWithIndex: Iterator[(A, Int)]

Deprecated Value Members

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: Iterator.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): (Iterator[A], B)

Ungrouped