Класс ArraySeq.ofFloat

final class ofFloat(val unsafeArray: Array[Float]) extends ArraySeq[Float]

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

Исходный код

override def appended[B >: Float](elem: B): ArraySeq[B]

Копия этого неизменяемого массива с добавленным элементом.

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

Пример:

scala> val a = List(1)
a: List[Int] = List(1)

scala> val b = a :+ 2
b: List[Int] = List(1, 2)

scala> println(a)
List(1)

Исходный код

def apply(i: Int): Float

Получить элемент по указанному индексу. Эта операция предоставлена для удобства в Seq. Не следует предполагать, что она эффективна, если у вас нет IndexedSeq.

Исходный код

override def equals(that: Any): Boolean

Универсальный метод равенства, определенный в AnyRef.

Исходный код

override def hashCode: Int

Вычисление значения хэш-кода для объекта.

По умолчанию алгоритм хэширования зависит от платформы.

Обратите внимание, что для двух объектов разрешено иметь одинаковые хэш-коды (o1.hashCode.equals(o2.hashCode)) но не быть равными (o1.equals(o2) возвращает false). Вырожденная реализация могла бы всегда возвращать 0. Однако требуется, чтобы если два объекта равны (o1.equals(o2) возвращает true) , у них были одинаковые хэш-коды (o1.hashCode.equals(o2.hashCode)). Поэтому при переопределении этого метода убедитесь, что поведение согласуется с методом equals.

Исходный код

override def iterator: Iterator[Float]

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

Исходный код

def length: Int

Длина (количество элементов) неизменяемого массива. size является псевдонимом для length в коллекциях Seq.

Исходный код

override def prepended[B >: Float](elem: B): ArraySeq[B]

Копия неизменяемого массива с добавленным элементом в начало.

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

Пример:

scala> val x = List(1)
x: List[Int] = List(1)

scala> val y = 2 +: x
y: List[Int] = List(2, 1)

scala> println(x)
List(1)

Исходный код

override def stepper[S <: Stepper[_]](implicit shape: StepperShape[Float, S]): S & EfficientSplit

Возвращает 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. Для степеров, помеченных как scala.collection.Stepper.EfficientSplit, преобразователи в scala.jdk.StreamConverters позволяют создавать параллельные потоки, в то время как обычные степеры могут быть преобразованы только в последовательные потоки.

Источник

override def updated[B >: Float](index: Int, elem: B): ArraySeq[B]

Копия этого неизменяемого массива с одним заменённым элементом.

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

Источник

final def ++[B >: Float](suffix: IterableOnce[B]): CC[B]

Псевдоним для concat

Источник

final override def ++:[B >: Float](prefix: IterableOnce[B]): CC[B]

Псевдоним для prependedAll

Источник

final def +:[B >: Float](elem: B): CC[B]

Псевдоним для prepended.

Обратите внимание, что операторы с окончанием двоеточием ассоциативны справа (см. пример). Мнемоника для +: против :+ : двоеточие ставится со стороны коллекции.

Источник

final def :+[B >: Float](elem: B): CC[B]

Псевдоним для appended

Обратите внимание, что операторы с окончанием двоеточием ассоциативны справа (см. пример). Мнемоника для +: против :+ : двоеточие ставится со стороны коллекции.

Источник

final def :++[B >: Float](suffix: IterableOnce[B]): CC[B]

Псевдоним для appendedAll

Источник

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 andThen[C](k: PartialFunction[Float, C]): PartialFunction[A, C]

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

Обратите внимание, что вызов isDefinedAt на результирующей частичной функции может применить первую частичную функцию и выполнить её побочное действие. Для повышения эффективности рекомендуется использовать applyOrElse вместо isDefinedAt или apply.

Источник

override def andThen[C](k: Float => C): PartialFunction[A, C]

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

Если тип функции во время выполнения является PartialFunction, то используется другой метод andThen (обратите внимание на его предостережения).

Источник

override def appendedAll[B >: Float](suffix: IterableOnce[B]): ArraySeq[B]

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

