Класс Iterator.GroupedIterator

class GroupedIterator[B >: A](self: Iterator[B], size: Int, step: Int) extends AbstractIterator[Seq[B]]

Гибкий итератор для преобразования Iterator[A] в Iterator[Seq[A]] с настраиваемыми размером последовательности, шагом и стратегией обработки элементов, которые не делятся равномерно.

Типичные применения могут быть реализованы с помощью методов grouped и sliding.

Наследованные классы

Исходный код

class GroupedIterator[B >: A](self: Iterator[B], size: Int, step: Int) extends AbstractIterator[Seq[B]]

Гибкий итератор для преобразования Iterator[A] в Iterator[Seq[A]] с настраиваемыми размером последовательности, шагом и стратегией обработки элементов, которые не делятся равномерно.

Типичные применения могут быть реализованы с помощью методов grouped и sliding.

Конкретные методы

Исходный код

def hasNext: Boolean

Проверка наличия следующего элемента.

Исходный код

def next(): Seq[B]

Возвращает следующий элемент и продвигает итератор.

Исходный код

def withPadding(x: => B): GroupedIterator.this.type

Публичные функции, которые могут быть использованы для настройки итератора перед его применением.

Заполняет последний сегмент при необходимости, чтобы все сегменты имели одинаковый размер.

Исходный код

def withPartial(x: Boolean): GroupedIterator.this.type

Публичные функции, которые могут быть использованы для настройки итератора перед его применением.

Выбирает, может ли последний сегмент возвращаться с менее чем size элементами. В противном случае некоторые элементы исходного итератора могут вообще не быть возвращены.

Наследованные методы

Исходный код

final def ++[B >: Seq[B]](xs: => IterableOnce[B]): Iterator[B]

Исходный код

final def addString(b: StringBuilder): StringBuilder

Добавляет все элементы этой коллекции в строковый билдер. Записанный текст состоит из строковых представлений (относительно метода toString) всех элементов этой коллекции без разделительной строки.

Пример:

scala> val a = List(1,2,3,4)
a: List[Int] = List(1, 2, 3, 4)

scala> val b = new StringBuilder()
b: StringBuilder =

scala> val h = a.addString(b)
h: StringBuilder = 1234

Исходный код

final def addString(b: StringBuilder, sep: String): StringBuilder

Добавляет все элементы этой коллекции в строковый билдер с использованием разделительной строки. Записанный текст состоит из строковых представлений (относительно метода toString) всех элементов этой коллекции, разделенных строкой sep.

Пример:

scala> val a = List(1,2,3,4)
a: List[Int] = List(1, 2, 3, 4)

scala> val b = new StringBuilder()
b: StringBuilder =

scala> a.addString(b, ", ")
res0: StringBuilder = 1, 2, 3, 4

Исходный код

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

Добавляет все элементы этой коллекции в строковый билдер с использованием начальной, конечной и разделительной строк. Записанный текст начинается со строки start и заканчивается строкой end. Внутри, строковые представления (относительно метода toString) всех элементов этой коллекции разделены строкой sep.

Пример:

scala> val a = List(1,2,3,4)
a: List[Int] = List(1, 2, 3, 4)

scala> val b = new StringBuilder()
b: StringBuilder =

scala> a.addString(b , "List(" , ", " , ")")
res5: StringBuilder = List(1, 2, 3, 4)

Исходный код

def buffered: BufferedIterator[A]

Создает буферизированный итератор из этого итератора.

Исходный код

def collect[B](pf: PartialFunction[Seq[B], B]): Iterator[B]

Создаёт новый итератор, применяя частичную функцию ко всем элементам этого итератора, для которых функция определена.

Источник

def collectFirst[B](pf: PartialFunction[Seq[B], B]): Option[B]

Находит первый элемент коллекции, для которого заданная частичная функция определена, и применяет частичную функцию к нему.

Примечание: может не завершаться для коллекций бесконечного размера.

Примечание: может возвращать разные результаты для разных запусков, если тип базовой коллекции не упорядочен.

Источник

def concat[B >: Seq[B]](xs: => IterableOnce[B]): Iterator[B]

Источник

def contains(elem: Any): Boolean

