Scala Standard Library 2.13.1 - 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): mutable.StringBuilder
8.  final def addString(b: mutable.StringBuilder, sep: String): mutable.StringBuilder
9.  def addString(b: mutable.StringBuilder, start: String, sep: String, end: String): mutable.StringBuilder
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.  def formatted(fmtstr: String): String
46.  final def getClass(): Class[_ <: AnyRef]
47.  def grouped[B >: A](size: Int): GroupedIterator[B]
48.  def hashCode(): Int
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)]

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.  final def hasDefiniteSize: Boolean
20.  def isEmpty: Boolean
21.  def map[B](f: (A) => B): IterableOnce[B]
22.  def max(implicit ord: math.Ordering[A]): A
23.  def maxBy[B](f: (A) => B)(implicit cmp: math.Ordering[B]): A
24.  def min(implicit ord: math.Ordering[A]): A
25.  def minBy[B](f: (A) => B)(implicit cmp: math.Ordering[B]): A
26.  def mkString: String
27.  def mkString(sep: String): String
28.  def mkString(start: String, sep: String, end: String): String
29.  def nonEmpty: Boolean
30.  def product(implicit num: math.Numeric[A]): A
31.  def reduce(f: (A, A) => A): A
32.  def reduceLeft(f: (A, A) => A): A
33.  def reduceLeftOption(f: (A, A) => A): Option[A]
34.  def reduceOption(f: (A, A) => A): Option[A]
35.  def reduceRight(f: (A, A) => A): A
36.  def reduceRightOption(f: (A, A) => A): Option[A]
37.  def sameElements[B >: A](that: IterableOnce[B]): Boolean
38.  def scanRight[B](z: B)(op: (A, B) => B): Iterator[B]
39.  def seq: Iterator.this.type
40.  def size: Int
41.  def sum(implicit num: math.Numeric[A]): A
42.  def to[C1](factory: Factory[A, C1]): C1
43.  def toArray[B >: A](implicit arg0: ClassTag[B]): Array[B]
44.  def toBuffer[B >: A]: Buffer[B]
45.  def toIndexedSeq: IndexedSeq[A]
46.  final def toIterable: Iterable[A]
47.  def toIterator: Iterator[A]
48.  final def toIterator: Iterator[A]
49.  def toList: immutable.List[A]
50.  def toMap[K, V](implicit ev: <:<[A, (K, V)]): immutable.Map[K, V]
51.  def toSeq: immutable.Seq[A]
52.  def toSet[B >: A]: immutable.Set[B]
53.  def toStream: immutable.Stream[A]
54.  final def toStream: immutable.Stream[A]
55.  final def toTraversable: Traversable[A]
56.  def toVector: immutable.Vector[A]
57.  def withFilter(f: (A) => Boolean): Iterator[A]
58.  def →[B](y: B): (Iterator[A], B)

Ungrouped