Источник

def applyOrElse[A1 <: Int, B1 >: Float](x: A1, default: A1 => B1): B1

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

Обратите внимание, что выражение pf.applyOrElse(x, default) эквивалентно

if(pf isDefinedAt x) pf(x) else default(x)

за исключением того, что метод applyOrElse может быть реализован более эффективно. Для всех частичных функций-литералов компилятор генерирует реализацию applyOrElse, которая избегает двойной оценки предикатных соответствий и защитных условий. Это делает applyOrElse основой для эффективной реализации многих операций и сценариев, таких как:

- объединение частичных функций в цепочки orElse/andThen не приводит к чрезмерной оценке apply/isDefinedAt - lift и unlift не оценивают исходные функции дважды при каждом вызове - runWith позволяет эффективно объединять частичные функции в императивном стиле с условными действиями

Для классов частичных функций, не являющихся литералами, с ненулевой реализацией метода isDefinedAt рекомендуется переопределять метод applyOrElse с настраиваемой реализацией, которая избегает двойной оценки isDefinedAt. Это может привести к лучшей производительности и более предсказуемому поведению с точки зрения побочных эффектов.

Источник

override def canEqual(that: Any): Boolean

Метод, который следует вызывать из каждой хорошо спроектированной функции equals, которая может быть переопределена в подклассе. См. Programming in Scala, Chapter 28 для обсуждения и проектирования.

Источник

override def collect[B](pf: PartialFunction[Float, B]): CC[B]

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

Источник

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

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

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

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

Источник

def combinations(n: Int): Iterator[C]

Перебирает комбинации. _Комбинация_ длины n — это подпоследовательность исходной последовательности, элементы которой взяты в порядке. Таким образом, "xy" и "yy" — это комбинации длины 2 "xyy", но "yx" — нет. Если существует более одного способа сгенерировать одну и ту же подпоследовательность, будет возвращен только один.

Например, "xyyy" имеет три различных способа сгенерировать "xy", в зависимости от того, выбирается ли первый, второй или третий "y". Однако, поскольку все они идентичны, будет выбран только один. Какой из трёх будет выбран — это реализационный detail, который не определён.

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

Источник

def compose[R](k: PartialFunction[R, Int]): PartialFunction[R, B]

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

Обратите внимание, что вызов isDefinedAt для полученной частичной функции может применить первую частичную функцию и выполнить её побочный эффект. Для повышения эффективности рекомендуется использовать applyOrElse вместо isDefinedAt или apply.

Источник

def compose[A](g: A => Int): A => R

Объединяет два экземпляра Function1 в новый Function1, при этом данная функция применяется последней.

Исходный код

final override def concat[B >: Float](suffix: IterableOnce[B]): CC[B]

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

Исходный код

def contains[A1 >: Float](elem: A1): Boolean

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

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

Исходный код

def containsSlice[B >: Float](that: Seq[B]): Boolean

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

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

Исходный код

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

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

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

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

Исходный код

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

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

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

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

Источник

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

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

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

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

Источник

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

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

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

Источник

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

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

Источник

def count(p: Float => Boolean): Int

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

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

Исходный код

override def diff[B >: Float](that: Seq[B]): C

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

Исходный код

def distinct: C

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

Исходный код

override def distinctBy[B](f: Float => B): C

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

Исходный код

override def drop(n: Int): ArraySeq[A]

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

Исходный код

override def dropRight(n: Int): ArraySeq[A]

Остальная часть коллекции без ее n последних элементов. Для линейных неизменяемых коллекций это должно избегать создания копии.

Примечание: Даже при применении к представлению или ленивой коллекции она всегда будет принудительно вычислять элементы.

Исходный код

def dropWhile(p: Float => Boolean): C

Удаляет самую длинную префиксную часть элементов, удовлетворяющих предикату.

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

Исходный код

def elementWise: ElementWiseExtractor[A, B]

Возвращает объект-экстрактор с методом unapplySeq, который извлекает каждый элемент данных последовательности.