Проверяет, содержит ли этот итератор данное значение в качестве элемента.

Примечание: может не завершаться для бесконечных итераторов.

Источник

def copyToArray[B >: Seq[B]](xs: Array[B], start: Int, len: Int): Int

Копирует элементы в массив, возвращая количество скопированных элементов.

Заполняет заданный массив xs начиная с индекса start не более чем len элементами этой коллекции.

Копирование прекращается, когда скопированы все элементы этой коллекции, достигнут конец массива или len элементов скопированы.

Источник

def copyToArray[B >: Seq[B]](xs: Array[B], start: Int): Int

Копирует элементы в массив, возвращая количество записанных элементов.

Заполняет заданный массив xs начиная с индекса start значениями этой коллекции.

Копирование прекратится, когда будут скопированы все элементы этого набора или будет достигнут конец массива.

Исходный код

def copyToArray[B >: Seq[B]](xs: Array[B]): Int

Копирует элементы в массив, возвращая количество скопированных элементов.

Заполняет заданный массив xs начиная с индекса start значениями из этого набора.

Копирование прекратится, когда будут скопированы все элементы этого набора или будет достигнут конец массива.

Исходный код

def corresponds[B](that: IterableOnce[B])(p: (Seq[B], B) => Boolean): Boolean

Проверяет, соответствует ли каждый элемент итератора этого набора соответствующему элементу другого набора, удовлетворяя условию предиката.

Примечание: не завершается для наборов бесконечной длины.

Исходный код

def count(p: Seq[B] => Boolean): Int

Подсчитывает количество элементов в наборе, удовлетворяющих предикату.

Примечание: не завершается для наборов бесконечной длины.

Исходный код

def distinct: Iterator[A]

Создаёт новый итератор из этого без дублируемых элементов.

Исходный код

def distinctBy[B](f: Seq[B] => B): Iterator[A]

Создаёт новый итератор из этого, исключая дубликаты, определяемые по == после применения преобразования f.

Источник

def drop(n: Int): Iterator[A]

Выбирает все элементы, кроме первых n.

Примечание: может возвращать разные результаты при разных запусках, если тип базового набора не упорядочен.

Источник

def dropWhile(p: Seq[B] => Boolean): Iterator[A]

Опускает самый длинный префикс элементов, удовлетворяющих предикату.

Примечание: может возвращать разные результаты при разных запусках, если тип базового набора не упорядочен.

Источник

def duplicate: (Iterator[A], Iterator[A])

Создает два новых итератора, которые оба итерируют по тем же элементам, что и этот итератор (в том же порядке). Дублированные итераторы считаются равными, если они находятся на одном элементе.

Учитывая, что большинство методов для итераторов сделают исходный итератор непригодным для дальнейшего использования, этот метод предоставляет надежный способ вызова нескольких таких методов для итератора.

Источник

def exists(p: Seq[B] => Boolean): Boolean

Проверяет, выполняется ли предикат хотя бы для одного элемента этого набора.

Примечание: может не завершиться для наборов бесконечной длины.

Источник

def filter(p: Seq[B] => Boolean): Iterator[A]

Выбирает все элементы этого итератора, которые удовлетворяют предикату.

Источник

def filterNot(p: Seq[B] => Boolean): Iterator[A]

Выбирает все элементы этого итератора, которые не удовлетворяют предикату.

Источник

def find(p: Seq[B] => Boolean): Option[A]

Находит первый элемент набора, удовлетворяющий предикату, если он существует.

Примечание: может не завершиться для наборов бесконечной длины.

Примечание: может возвращать разные результаты при разных запусках, если тип базового набора упорядочен.

Источник

def flatMap[B](f: Seq[B] => IterableOnce[B]): Iterator[B]

Создает новый итератор, применяя функцию ко всем элементам этого итератора и используя элементы полученных коллекций.

Например:

def getWords(lines: Seq[String]): Seq[String] = lines flatMap (line => line split "\\W+")

Тип результирующей коллекции определяется статическим типом итератора. Это иногда может приводить к неожиданным результатам. Например:

// lettersOf will return a Seq[Char] of likely repeated letters, instead of a Set
def lettersOf(words: Seq[String]) = words flatMap (word => word.toSet)

