Collection

Overview 概要

Collections are used extensively throughout the standard library. When you use arrays, dictionaries, and other collections, you benefit from the operations that the Collection protocol declares and implements. In addition to the operations that collections inherit from the Sequence protocol, you gain access to methods that depend on accessing an element at a specific position in a collection. コレクションは標準ライブラリの至る所で広範囲にわたって使われます。あなたが配列、辞書、および他のコレクションを使うとき、あなたはCollectionプロトコルが宣言および実装する演算からの恩恵を受けます。コレクションがSequenceプロトコルから継承するメソッドに加えて、あなたは、コレクションの特定の位置で要素にアクセスすることを当てにするメソッドへの利用権を手に入れます。

For example, if you want to print only the first word in a string, you can search for the index of the first space, and then create a substring up to that position. 例えば、あなたがある文字列の最初の単語のみを出力したいならば、最初の空白のインデックスを捜して、それからその位置までの下位文字列を作成してください。

let text = "Buffalo buffalo buffalo buffalo."
if let firstSpace = text.firstIndex(of: " ") {
    print(text[..<firstSpace])
}
// Prints "Buffalo"

The firstSpace constant is an index into the text string—the position of the first space in the string. You can store indices in variables, and pass them to collection algorithms or use them later to access the corresponding element. In the example above, firstSpace is used to extract the prefix that contains elements up to that index. firstSpace定数は、text文字列へのあるインデックス — その文字列の中の最初の空白の位置、です。あなたはこのようなインデックスを変数に格納して、それらを幾つかあるコレクションアルゴリズムに渡すことや、相当する要素にアクセスするためにそれらを後で使うことができます。上の例において、firstSpaceは、そのインデックスまでの要素を含んでいる前の部分を抜き取るために使われます。

Accessing Individual Elements 個々の要素にアクセスする

You can access an element of a collection through its subscript by using any valid index except the collection’s endIndex property. This property is a “past the end” index that does not correspond with any element of the collection. あなたは、コレクションの要素にそれの添え字を通してアクセスすることが、そのコレクションのendIndexプロパティを除くあらゆる有効なインデックスを使って行えます。このプロパティは「終わりを過ぎた」インデックスで、それはコレクションのどの要素にも対応しません。

Here’s an example of accessing the first character in a string through its subscript: ここにあるのはある文字列の最初の文字にそれの添え字を通してアクセスする例です。

let firstChar = text[text.startIndex]
print(firstChar)
// Prints "B"

The Collection protocol declares and provides default implementations for many operations that depend on elements being accessible by their subscript. For example, you can also access the first character of text using the first property, which has the value of the first element of the collection, or nil if the collection is empty. Collectionプロトコルは、多くの演算に対して省略時の実装を宣言および提供していて、それは要素がそれらの添え字によってアクセス可能になっているのを当てにします。例えば、あなたはまたtextの最初の文字にアクセスすることがfirstプロパティを使って行えます、それはコレクションの最初の要素の値、またはコレクションが空ならばnilを持ちます。

print(text.first)
// Prints "Optional("B")"

You can pass only valid indices to collection operations. You can find a complete set of a collection’s valid indices by starting with the collection’s startIndex property and finding every successor up to, and including, the endIndex property. All other values of the Index type, such as the startIndex property of a different collection, are invalid indices for this collection. あなたは有効なインデックスだけをコレクション演算子に渡せます。あなたはコレクションの有効なインデックスの完全な一揃いを見つけることが、そのコレクションのstartIndexプロパティで開始して、すべての後に続くものをendIndexプロパティまで、それを含めて、見つけ出すことによって行えます。Index型の他の値すべて、例えば異なるコレクションのstartIndexプロパティなどは、このコレクションに対する無効なインデックスです。

Saved indices may become invalid as a result of mutating operations. For more information about index invalidation in mutable collections, see the reference for the MutableCollection and RangeReplaceableCollection protocols, as well as for the specific type you’re using. 保存されたインデックスは変更を行う演算の結果として無効となるかもしれません。可変コレクションにおけるインデックス無効化についてのさらなる情報は、MutableCollectionおよびRangeReplaceableCollectionプロトコルに対してのリファレンスを見てください、もちろんあなたが使っている特定の型に対しても。