val firstChar: String => Option[Char] = _.headOption
Seq("foo", "bar", "baz") match {
  case firstChar.unlift.elementWise(c0, c1, c2) =>
    println(s"$c0, $c1, $c2") // Output: f, b, b
}

Исходный код

override def empty: CC[A]

Пустая итерируемая коллекция того же типа, что и эта итерируемая коллекция

Исходный код

def endsWith[B >: Float](that: Iterable[B]): Boolean

Проверяет, заканчивается ли эта последовательность заданной последовательностью.

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

Исходный код

def exists(p: Float => Boolean): Boolean

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

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

Исходный код

override def filter(pred: Float => Boolean): C

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

Исходный код

override def filterNot(pred: Float => Boolean): C

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

Источник

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

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

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

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

Источник

def findLast(p: Float => Boolean): Option[A]

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

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

Источник

override def flatMap[B](f: Float => IterableOnce[B]): CC[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)

Источник

override def flatten[B](implicit toIterableOnce: Float => IterableOnce[B]): CC[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 >: Float](z: A1)(op: (A1, A1) => A1): A1

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

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

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

Источник

override def foldLeft[B](z: B)(f: (B, Float) => B): B

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

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

Источник

override def foldRight[B](z: B)(f: (Float, B) => B): B

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

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

Источник

def forall(p: Float => Boolean): Boolean

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

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

Source

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

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

Source

override protected def fromSpecific(coll: IterableOnce[Float]): CC[A]

Определяет, как преобразовать заданную Iterable[A] в коллекцию типа C.

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

Source

def groupBy[K](f: Float => K): Map[K, C]

Разделяет эту итерируемую коллекцию на карту итерируемых коллекций в соответствии с некоторой функцией-дискриминатором.

Примечание: Даже при применении к представлению или ленивой коллекции элементы всегда будут принудительно вычисляться.

(xs groupBy f)(k) = xs filter (x => f(x) == k)

Source

def groupMap[K, B](key: Float => K)(f: Float => B): Map[K, CC[B]]

Разделяет эту итерируемую коллекцию на карту итерируемых коллекций согласно функции-дискриминатору key. Каждый элемент в группе преобразуется в значение типа B с использованием функции value.

Эквивалентно groupBy(key).mapValues(_.map(f)), но более эффективно.

case class User(name: String, age: Int)

def namesByAge(users: Seq[User]): Map[Int, Seq[String]] =
  users.groupMap(_.age)(_.name)

Примечание: Даже при применении к представлению или ленивой коллекции элементы всегда будут принудительно вычисляться.

Source

def groupMapReduce[K, B](key: Float => K)(f: Float => B)(reduce: (B, B) => B): Map[K, B]

Разделяет эту итерируемую коллекцию на карту согласно функции-дискриминатору key. Все значения, имеющие одинаковый дискриминатор, затем преобразуются функцией f и затем сводятся к одному значению с помощью функции reduce.

Эквивалентно groupBy(key).mapValues(_.map(f).reduce(reduce)), но более эффективно.

def occurrences[A](as: Seq[A]): Map[A, Int] =
  as.groupMapReduce(identity)(_ => 1)(_ + _)

Примечание: Даже при применении к представлению или ленивой коллекции элементы всегда будут принудительно вычисляться.

Source

def grouped(size: Int): Iterator[C]

Разбивает элементы на итерируемые коллекции фиксированного размера.

Source

override def head: A

Выбирает первый элемент этой последовательности.

Source

override def headOption: Option[A]

Возвращает первый элемент, если он есть.

Source

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

Находит индекс первого вхождения некоторого значения в этой последовательности.

Source

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

Находит индекс первого вхождения некоторого значения в этой последовательности после или на определенном стартовом индексе.

Source

def indexOfSlice[B >: Float](that: Seq[B]): Int

Находит первый индекс, где эта последовательность содержит заданную последовательность как срез.

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

Исходный код