// lettersOf will return a Set[Char], not a Seq
def lettersOf(words: Seq[String]) = words.toSet flatMap ((word: String) => word.toSeq)

// xs will be an Iterable[Int]
val xs = Map("a" -> List(11,111), "b" -> List(22,222)).flatMap(_._2)

// ys will be a Map[Int, Int]
val ys = Map("a" -> List(1 -> 11,1 -> 111), "b" -> List(2 -> 22,2 -> 222)).flatMap(_._2)

Источник

def flatten[B](implicit ev: Seq[B] => IterableOnce[B]): Iterator[B]

Преобразует этот итератор коллекций в итератор, образованный элементами этих коллекций.

Тип результирующей коллекции определяется типом итератора. Например:

val xs = List(
           Set(1, 2, 3),
           Set(1, 2, 3)
         ).flatten
// xs == List(1, 2, 3, 1, 2, 3)

val ys = Set(
           List(1, 2, 3),
           List(3, 2, 1)
         ).flatten
// ys == Set(1, 2, 3)

Источник

def fold[A1 >: Seq[B]](z: A1)(op: (A1, A1) => A1): A1

Складывает элементы этой коллекции, используя заданный ассоциативный бинарный оператор. Реализация по умолчанию в IterableOnce эквивалентна foldLeft, но может быть переопределена для более эффективного порядка обхода.

Порядок выполнения операций над элементами не определен и может быть не детерминированным.

Примечание: не завершится для наборов бесконечной длины.

Источник

def foldLeft[B](z: B)(op: (B, Seq[B]) => B): B

Применяет бинарный оператор к начальному значению и всем элементам этого набора, слева направо.

Примечание: не завершится для наборов бесконечного размера.

Примечание: может возвращать разные результаты для разных запусков, если тип базового набора не упорядочен или оператор не ассоциативен и коммутативен.

Источник

def foldRight[B](z: B)(op: (Seq[B], B) => B): B

Применяет бинарный оператор ко всем элементам этого набора и начальному значению, справа налево.

Примечание: не завершится для наборов бесконечного размера.

Примечание: может возвращать разные результаты для разных запусков, если тип базового набора упорядочен или оператор ассоциативен и коммутативен.

Источник

def forall(p: Seq[B] => Boolean): Boolean

Проверяет, выполняется ли предикат для всех элементов этого набора.

Примечание: может не завершиться для наборов бесконечного размера.

Источник

def foreach[U](f: Seq[B] => U): Unit

Применяет f к каждому элементу для его побочных эффектов. Примечание: параметр [U] необходим для помощи в инференции типов scalac.

Источник

def grouped[B >: Seq[B]](size: Int): GroupedIterator[B]

Возвращает итератор, который группирует этот итератор в блоки фиксированного размера. Примеры использования:

// Returns List(List(1, 2, 3), List(4, 5, 6), List(7)))
(1 to 7).iterator.grouped(3).toList
// Returns List(List(1, 2, 3), List(4, 5, 6))
(1 to 7).iterator.grouped(3).withPartial(false).toList
// Returns List(List(1, 2, 3), List(4, 5, 6), List(7, 20, 25)
// Illustrating that withPadding's argument is by-name.
val it2 = Iterator.iterate(20)(_ + 5)
(1 to 7).iterator.grouped(3).withPadding(it2.next).toList

Источник

def indexOf[B >: Seq[B]](elem: B, from: Int): Int

Возвращает индекс первого вхождения указанного объекта в этом итерируемом объекте после или на некотором начальном индексе.

Примечание: может не завершиться для бесконечных итераторов.

Источник

def indexOf[B >: Seq[B]](elem: B): Int

Возвращает индекс первого вхождения указанного объекта в этом итерируемом объекте.

Примечание: может не завершиться для бесконечных итераторов.

Источник

def indexWhere(p: Seq[B] => Boolean, from: Int): Int

Источник

override def isEmpty: Boolean

Проверяет, пуст ли итератор.

Примечание: Реализации в подклассах, которые не являются многократно проходимыми, должны следить за тем, чтобы не потреблять какие-либо элементы, когда isEmpty вызывается.