Accessing Slices of a Collection あるコレクションのスライスにアクセスする

You can access a slice of a collection through its ranged subscript or by calling methods like prefix(while:) or suffix(_:). A slice of a collection can contain zero or more of the original collection’s elements and shares the original collection’s semantics. あなたは、あるコレクションのあるスライスにそれの範囲指定された添え字を通して、またはprefix(while:)またはsuffix(_:)のようなメソッドを呼び出すことによってアクセスできます。コレクションのスライスは、ゼロまたはそれ以上の元のコレクションの要素を含み、元のコレクションのもつ意味論を共有できます。

The following example creates a firstWord constant by using the prefix(while:) method to get a slice of the text string. 以下の例は、firstWord定数をprefix(while:)メソッドを使ってtext文字列のスライスを得ることによって作成します。

let firstWord = text.prefix(while: { $0 != " " })
print(firstWord)
// Prints "Buffalo"

You can retrieve the same slice using the string’s ranged subscript, which takes a range expression. あなたは、同じスライスを文字列の範囲指定された添え字を使って取って来ることができます、それは範囲式をとっています。

if let firstSpace = text.firstIndex(of: " ") {
    print(text[..<firstSpace]
    // Prints "Buffalo"
}

The retrieved slice of text is equivalent in each of these cases. 取って来たtextのスライスは、それらの場合それぞれにで同等です。

Slices Share Indices スライスはインデックスを共有します

A collection and its slices share the same indices. An element of a collection is located under the same index in a slice as in the base collection, as long as neither the collection nor the slice has been mutated since the slice was created. コレクションとそれのスイラスは同じインデックスを共有します。コレクションのある要素は、基盤となるコレクションの中と同じスライスの中のインデックスのもとに位置を突き止められます、コレクションもスライスもスライスが作成された時からずっと変化していない限りは。

For example, suppose you have an array holding the number of absences from each class during a session. 例えば、あなたがある学期（２学期制）の各クラスの欠席者数が入った配列を持つと考えてください。

var absences = [0, 2, 0, 4, 0, 3, 1, 0]

You’re tasked with finding the day with the most absences in the second half of the session. To find the index of the day in question, follow these steps: あなたはこの学期の後半において最も多く欠席者がいる日付を見つける任務を負います。質問の日付のインデックスを見つけるには、これらの手順に従ってください：

1. Create a slice of the absences array that holds the second half of the days. 学期後半の日付を保持する、absences配列のスライスを作成してください。

2. Use the max(by:) method to determine the index of the day with the most absences. max(by:)メソッドを使って最も欠席者の多い日付のインデックスを判定してください。

3. Print the result using the index found in step 2 on the original absences array. 手順２で見つけたインデックスをオリジナルabsences配列上で使って結果を出力してください。

Here’s an implementation of those steps: ここにこれらの手順の実装があります：

let secondHalf = absences.suffix(absences.count / 2)
if let i = secondHalf.indices.max(by: { secondHalf[$0] < secondHalf[$1] }) {
    print("Highest second-half absences: \(absences[i])")
}
// Prints "Highest second-half absences: 3"

Slices Inherit Collection Semantics スライスはコレクションの意味論を継承します

A slice inherits the value or reference semantics of its base collection. That is, when working with a slice of a mutable collection that has value semantics, such as an array, mutating the original collection triggers a copy of that collection and does not affect the contents of the slice. スライスは、それの基盤コレクションのもつ値意味論もしくは参照意味論を継承します。すなわち、値意味論を持つ可変コレクション、例えば配列などのスライスを扱う場合、元のコレクションを変化させることはそのコレクションのコピーを引き起こし、スライスの内容に作用しません。

For example, if you update the last element of the absences array from 0 to 2, the secondHalf slice is unchanged. 例えば、あなたがabsences配列の最後の要素を0から2に更新する場合、secondHalfスライスは変化していません。

absences[7] = 2
print(absences)
// Prints "[0, 2, 0, 4, 0, 3, 1, 2]"
print(secondHalf)
// Prints "[0, 3, 1, 0]"

Traversing a Collection コレクションを辿っていく

Although a sequence can be consumed as it is traversed, a collection is guaranteed to be multipass: Any element can be repeatedly accessed by saving its index. Moreover, a collection’s indices form a finite range of the positions of the collection’s elements. The fact that all collections are finite guarantees the safety of many sequence operations, such as using the contains(_:) method to test whether a collection includes an element. シーケンスはそれが辿って行かれるとき消費されることが可能な一方、コレクションはマルチパスであることを保証されます：どんな要素もそれのインデックスを保存することによって繰り返しアクセスされます。その上、コレクションのインデックスは、コレクションの要素の位置からなる有限の範囲を形成します。すべてのコレクションが有限であるという事実は、多くのシーケンス演算、例えばcontains(_:)メソッドを使ってコレクションがある要素を含むかどうかテストすることなどの安全を保証します。

Iterating over the elements of a collection by their positions yields the same elements in the same order as iterating over that collection using its iterator. This example demonstrates that the characters view of a string returns the same characters in the same order whether the view’s indices or the view itself is being iterated. あるコレクションの要素すべてにそれの位置によって反復していくことは、そのコレクションすべてにそれのイテレータを使って反復していくのと同じ要素を同じ順序で生み出します。この例は、ある文字列のcharactersビューが、そのビューのインデックスであろうとビューそれ自体が反復されていようと同じ文字を同じ順序で返すのを実演します。

let word = "Swift"
for character in word {
    print(character)
}
// Prints "S"
// Prints "w"
// Prints "i"
// Prints "f"
// Prints "t"


for i in word.indices {
    print(word[i])
}
// Prints "S"
// Prints "w"
// Prints "i"
// Prints "f"
// Prints "t"

Conforming to the Collection Protocol Collectionプロトコルに準拠する

If you create a custom sequence that can provide repeated access to its elements, make sure that its type conforms to the Collection protocol in order to give a more useful and more efficient interface for sequence and collection operations. To add Collection conformance to your type, you must declare at least the following requirements: あなたがそれの要素に繰り返しアクセスを提供できるあつらえのシーケンスを作成しているならば、より実用的でより効率的なインターフェイスをシーケンスおよびコレクション演算に与えるために、それの型がCollectionプロトコルに準拠するのを確実にしてください。Collection準拠をあなたの型に加えるには、あなたは少なくとも以下の要件を宣言しなければなりません：

• The startIndex and endIndex properties startIndexおよびendIndexプロパティ

• A subscript that provides at least read-only access to your type’s elements 少なくとも読み出し専用のアクセスをあなたの型のもつ要素に提供する添え字

• The index(after:) method for advancing an index into your collection あるインデックスをあなたのコレクションにおいて前に進めるためのindex(after:)メソッド

Expected Performance 期待される性能

Types that conform to Collection are expected to provide the startIndex and endIndex properties and subscript access to elements as O(1) operations. Types that are not able to guarantee this performance must document the departure, because many collection operations depend on O(1) subscripting performance for their own performance guarantees. Collectionに準拠する型は、startIndexおよびendIndexプロパティと要素への添え字アクセスをO(1)演算として提供することを期待されます。この性能を保証することが可能でない型は、その逸脱を文書化されなければなりません、なぜなら多くのコレクション演算はそれら自身の性能保証としてO(1)添え字操作性能に依存するからです。

The performance of some collection operations depends on the type of index that the collection provides. For example, a random-access collection, which can measure the distance between two indices in O(1) time, can calculate its count property in O(1) time. Conversely, because a forward or bidirectional collection must traverse the entire collection to count the number of contained elements, accessing its count property is an O(n) operation. いくつかのコレクション演算の性能は、コレクションの提供するインデックスの型に依存します。例えば、ランダムアクセスのコレクションは、２つのインデックス間の隔たりをO(1)時間で測ることが可能で、それのcountプロパティをO(1)時間で計算できます。反対に、前方または双方向性のコレクションはコレクション全体を辿っていくことで含まれる要素の数を数えるので、それのcountプロパティにアクセスすることはO(n)演算になります。