def indexOfSlice[B >: Float](that: Seq[B], from: Int): Int

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

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

Исходный код

def indexWhere(p: Float => Boolean): Int

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

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

Исходный код

def indexWhere(p: Float => Boolean, from: Int): Int

Находит индекс первого элемента, удовлетворяющего некоторому предикату после или на некотором начальном индексе.

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

Исходный код

def indices: Range

Создаёт диапазон всех индексов этой последовательности.

Примечание: даже при применении к представлению или ленивой коллекции она всегда заставит элементы.

Исходный код

def init: C

Начальная часть коллекции без последнего элемента.

Примечание: даже при применении к представлению или ленивой коллекции она всегда заставит элементы.

Исходный код

def inits: Iterator[C]

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

Примечание: даже при применении к представлению или ленивой коллекции она всегда заставит элементы.

Исходный код

override def intersect[B >: Float](that: Seq[B]): C

Вычисляет пересечение мультимножеств между этой последовательностью и другой последовательностью.

Исходный код

def isDefinedAt(idx: Int): Boolean

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

Реализации методов apply и isDefinedAt преобразуют Seq[A] в PartialFunction[Int, A].

Исходный код

override def isEmpty: Boolean

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

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

Исходный код

override def isTraversableAgain: Boolean

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

Исходный код

override def iterableFactory: SeqFactory[ArraySeq]

Компаньон-объект этой неизменяемой массива, предоставляющий различные методы создания.

Исходный код

override def knownSize: Int

Исходный код

override def last: A

Выбирает последний элемент.

Исходный код

def lastIndexOf[B >: Float](elem: B, end: Int): Int

Находит индекс последнего вхождения некоторого значения в этой последовательности до или на заданном индексе конца.

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

Исходный код

def lastIndexOfSlice[B >: Float](that: Seq[B]): Int

Находит последний индекс, где эта последовательность содержит заданную последовательность в виде среза.

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

Исходный код

def lastIndexOfSlice[B >: Float](that: Seq[B], end: Int): Int

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

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

Исходный код

def lastIndexWhere(p: Float => Boolean): Int

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

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

Source

def lastIndexWhere(p: Float => Boolean, end: Int): Int

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

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

Source

def lastOption: Option[A]

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

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

Source

def lazyZip[B](that: Iterable[B]): LazyZip2[A, B, Iterable]

Аналогично zip за исключением того, что элементы в каждой коллекции не потребляются до тех пор, пока не будет вызвано строгое действие над возвращаемой LazyZip2 декорацией.

Вызовы lazyZip могут быть объединены, чтобы поддерживать более высокие арности (до 4) без затрат на создание и деконструирование промежуточных кортежей.

val xs = List(1, 2, 3)
val res = (xs lazyZip xs lazyZip xs lazyZip xs).map((a, b, c, d) => a + b + c + d)
// res == List(4, 8, 12)

Source

final override def lengthCompare(that: Iterable[_]): Int

Сравнивает длину этой последовательности с размером другого Iterable.

x <  0       if this.length <  that.size
x == 0       if this.length == that.size
x >  0       if this.length >  that.size

Source

final override def lengthCompare(len: Int): Int

Сравнивает длину этой последовательности со значением теста.

x <  0       if this.length <  len
x == 0       if this.length == len
x >  0       if this.length >  len

Source

final def lengthIs: SizeCompareOps

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

Эти операции реализованы с точки зрения lengthCompare(Int), и позволяют использовать следующие более читаемые варианты:

this.lengthIs < len     // this.lengthCompare(len) < 0
this.lengthIs <= len    // this.lengthCompare(len) <= 0
this.lengthIs == len    // this.lengthCompare(len) == 0
this.lengthIs != len    // this.lengthCompare(len) != 0
this.lengthIs >= len    // this.lengthCompare(len) >= 0
this.lengthIs > len     // this.lengthCompare(len) > 0

Source

def lift: A => Option[B]

Преобразует эту частичную функцию в обычную функцию, возвращающую Option результат.

Source