Источник

def isTraversableAgain: Boolean

Проверяет, можно ли многократно пройти этот набор. Всегда true для Iterables и false для Iterators, если не переопределено.

Источник

final def iterator: Iterator[A]

Итератор может быть использован только один раз

Источник

def knownSize: Int

Источник

final def length: Int

Источник

def map[B](f: Seq[B] => B): Iterator[B]

Создает новый итератор, применяя функцию ко всем элементам этого итератора.

Источник

def max[B >: Seq[B]](implicit ord: Ordering[B]): A

Находит наибольший элемент.

Примечание: не завершит работу для коллекций бесконечного размера.

Источник

def maxBy[B](f: Seq[B] => B)(implicit cmp: Ordering[B]): A

Находит первый элемент, который даёт наибольшее значение, измеряемое функцией f.

Примечание: не завершит работу для коллекций бесконечного размера.

Источник

def maxByOption[B](f: Seq[B] => B)(implicit cmp: Ordering[B]): Option[A]

Находит первый элемент, который даёт наибольшее значение, измеряемое функцией f.

Примечание: не завершит работу для коллекций бесконечного размера.

Источник

def maxOption[B >: Seq[B]](implicit ord: Ordering[B]): Option[A]

Находит наибольший элемент.

Примечание: не завершится для коллекций бесконечного размера.

Источник

def min[B >: Seq[B]](implicit ord: Ordering[B]): A

Находит наименьший элемент.

Примечание: не завершится для коллекций бесконечного размера.

Источник

def minBy[B](f: Seq[B] => B)(implicit cmp: Ordering[B]): A

Находит первый элемент, который дает наименьшее значение, измеренное функцией f.

Примечание: не завершится для коллекций бесконечного размера.

Источник

def minByOption[B](f: Seq[B] => B)(implicit cmp: Ordering[B]): Option[A]

Находит первый элемент, который дает наименьшее значение, измеренное функцией f.

Примечание: не завершится для коллекций бесконечного размера.

Источник

def minOption[B >: Seq[B]](implicit ord: Ordering[B]): Option[A]

Находит наименьший элемент.

Примечание: не завершится для коллекций бесконечного размера.

Источник

final def mkString: String

Отображает все элементы этой коллекции в строке.

Делегирует вызов addString, который можно переопределить.

Source

final def mkString(sep: String): String

Отображает все элементы этого набора в строке с использованием разделительной строки.

Делегирует вызов addString, который можно переопределить.

Source

final def mkString(start: String, sep: String, end: String): String

Отображает все элементы этого набора в строке с использованием начальной, конечной и разделительной строк.

Делегирует вызов addString, который можно переопределить.

Source

def nextOption(): Option[A]

Оборачивает значение next() в опцию.

Source

def nonEmpty: Boolean

Проверяет, не пуст ли набор.

Source

def padTo[B >: Seq[B]](len: Int, elem: B): Iterator[B]

Копия этого итератора с добавленным элементом до тех пор, пока не будет достигнута заданная целевая длина.

Source

def partition(p: Seq[B] => Boolean): (Iterator[A], Iterator[A])

Разделяет этот итератор на два итератора в соответствии с предикатом.

Source

def patch[B >: Seq[B]](from: Int, patchElems: Iterator[B], replaced: Int): Iterator[B]

Возвращает этот итератор с изменёнными значениями.

Source

def product[B >: Seq[B]](implicit num: Numeric[B]): B

Умножает элементы этого набора.

Примечание: не завершится для наборов бесконечного размера.

Source

def reduce[B >: Seq[B]](op: (B, B) => B): B

Сводит элементы этого набора с использованием указанного ассоциативного бинарного оператора.

Порядок выполнения операций над элементами не определен и может быть не детерминированным.

Source

def reduceLeft[B >: Seq[B]](op: (B, Seq[B]) => B): B

Применяет бинарный оператор ко всем элементам этого набора слева направо.

Примечание: не завершится для наборов бесконечного размера.

Примечание: может возвращать разные результаты для разных запусков, если только тип базового набора не является упорядоченным, или оператор не является ассоциативным и коммутативным.

