Главная страница
Навигация по странице:

  • Таблица 24.1

  • Специализованные свертки

  • Операции индексирования и длины apply, isDefinedAt, length, indices lengthCompare и lengthIs.

  • Операции поиска индекса indexOf, lastIndexOf, indexOfSlice, lastIn- dexOfSlice, indexWhere, lastIndexWhere, segmentLength и prefixLength

  • Операции добавления +: (псевдоним: prepended), ++: (псевдоним: pre- pen dedAll), :+ (псевдоним: appended), :++ (псевдоним: appendedAll) и padTo

  • Операции обновления updated и patch

  • Операции сравнения startsWith, endsWith, contains, corresponds, con- tainsSlice и search

  • Таблица 24.2.

  • Добавления x+:xs (или xs.prepended(x))Новая последовательность со значением x, добав­ленным в начало xs 526

  • Реверсирования xs.reverseПоследовательность из элементов xs, следующих в обратном порядке xs.reverseIteratorИтератор, выдающий все элементы xs в обратном порядкеТаблица 24.2

  • Операции над множествами

  • Таблица 24.3.

  • Scala. Профессиональное программирование 2022. Одерски Мартин, Спун Лекс, Веннерс Билл, Соммерс ФрэнкО41 Scala. Профессиональное программирование. 5е изд спб. Питер, 2022. 608 с. ил. Серия Библиотека программиста


    Скачать 6.24 Mb.
    НазваниеОдерски Мартин, Спун Лекс, Веннерс Билл, Соммерс ФрэнкО41 Scala. Профессиональное программирование. 5е изд спб. Питер, 2022. 608 с. ил. Серия Библиотека программиста
    Дата27.04.2023
    Размер6.24 Mb.
    Формат файлаpdf
    Имя файлаScala. Профессиональное программирование 2022.pdf
    ТипДокументы
    #1094967
    страница55 из 64
    1   ...   51   52   53   54   55   56   57   58   ...   64
    Извлечение элементов
    xs.head
    Первый элемент коллекции (или какой­нибудь элемент, если порядок следования элементов не определен)
    xs.headOption
    Первый элемент xs в Option­значении или
    None
    , если xs пуст xs.last
    Последний элемент коллекции (или какой­ни­
    будь элемент, если порядок следования элементов не определен)
    xs.lastOption
    Последний элемент xs в Option­значении параме­
    тра или
    None
    , если xs пуст xs.find(p)
    Option­значение, содержащее первый элемент в xs
    , удовлетворяющий условию p
    , или
    None
    , если такого элемента нет
    Создание подколлекций
    xs.tail
    Вся коллекция, за исключением xs.head xs.init
    Вся коллекция, за исключением xs.last xs.slice(from, to)
    Коллекция, состоящая из элементов в некотором диапазоне индексов xs
    (от from включительно до to не включительно)
    xs.take(n)
    Коллекция, состоящая из первых n
    элементов xs
    (или n
    каких­либо произвольных элементов, если порядок следования элементов не определен)
    xs.drop(n)
    Вся коллекция xs
    , за вычетом тех элементов, ко­
    торые получаются при использовании выражения xs take n
    xs.takeWhile(p)
    Самый длинный префикс элементов в коллекции, каждый из которых соответствует условию p
    xs.dropWhile(p)
    Коллекция без самого длинного префикса элемен­
    тов, каждый из которых соответствует условию p
    xs.takeRight(n)
    Коллекция, состоящая из заключительных n
    эле­
    ментов xs
    (или произвольных n
    элементов, если порядок не определен)
    Таблица 24.1 (продолжение)

    24 .3 . Трейт Iterable 521
    Что
    Что делает
    xs.dropRight(n)
    Вся коллекция, кроме xs takeRight n
    xs.filter(p)
    Коллекция, состоящая только из тех элементов xs
    , которые соответствуют условию p
    xs.withFilter(p)
    Нестрогий фильтр коллекции. Все операции в отношении фильтруемых элементов будут при­
    меняться только к тем элементам xs
    , для которых условие p
    вычисляется в true xs.filterNot(p)
    Коллекция, состоящая из тех элементов xs
    , кото­
    рые не соответствуют условию p
    Слияния
    xs.zip(ys)
    Итерируемые пары соответствующих элементов из xs и ys xs.lazyZip(ys)
    Значение, предоставляющее методы для поэле­
    ментной работы с коллекциями xs и ys
    . См. раз­
    дел 14.9
    xs.zipAll(ys, x, y)
    Итерируемые пары соответствующих элементов из xs и ys
    ; если одна из последовательностей ко­
    роче, то расширяется за счет добавления элемен­
    тов x
    или y
    xs.zipWithIndex
    Итерируемые пары элементов из xs с их индек­
    сами
    Разбиения
    xs.splitAt(n)
    Разбивает xs по позиции на пару коллекций
    (
    xs.take(n)
    , xs.drop(n)
    )
    xs.span(p)
    Разбивает xs в соответствии с предикатом на пару коллекций (
    xs.takeWhile(p)
    , xs.dropWhile(p)
    )
    xs.partition(p)
    Разбивает xs на пару коллекций, в одной из которых находятся все элементы, удовлетворя­
    ющие условию p
    , а в другой — все элементы, не удовлетворяющие этому условию (
    xs.filter(p)
    , xs.filterNot(p)
    )
    xs.partitionMap(f)
    Преобразует каждый элемент xs в значение
    Either[X,
    Y
    ] и разбивает результат на две коллек­
    ции: одна с элементами из
    Left
    , а другая с элемен­
    тами из
    Right xs.groupBy(f)
    Разбивает xs на отображение коллекций в соот­
    ветствии с функцией дискриминатором f

    522 Глава 24 • Углубленное изучение коллекций
    Что
    Что делает
    xs.groupMap(f)(g)
    Превращает xs в отображение коллекций в соот­
    ветствии с функцией­дискриминатором f
    и при­
    меняет функцию преобразования g
    к каждому элементу каждой коллекции xs.groupMapReduce(f)(g)(h)
    Превращает xs в отображение коллекций в со­
    ответствии с функцией­дискриминатором f
    , применяет функцию преобразования g
    к каждому элементу каждой коллекции и сводит каждую коллекцию к единственному значению, объединяя ее элементы с помощью функции h
    Состояния элементов
    xs.forall(p)
    Булево значение, показывающее, соблюдается ли условие p
    для всех элементов xs xs.exists(p)
    Булево значение, показывающее, соблюдается ли условие p
    для каких­либо элементов xs xs.count(p)
    Количество элементов в xs
    , удовлетворяющих условию p
    Свертки
    xs.foldLeft(z)(op)
    Применяет бинарную операцию op к последова­
    тельным элементам xs
    , продвигаясь слева на­
    право, начиная с z
    xs.foldRight(z)(op)
    Применяет бинарную операцию op к последо­
    вательным элементам xs
    , продвигаясь справа налево, начиная с z
    xs.reduceLeft(op)
    Применяет бинарную операцию op к последова­
    тельным элементам xs непустой коллекции xs
    , продвигаясь слева направо xs.reduceRight(op)
    Применяет бинарную операцию op к последова­
    тельным элементам xs непустой коллекции xs
    , продвигаясь справа налево
    Специализованные свертки
    xs.sum
    Сумма числовых элементов коллекции xs xs.product
    Произведение числовых элементов коллекции xs xs.min
    Минимальное значение упорядочиваемых эле­
    ментов коллекции xs xs.max
    Максимальное значение упорядочиваемых эле­
    ментов коллекции xs
    Таблица 24.1 (продолжение)

    24 .4 . Трейты последовательностей Seq, IndexedSeq и LinearSeq 523
    Что
    Что делает
    Строки
    xs addString (b, start, sep, end)
    Добавляет строку к строковому буферу b
    типа
    StringBuilder со всеми элементами xs с разде­
    лителями sep
    , заключенными между строками start и end
    . Аргументы start
    , sep и end являются необязательными xs mkString (start, sep, end)
    Превращает коллекцию в строку со всеми эле­
    ментами xs с разделителями sep
    , заключенными между строками start и end
    . Аргументы start
    , sep и end являются необязательными
    Представления
    xs.view
    Создает представление xs
    Подкатегории Iterable
    В иерархии наследования ниже
    Iterable находятся три трейта:
    Seq
    ,
    Set и
    Map
    Трейты
    Seq и
    Map объединяет то, что они реализуют трейт
    PartialFunction
    1
    с методами apply и isDefinedAt
    . Но способы реализации
    PartialFunction у каждого трейта свои.
    Для последовательностей apply
    позиционное индексирование, в котором элементы всегда нумеруются с нуля. То есть
    Seq(1,
    2,
    3)(1)
    ==
    2
    . Для мно­
    жеств apply
    — проверка на принадлежность. Например,
    Set('a',
    'b',
    'c')
    ('b')
    ==
    true
    , а
    Set()('a')
    ==
    false
    . И наконец, для отображений apply
    — средство выбора. Например,
    Map('a'
    –>
    1,
    'b'
    –>
    10,
    'c'
    –>
    100)('b')
    ==
    10
    Более подробно каждый из этих видов коллекций мы рассмотрим в следу­
    ющих трех разделах.
    24 .4 . Трейты последовательностей Seq,
    IndexedSeq и LinearSeq
    Трейт
    Seq представляет последовательности. Последовательностью назы­
    вается разновидность итерируемой коллекции, у которой есть длина и все элементы которой имеют фиксированные индексированные позиции, отсчет
    1
    Частично определенные функции описаны в разделе 13.7.

    524 Глава 24 • Углубленное изучение коллекций которых начинается с нуля. Операции с последовательностями (сведены в табл. 24.2) разбиваются на следующие категории.
    z z
    Операции индексирования и длины apply, isDefinedAt, length, indices
    lengthCompare и lengthIs. Для
    Seq операция apply означает индексирова­
    ние, поэтому последовательность типа
    Seq[T]
    является частично приме­
    ненной функцией, которая получает аргумент типа
    Int
    (индекс) и выдает элемент последовательности типа
    T
    . Иными словами,
    Seq[T]
    расширяет
    PartialFunction[Int,
    T]
    . Элементы последовательности индексируются от нуля до длины последовательности length за вычетом единицы. Метод length
    , применяемый в отношении последовательностей, — псевдоним общего для коллекций метода size
    . Метод lengthCompare позволяет срав­
    нивать длины двух последовательностей, даже если одна из них имеет бесконечную длину. Метод lengthIs
    — псевдоним метода sizeIs z
    z
    Операции поиска индекса indexOf, lastIndexOf, indexOfSlice, lastIn-
    dexOfSlice, indexWhere, lastIndexWhere, segmentLength и prefixLength возвращают индекс элемента, равного заданному значению или соответ­
    ствующего некоему условию.
    z z
    Операции добавления +: (псевдоним: prepended), ++: (псевдоним: pre-
    pen dedAll), :+ (псевдоним: appended), :++ (псевдоним: appendedAll)
    и padTo возвращают новые последовательности, получаемые путем до­
    бавления к началу или концу последовательности.
    z z
    Операции обновления updated и patch возвращают новую последова­
    тельность, получаемую путем замены некоторых элементов исходной последовательности.
    z z
    Операции сортировки sorted, sortWith и sortBy сортируют элементы последовательности в соответствии с различными критериями.
    z z
    Операции реверсирования reverse и reverseIterator обрабатывают или возвращают элементы последовательности в обратном порядке, с по­
    следнего до первого.
    z z
    Операции сравнения startsWith, endsWith, contains, corresponds, con-
    tainsSlice и search определяют соотношение двух последовательностей или ищут элемент в последовательности.
    z z
    Операции над множествами intersect, diff, distinct и distinctBy выпол­
    няют над элементами двух последовательностей операции, подобные операциям с множествами, или удаляют дубликаты.
    Для изменяемой последовательности предлагается дополнительный метод добавления update с побочным эффектом, который позволяет элементам

    24 .4 . Трейты последовательностей Seq, IndexedSeq и LinearSeq 525
    последовательности обновляться. Вспомним: в главе 3 мы уже говорили, что синтаксис вида seq(idx)
    =
    elem
    — не более чем сокращение для выражения seq.update(idx,
    elem)
    . Обратите внимание на разницу между методами update и updated
    . Первый изменяет элемент последовательности на месте и доступен только для изменяемых последовательностей. Второй доступен для всех последовательностей и всегда вместо изменения исходной возвра­
    щает новую последовательность.
    Таблица 24.2. Операции в трейте Seq
    Что
    Что делает
    Индексирование и длина
    xs(i)
    (или после раскры­
    тия xs.apply(i)
    )
    Элемент xs с индексом i
    xs.isDefinedAt(i)
    Проверяет, содержится ли i
    в xs.indices xs.length
    Длина последовательности (то же самое, что и size
    )
    xs.lengthCompare(len)
    Возвращает отрицательное значение
    Int
    , если дли­
    на xs меньше len
    , положительное, если больше, и
    0
    , если они равны. Работает даже для бесконечных коллекций xs xs.indices
    Диапазон индексов xs от
    0
    до xs.length — 1
    Поиск индекса
    xs.indexOf(x)
    Индекс первого элемента в xs
    , равного значению x
    (существует несколько вариантов)
    xs.lastIndexOf(x)
    Индекс последнего элемента в xs
    , равного значе­
    нию x
    (существует несколько вариантов)
    xs.indexOfSlice(ys)
    Первый индекс xs при условии, что следующие друг за другом элементы, начинающиеся с элемента с этим индексом, составляют последовательность ys xs.lastIndexOfSlice(ys)
    Последний индекс xs при условии, что следующие друг за другом элементы, начинающиеся с элемента с этим индексом, составляют последовательность ys xs.indexWhere(p)
    Индекс первого элемента в xs
    , удовлетворяющего условию p
    (существует несколько вариантов)
    xs.segmentLength(p,
    i)
    Длина самого длинного непрерывного сегмента элементов в xs
    , начинающегося с xs(i)
    , который удовлетворяет условию p
    Добавления
    x
    +:
    xs
    (или xs.prepended(x)
    )
    Новая последовательность со значением x
    , добав­
    ленным в начало xs

    526 Глава 24 • Углубленное изучение коллекций
    Что
    Что делает
    ys ++: xs
    (или xs.prependedAll(ys)
    )
    Новая последовательность, состоящая из всех эле­
    ментов ys
    , добавленных в начало xs xs :+ x
    (или xs.appended(x)
    )
    Новая последовательность со значением x
    , добав­
    ленным в конец xs xs :++ ys
    (или xs.appendedAll(ys)
    )
    Новая последовательность, состоящая из всех элементов ys
    , добавленных в конец xs
    . То же самое, что xs
    ++
    ys xs.padTo(len, x)
    Последовательность, получающаяся при добав­
    лении значения x
    к xs
    , до тех пор, пока длина не достигнет значения len
    Обновления
    xs.patch(i, ys, r)
    Последовательность, получающаяся путем замены r
    элементов последовательности xs
    , начиная с i
    , элементами последовательности ys xs.updated(i, x)
    Копия xs
    , в которой элемент с индексом i
    заменяет­
    ся значением x
    xs(i) = x
    (или после рас­
    крытия xs.update(i, x)
    , которая доступна только для изменяемых последо­
    вательностей mutable.Seq
    )
    Изменяет значение элемента xs с индексом i
    на значение x
    Сортировки
    xs.sorted
    Новая последовательность, полученная путем сортировки элементов xs в порядке следования элементов типа xs xs.sortWith(lessThan)
    Новая последовательность, полученная путем сор­
    тировки элементов xs с использованием в качестве операции сравнения lessThan
    (Меньше чем)
    xs.sortBy(f)
    Новая последовательность, полученная путем сор­
    тировки элементов xs
    . Сравнение двух элементов выполняется путем применения к ним функции f
    и сравнения результатов
    Реверсирования
    xs.reverse
    Последовательность из элементов xs
    , следующих в обратном порядке xs.reverseIterator
    Итератор, выдающий все элементы xs в обратном порядке
    Таблица 24.2 (продолжение)

    24 .4 . Трейты последовательностей Seq, IndexedSeq и LinearSeq 527
    Что
    Что делает
    Сравнения
    xs.sameElements(ys)
    Проверяет, содержат ли xs и ys одинаковые элемен­
    ты в одном и том же порядке xs.startsWith(ys)
    Проверяет, не начинается ли xs с последовательно­
    сти ys
    (имеется несколько вариантов)
    xs.endsWith(ys)
    Проверяет, не заканчивается ли xs последователь­
    ностью ys
    (имеется несколько вариантов)
    xs.contains(x)
    Проверяет, имеется ли в xs элемент, равный x
    xs.search(x)
    Проверяет, содержит ли отсортированная коллек­
    ция xs элемент, равный x
    , и делает это потенциаль­
    но эффективнее, чем xs contains x
    xs.containsSlice(ys)
    Проверяет, имеется ли в xs непрерывная последова­
    тельность, равная ys xs.corresponds(ys)(p)
    Проверяет, удовлетворяют ли соответствующие элементы xs и ys бинарному предикату p
    Операции над множествами
    xs.intersect(ys)
    Пересечение множеств, состоящих из элементов последовательностей xs и ys
    , которое сохраняет по­
    рядок следования элементов в xs xs.diff(ys)
    Разность множеств, состоящих из элементов после­
    довательностей xs и ys
    , которое сохраняет порядок следования элементов в xs xs.distinct
    Часть последовательности xs
    , не содержащая ду­
    бликатов xs.distinctBy(f)
    Подпоследовательность xs
    , в которой после при­
    менения преобразующей функции f
    нет повторя­
    ющихся элементов
    У каждого трейта
    Seq есть два подтрейта:
    LinearSeq и
    IndexedSeq
    . Они не до­
    бавляют никаких новых операций, но каждый их них предлагает разные ха­
    рактеристики производительности. У линейной последовательности (linear sequence) есть эффективные операции head и tail
    , а у индексированной — эффективные операции apply
    , length и (если последовательность изменя­
    емая) update
    . В
    List зачастую применяется линейная последовательность, как и в
    LazyList
    . Представители двух часто используемых индексированных последовательностей —
    Array и
    ArrayBuffer
    . Класс
    Vector обеспечивает весьма интересный компромисс между индексированным и последователь­
    ным доступом. У него практически постоянные линейные издержки как на

    528 Глава 24 • Углубленное изучение коллекций индексированный, так и на последовательный доступ. Поэтому векторы слу­
    жат хорошей основой для смешанных схем доступа, в которых используется как индексированный, так и последовательный доступ. Более подробно мы рассмотрим векторы в разделе 24.7.
    Изменяемый подтрейт
    IndexedSeq добавляет операции для преобразования имеющихся элементов. В отличие от map и sort
    , которые доступны в
    Seq
    , эти операции, представленные в табл. 24.3, не возвращают новый экземпляр коллекции.
    Таблица 24.3. Операции в трейте mutable .IndexedSeq
    Что
    Что делает
    Добавления
    xs.mapInPlace(f)
    Преобразует все элементы xs
    , применяя к каждому из них функцию f
    xs.sortInPlace()
    Сортирует элементы xs на месте xs.sortInPlaceBy(f)
    Сортирует элементы xs на месте и в соответствии с порядком, который определяется путем применения функции f
    к каждому элементу xs.sortInPlaceWith(c)
    Сортирует элементы xs на месте в соответствии с функцией сравнения c
    Буферы
    Важная подкатегория изменяемых последовательностей — буферы. Они по­
    зволяют не только обновлять существующие элементы, но и вставлять и уда­
    лять элементы, а также с высокой эффективностью добавлять новые элементы в конец буфера. Принципиально новые методы, поддерживаемые буфером, —
    +=
    (псевдоним: append
    ) и
    ++=
    (псевдоним: appendAll
    ) для добавления элемен­
    тов в конец буфера,
    +=:
    (псевдоним: prepend
    ) и
    ++=:
    (псевдоним: prependAll
    ) для добавления элементов в начало буфера, insert и insertAll для вставки элементов, а также remove
    ,
    -=
    (псевдоним: subtractOne
    ) и
    --=
    (псевдоним: subtractAll
    ) для удаления элементов. Все эти операции сведены в табл. 24.4.
    Наиболее часто используются две реализации буферов:
    ListBuffer и
    Ar- rayBuffer
    . Исходя из названий,
    ListBuffer базируется на классе
    List и под­
    держивает высокоэффективное преобразование своих элементов в список, а
    ArrayBuffer базируется на массиве и может быть быстро превращен в мас­
    сив. Наметки реализации
    ListBuffer мы показали в разделе 1.2.

    24 .4 . Трейты последовательностей Seq, IndexedSeq и LinearSeq
    1   ...   51   52   53   54   55   56   57   58   ...   64


    написать администратору сайта