override def map[B](f: Float => B): ArraySeq[B]

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

Source

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

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

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

Source

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

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

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

Source

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Источник

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

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

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

Source

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

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

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

Source

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

override protected def newSpecificBuilder: Builder[A, CC[A]]

Source

def nonEmpty: Boolean

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

Source

def orElse[A1 <: Int, B1 >: Float](that: PartialFunction[A1, B1]): PartialFunction[A1, B1]

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

Source

override def padTo[B >: Float](len: Int, elem: B): CC[B]

Копия этой последовательности со значением элемента, добавленным до достижения заданной целевой длины.

Source

override def partition(p: Float => Boolean): (C, C)

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

Реализация по умолчанию, представленная здесь, требует два прохода по коллекции. Строгие коллекции имеют переопределенную версию partition в StrictOptimizedIterableOps, которая требует только одного прохода.

Source

override def partitionMap[A1, A2](f: Float => Either[A1, A2]): (CC[A1], CC[A2])

Применяет функцию f к каждому элементу итерируемой коллекции и возвращает пару итерируемых коллекций: первая содержит те значения, возвращённые функцией f, которые были заключены в scala.util.Left, а вторая — те, что были заключены в scala.util.Right.

Пример:

val xs = Iterable(1, "one", 2, "two", 3, "three") partitionMap {
 case i: Int => Left(i)
 case s: String => Right(s)
}
// xs == (Iterable(1, 2, 3),
//        Iterable(one, two, three))

Исходный код

override def patch[B >: Float](from: Int, other: IterableOnce[B], replaced: Int): CC[B]

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

Замена по отрицательным индексам эквивалентна замене с началом с 0. Замена по индексам, равным или большим длины исходной последовательности, добавляет вставку в конец. Если заменяемых значений больше, чем фактически существует, избыток игнорируется.

Исходный код

def permutations: Iterator[C]

Итерируется по различным перестановкам.

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

Исходный код

override def prependedAll[B >: Float](prefix: IterableOnce[B]): ArraySeq[B]

Как и :++, возвращает новую коллекцию, содержащую элементы левого операнда, за которыми следуют элементы правого операнда.

Он отличается от :++ тем, что правый операнд определяет тип результирующей коллекции, а не левый. Мнемоника: двоеточие стоит со стороны типа новой коллекции.

Исходный код

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

Умножает элементы этой коллекции.

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

Исходный код

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

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

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

Исходный код

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

Применяет бинарную операцию ко всем элементам этой коллекции слева направо.

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

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

Исходный код

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

Опционально применяет бинарную операцию ко всем элементам этой коллекции слева направо.

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

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

Исходный код

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

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

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

Source

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

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

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

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

Source

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

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

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

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

Source

override def reverse: ArraySeq[A]

Возвращает новый неизменяемый массив с элементами в обратном порядке.

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

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

Source

override def reverseIterator: Iterator[A]

Итератор, возвращающий элементы в обратном порядке.

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

Примечание: xs.reverseIterator эквивалентно xs.reverse.iterator, но может быть более эффективным.

Source

override protected def reversed: Iterable[A]

Source

def runWith[U](action: Float => U): A => Boolean

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

Обратите внимание, что выражение pf.runWith(action)(x) эквивалентно

if(pf isDefinedAt x) { action(pf(x)); true } else false

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

Source

override def sameElements[B >: Float](o: IterableOnce[B]): Boolean

Являются ли элементы этого набора такими же (и в таком же порядке), как и элементы that?

Source

def scan[B >: Float](z: B)(op: (B, B) => B): CC[B]

Вычисляет сканирование префиксов элементов коллекции.

Примечание: нейтральный элемент z может применяться более одного раза.

Source

override def scanLeft[B](z: B)(op: (B, Float) => B): CC[B]

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

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

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

Source

def scanRight[B](z: B)(op: (Float, B) => B): CC[B]

Создаёт коллекцию, содержащую кумулятивные результаты применения оператора справа налево. Головка коллекции — последний кумулятивный результат.

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

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

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