Источник

def reduceLeftOption[B >: Seq[B]](op: (B, Seq[B]) => B): Option[B]

Применяет бинарный оператор ко всем элементам этого набора слева направо (по умолчанию).

Примечание: не завершится для наборов бесконечной длины.

Примечание: может возвращать разные результаты для разных запусков, если тип базового набора не упорядочен или оператор не ассоциативен и коммутативен.

Источник

def reduceOption[B >: Seq[B]](op: (B, B) => B): Option[B]

Применяет оператор к элементам этого набора (если есть), используя указанный ассоциативный бинарный оператор.

Порядок выполнения операций над элементами не определен и может быть не детерминированным.

Источник

def reduceRight[B >: Seq[B]](op: (Seq[B], B) => B): B

Применяет бинарный оператор ко всем элементам этого набора справа налево.

Примечание: не завершится для наборов бесконечной длины.

Примечание: может возвращать разные результаты для разных запусков, если тип базового набора упорядочен или оператор ассоциативен и коммутативен.

Источник

def reduceRightOption[B >: Seq[B]](op: (Seq[B], B) => B): Option[B]

Возвращает значение option, содержащее результат применения бинарного оператора ко всем элементам этого набора справа налево.

Примечание: не завершится для наборов бесконечной длины.

Примечание: может возвращать разные результаты для разных запусков, если тип базового набора упорядочен или оператор ассоциативен и коммутативен.

Источник

protected def reversed: Iterable[A]

Источник

def sameElements[B >: Seq[B]](that: IterableOnce[B]): Boolean

Проверяет, равны ли соответствующие элементы данного набора (с точки зрения ==) элементам этого итератора.

Источник

def scanLeft[B](z: B)(op: (B, Seq[B]) => B): Iterator[B]

Возвращает итератор, содержащий накопленные результаты применения оператора слева направо, включая начальное значение.

Примечание: не завершится для наборов бесконечной длины.

Примечание: может возвращать разные результаты для разных запусков, если тип базового набора упорядочен.

Источник

def slice(from: Int, until: Int): Iterator[A]

Выбирает интервал элементов. Результирующий итератор состоит из всех элементов x, которые удовлетворяют следующему условию:

from <= indexOf(x) < until

Примечание: может возвращать разные результаты для разных запусков, если тип базового набора упорядочен.

Источник

def sliding[B >: Seq[B]](size: Int, step: Int): GroupedIterator[B]

Возвращает итератор, представляющий «скользящее окно» этого итератора. Первый аргумент — размер окна, а второй аргумент step — это величина сдвига окна на каждой итерации. По умолчанию step равен 1.

Возвращаемый GroupedIterator можно настроить для заполнения частичного результата до размера size или для подавления частичного результата.

Примеры использования:

// Returns List(ArraySeq(1, 2, 3), ArraySeq(2, 3, 4), ArraySeq(3, 4, 5))
(1 to 5).iterator.sliding(3).toList
// Returns List(ArraySeq(1, 2, 3, 4), ArraySeq(4, 5))
(1 to 5).iterator.sliding(4, 3).toList
// Returns List(ArraySeq(1, 2, 3, 4))
(1 to 5).iterator.sliding(4, 3).withPartial(false).toList
// Returns List(ArraySeq(1, 2, 3, 4), ArraySeq(4, 5, 20, 25))
// Illustrating that withPadding's argument is by-name.
val it2 = Iterator.iterate(20)(_ + 5)
(1 to 5).iterator.sliding(4, 3).withPadding(it2.next).toList

Исходный код

def span(p: Seq[B] => Boolean): (Iterator[A], Iterator[A])

Разделяет этот итератор на пару префикс/суффикс в соответствии с предикатом.

Примечание: c span p эквивалентно (но, возможно, более эффективно, чем) (c takeWhile p, c dropWhile p), при условии, что вычисление предиката p не вызывает побочных эффектов.

Примечание: может возвращать разные результаты для разных запусков, если тип базовой коллекции не упорядочен.

Исходный код

def splitAt(n: Int): (C, C)

Разделяет эту коллекцию на пару префикс/суффикс в заданной позиции.