Пример:

List(1, 2, 3, 4).scanRight(0)(_ + _) == List(10, 9, 7, 4, 0)

Source

override def search[B >: Float](elem: B, from: Int, to: Int)(implicit ord: Ordering[B]): SearchResult

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

Последовательность должна быть отсортирована с использованием того же Ordering перед вызовом; в противном случае результаты будут неопределенными.

Source

override def search[B >: Float](elem: B)(implicit ord: Ordering[B]): SearchResult

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

Последовательность должна быть отсортирована с использованием того же Ordering перед вызовом; в противном случае результаты будут неопределенными.

Source

def segmentLength(p: Float => Boolean, from: Int): Int

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

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

Source

final def segmentLength(p: Float => Boolean): Int

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

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

Исходный код

final override def size: Int

Размер этого набора.

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

Исходный код

final override def sizeCompare(that: Iterable[_]): Int

Сравнивает размер этого набора с размером другого Iterable.

x <  0       if this.size <  that.size
x == 0       if this.size == that.size
x >  0       if this.size >  that.size

Исходный код

final override def sizeCompare(otherSize: Int): Int

Сравнивает размер этого набора со значением теста.

x <  0       if this.size <  otherSize
x == 0       if this.size == otherSize
x >  0       if this.size >  otherSize

Исходный код

final def sizeIs: SizeCompareOps

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

Эти операции реализованы с помощью sizeCompare(Int) и позволяют использовать следующие более удобочитаемые выражения:

this.sizeIs < size     // this.sizeCompare(size) < 0
this.sizeIs <= size    // this.sizeCompare(size) <= 0
this.sizeIs == size    // this.sizeCompare(size) == 0
this.sizeIs != size    // this.sizeCompare(size) != 0
this.sizeIs >= size    // this.sizeCompare(size) >= 0
this.sizeIs > size     // this.sizeCompare(size) > 0

Исходный код

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

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

from <= indexOf(x) < until

Исходный код

def sliding(size: Int, step: Int): Iterator[C]

Группирует элементы в блоки фиксированного размера, пропуская по ним «скользящее окно» (в отличие от разбиения, как это делается в grouped).

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

Исходный код

def sliding(size: Int): Iterator[C]

Группирует элементы в блоки фиксированного размера, пропуская по ним «скользящее окно» (в отличие от разбиения, как это делается в grouped).

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

Исходный код

def sortBy[B](f: Float => B)(implicit ord: Ordering[B]): C

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

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

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

Сортировка стабильная. То есть, элементы, которые равны (как определяется ord.compare), появляются в отсортированном наборе в том же порядке, что и в оригинальном.

val words = "The quick brown fox jumped over the lazy dog".split(' ')
// this works because scala.Ordering will implicitly provide an Ordering[Tuple2[Int, Char]]
words.sortBy(x => (x.length, x.head))
res0: Array[String] = Array(The, dog, fox, the, lazy, over, brown, quick, jumped)

Исходный код

def sortWith(lt: (Float, Float) => Boolean): C

Сортирует этот набор в соответствии с функцией сравнения.

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

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

Сортировка стабильная. То есть, элементы, которые равны (как определяется lt ), появляются в отсортированном наборе в том же порядке, что и в оригинальном.

List("Steve", "Tom", "John", "Bob").sortWith(_.compareTo(_) < 0) =
List("Bob", "John", "Steve", "Tom")

Источник

override def sorted[B >: Float](implicit ord: Ordering[B]): ArraySeq[A]

Сортирует этот неизменяемый массив в соответствии с Ordering.

Сортировка стабильна. То есть, элементы, которые равны (как определено ord.compare), появляются в том же порядке в отсортированной последовательности, что и в исходной.

Источник

override def span(p: Float => Boolean): (C, C)

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

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

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

Источник

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

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

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

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

Источник

def startsWith[B >: Float](that: IterableOnce[B], offset: Int): Boolean

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