Примечание: c splitAt n эквивалентно (но, возможно, более эффективно, чем) (c take n, c drop n).

Примечание: может возвращать разные результаты для разных запусков, если тип базовой коллекции не упорядочен.

Исходный код

def stepper[S <: Stepper[_]](implicit shape: StepperShape[Seq[B], S]): S

Возвращает scala.collection.Stepper для элементов этой коллекции.

Stepper позволяет создавать поток Java для работы с коллекцией, см. scala.jdk.StreamConverters. Для коллекций, содержащих примитивные значения, Stepper можно использовать как итератор, который не упаковывает элементы.

Неявный параметр scala.collection.StepperShape определяет тип возвращаемого Stepper в соответствии с типом элементов этой коллекции.

• Для коллекций Int, Short, Byte или Char, возвращается scala.collection.IntStepper

• Для коллекций Double или Float, возвращается scala.collection.DoubleStepper

• Для коллекций Long, возвращается scala.collection.LongStepper

• Для любого другого типа элементов возвращается scala.collection.AnyStepper

Обратите внимание, что этот метод переопределён в подклассах, и тип возвращаемого значения уточняется до S with EfficientSplit, например, scala.collection.IndexedSeqOps.stepper. Для Steppers, помеченных scala.collection.Stepper.EfficientSplit, преобразователи в scala.jdk.StreamConverters позволяют создавать параллельные потоки, тогда как обычные Steppers могут быть преобразованы только в последовательные потоки.

Исходный код

def sum[B >: Seq[B]](implicit num: Numeric[B]): B

Суммирует элементы этой коллекции.

Примечание: не завершится для коллекций бесконечного размера.

Исходный код

def take(n: Int): Iterator[A]

Выбирает первые n элементов.

Примечание: может возвращать разные результаты для разных запусков, если тип базовой коллекции не упорядочен.

Исходный код

def takeWhile(p: Seq[B] => Boolean): Iterator[A]

Взятие самого длинного префикса элементов, удовлетворяющих предикату.

Примечание: может возвращать разные результаты для разных запусков, если тип базовой коллекции не упорядочен.

Исходный код

override def tapEach[U](f: Seq[B] => U): Iterator[A]

Применение функции побочного эффекта к каждому элементу в этой коллекции. Строгие коллекции применяют f к своим элементам немедленно, в то время как ленивые коллекции, такие как представления и LazyLists, применяют f к каждому элементу только при его вычислении и каждый раз, когда этот элемент вычисляется.

Исходный код

def to[C1](factory: Factory[Seq[B], C1]): C1

При заданном фабрике коллекции factory, преобразуйте эту коллекцию в соответствующее представление для текущего типа элемента A. Примеры использования:

xs.to(List) xs.to(ArrayBuffer) xs.to(BitSet) // для xs: Iterable[Int]

Исходный код

def toArray[B >: Seq[B] : ClassTag]: Array[B]

Преобразует коллекцию в массив.

Примечание реализации: НЕ вызывайте Array.from из этого метода.

Исходный код

final def toBuffer[B >: Seq[B]]: Buffer[B]

Источник

def toIndexedSeq: IndexedSeq[A]

Источник

def toList: List[A]

Источник

def toMap[K, V](implicit ev: Seq[B] <:< (K, V)): Map[K, V]

Источник

def toSeq: Seq[A]

Источник

def toSet[B >: Seq[B]]: Set[B]

Источник

override def toString: String

Преобразует этот итератор в строку.

Источник

def toVector: Vector[A]

Источник

def withFilter(p: Seq[B] => Boolean): Iterator[A]

Создаёт итератор, содержащий все элементы этого итератора, удовлетворяющие предикату p. Порядок элементов сохраняется.

Примечание: withFilter эквивалентно filter для итераторов. Оно существует, чтобы выражения for с фильтрами работали над итераторами.

Источник

def zip[B](that: IterableOnce[B]): Iterator[(A, B)]

Источник

def zipAll[A1 >: Seq[B], B](that: IterableOnce[B], thisElem: A1, thatElem: B): Iterator[(A1, B)]

Источник

def zipWithIndex: Iterator[(A, Int)]

Объединяет этот итератор с его индексами.