Примечание: Если и объект-получатель this и аргумент that являются бесконечными последовательностями, этот метод может не завершиться.

Источник

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

Суммирует элементы этого набора.

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

Источник

override def tail: ArraySeq[A]

Остальная часть коллекции без первого элемента.

Источник

def tails: Iterator[C]

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

Источник

override def take(n: Int): ArraySeq[A]

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

Источник

override def takeRight(n: Int): ArraySeq[A]

Коллекция, содержащая последние n элементов этой коллекции.

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

Источник

def takeWhile(p: Float => Boolean): C

Берет самую длинную префиксную часть элементов, удовлетворяющих предикату.

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

Источник

override def tapEach[U](f: Float => U): C

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

Источник

def to[C1](factory: Factory[Float, C1]): C1

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

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

Источник

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

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

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

Источник

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

Источник

final override def toIndexedSeq: IndexedSeq[A]

Источник

def toList: List[A]

Источник

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

Источник

final override def toSeq: Seq.this.type

Источник

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

Source

override def toString(): String

Возвращает строковое представление объекта.

По умолчанию представление зависит от платформы.

Source

def toVector: Vector[A]

Source

def transpose[B](implicit asIterable: Float => Iterable[B]): CC[CC[B]]

Транспонирует это итерируемое множество итерируемых множеств в итерируемое множество итерируемых множеств.

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

val xs = List(
           Set(1, 2, 3),
           Set(4, 5, 6)).transpose
// xs == List(
//         List(1, 4),
//         List(2, 5),
//         List(3, 6))

val ys = Vector(
           List(1, 2, 3),
           List(4, 5, 6)).transpose
// ys == Vector(
//         Vector(1, 4),
//         Vector(2, 5),
//         Vector(3, 6))

Примечание: Даже при применении к представлению или ленивому множеству элементы всегда будут принудительно вычисляться.

Source

def unapply(a: Int): Option[B]

Попытка извлечь B из A в выражении сопоставления с образцом.

Source

override def unzip[A1, A2](implicit asPair: Float => (A1, A2)): (CC[A1], CC[A2])

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

val xs = Iterable(
           (1, "one"),
           (2, "two"),
           (3, "three")).unzip
// xs == (Iterable(1, 2, 3),
//        Iterable(one, two, three))

Source

override def unzip3[A1, A2, A3](implicit asTriple: Float => (A1, A2, A3)): (CC[A1], CC[A2], CC[A3])

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

val xs = Iterable(
           (1, "one", '1'),
           (2, "two", '2'),
           (3, "three", '3')).unzip3
// xs == (Iterable(1, 2, 3),
//        Iterable(one, two, three),
//        Iterable(1, 2, 3))

Источник

override def view: IndexedSeqView[A]

Представление над элементами этого множества.

Источник

def withFilter(p: Float => Boolean): WithFilter[A, CC]

Создаёт нестрогий фильтр этого итерируемого множества.

Примечание: разница между c filter p и c withFilter p заключается в том, что первый создаёт новое множество, а второй только ограничивает область применения последующих map, flatMap, foreach и withFilter операций.

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

Источник

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

Возвращает неизменяемый массив, сформированный из этого неизменяемого массива и другого итерируемого множества, объединяя соответствующие элементы в пары. Если одно из двух множеств длиннее другого, оставшиеся элементы игнорируются.

Источник

def zipAll[A1 >: Float, B](that: Iterable[B], thisElem: A1, thatElem: B): CC[(A1, B)]

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

Источник

override def zipWithIndex: CC[(A, Int)]

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

Подробное описание полей

Источник

val unsafeArray: Array[Float]

Оборачиваемый изменяемый Array набор, который поддерживает этот ArraySeq. Любые изменения в этом массиве нарушат ожидаемую неизменяемость. Его тип элемента не обязательно должен совпадать с типом элемента этого ArraySeq. Примитивный ArraySeq может быть поддержан массивом упакованных значений, а ArraySeq ссылок — массивом типа-супертипа или типа-подтипа типа элемента.