Swift ofrece tres tipos de coleccións principais:

• Arrays (matrices). Son coleccións ordenadas de valores
• Conxuntos. Son coleccións non ordenadas de valores únicos
• Dicionarios. Son coleccións non ordenadas de asociacións de clave-valor

Arrays

Unha matriz almacena valores do mesmo tipo nunha lista ordenada. O mesmo valor pode aparecer nunha matriz varias veces en diferentes posicións.

Para definir un array:

• Array<Elemento>, onde Elemento é o tipo de valores que a matriz pode almacenar.
• [Elemento].

Aínda que as dúas formas son funcionalmente idénticas, prefírese a última forma.

No seguinte exemplo definimos catro arrays:

• array1 e array2: Creamos un array vacío, e, unha vez creados, engadimos os valores.
• array3 e array4: Creamos un array xa con valores.

var array1: [Int] = [];
array1 += [1,2,3,4];

var array2: Array<Int> = [];
array2 += [1,2,3,4];

var array3: [Int] = [1,2,3,4];
var array4: Array<Int> = [1,2,3,4];

print("""
- array1[0] = \(array1[0])
- array2[1] = \(array2[1])
- array3[2] = \(array2[2])
- array4[3] = \(array2[3])
""");
//Imprime por pantalla o seguinte:
//- array1[0] = 1
//- array2[1] = 2
//- array3[2] = 3
//- array4[3] = 4

Aquí tedes o código fonte con todos os exemplos empregados nesta sección:

Array baleiro

var algunosEnteros: [Int] = []
print("algunosEnteros es de tipo [Int] con \(algunosEnteros.count) elementos.")
// Imprime "algunosEnteros es de tipo [Int] con 0 elementos."

algunosEnteros.append(4) //Agora algunosEnteros contén un valor (4)
algunosEnteros = [] //Agora algunosEnteros está baleiro, pero segue sendo de tipo Int

Arrays con valores

Podemos crear un array dun tamaño determinado con todos os seus valores definidos co mesmo valor.

Para iso, pasamos a este inicializador un valor predeterminado do tipo apropiado (chamado repeating:) e o número de veces que ese valor se repite na nova matriz (chamado count:).

var tresEnteros = Array(repeating: 0, count: 3)
//tresEnteros es un array de tipo [Int], y su contenido es [0,0,0]

var cuatroEnteros: [Int] = [1,2,3,4];
//cuatroEnteros es un array de tipo [Int], y su contenido es [1,2,3,4]

var arrayCadenas = ["Cadena 1", "Cadena 2", "Cadena 3"]
//arrayCadenas es de tipo [String]

var arrayCadenas2: [String] = ["Cadena 1", "Cadena 2", "Cadena 3"]
//arrayCadenas2 es de tipo [String]

No seguinte exemplo podemos ver como crear un array con dous valores:

var tresEnteros = Array(repeating: 0, count: 3)
var seisEnteros = tresEnteros + tresEnteros //seisEnteros é: [0,0,0,0,0,0]

tresEnteros = [1,2,3]
var cuatroEnteros: [Int] = [4,5,6,7]
var sieteEnteros =  tresEnteros + cuatroEnteros //sieteEnteros é: [1,2,3,4,5,6,7]

Acceso e modificación

O máis básico

• Emprega a propiedade count para saber o número de elementos do array
• Emprega a propiedade booleana isEmpy para saber si é un array baleiro
• Podes engadir elementos ao array mediante o método append(_:)
• Podes engadir un array a outro array mediante o operador +=

var listaCompra = ["Huevos", "Leche"]
print("A lista da compra contén \(listaCompra.count) elementos")
//Imprime: A lista da compra contén 2 elementos

if listaCompra.isEmpty {
    print("A lista da compra está baleira.")
} else {
    print("A lista da compra NON está baleira.")
}
//Imprime: A lista da compra NON está baleira

listaCompra.append("Carne") //listaCompra é ["Huevos", "Leche", "Carne"]

listaCompra += ["Pan"] //listaCompra é ["Huevos", "Leche", "Carne","Pan"]

Subíndices

Podemos recuperar ou modificar un valor dun array pasando o índice do valor que queremos recuperar entre corchetes (inmediatamente despois do nome da matriz):

var listaCompra = ["Huevos", "Leche"]
var primeiroElemento = listaCompra[0] //primeiroElemento é igual a "Huevos"

listaCompra[0] = "Seis ovos" //O primeiro elementos da lista (listaCompra) agora é "Seis ovos"

Tamén podemos cambiar un intervalo de valores á vez:

var listaCompra = ["Huevos", "Leche","Carne","Pescado","Pan","Verduras"]
listaCompra[2...4] = ["Plátano","Chocolate"] 
//Agora, listaCompra é: ["Huevos", "Leche", "Plátano", "Chocolate", "Verduras"]
//xa que substituimos ["Carne","Pescado","Pan"] por ["Plátano","Chocolate"]

Índices

• Para inserir un elemento nun índice especificado, chamamos ao método insert(_:at:) do array.
• De xeito similar, para eliminar un elemento empregamos remove(at:)
• Eliminamos o último valor mediante removeLast()

listaCompra = ["Huevos", "Leche","Carne","Pescado","Pan"]

listaCompra.insert("Pescado", at: 2)
//Agora, listaCompra é: ["Huevos", "Leche", "Pescado", "Carne", "Pescado", "Pan"]

listaCompra.remove(at: 2)
//Agora, listaCompra é: ["Huevos", "Leche", "Carne", "Pescado", "Pan"]

listaCompra.removeLast()
//Agora, listaCompra é: ["Huevos", "Leche", "Carne", "Pescado"]

Recorrer o array

Podemos recorrer o array mediante o bucle for-in:

listaCompra = ["Huevos", "Leche","Carne","Pescado","Pan"]
for item in listaCompra {
    print(item)
}

Se necesitamos o índice enteiro de cada elemento así como o seu valor, usamos o método enumerated() para recorrer o array.

• Para cada elemento do array, o método enumerated() devolve unha tupla composta por un número enteiro e o elemento.
• Os números enteiros comezan en cero e contan en un para cada elemento.

listaCompra = ["Huevos", "Leche","Carne","Pescado","Pan"]
for (numOrden, valor) in listaCompra.enumerated() {
    print("Item \(numOrden + 1): \(valor)")
}

Conxuntos

Un conxunto almacena distintos valores do mesmo tipo sen unha orde definida.

Podes usar un conxunto en lugar dunha matriz cando a orde dos elementos non sexa importante ou cando teñas que asegurarte de que un elemento só aparece unha vez.

O tipo dun conxunto Swift escríbese como Set<Elemento>, onde Elemento é o tipo que o conxunto pode almacenar. A diferenza dos arrays, os conxuntos non teñen unha forma abreviada equivalente.

var conjunto = Set<Character>()
print("conjunto es del tipo Set<Character> y tiene \(conjunto.count) elementos")
//Esto imprime: conjunto es del tipo Set<Character> y tiene o elementos

var conjunto2: Set = ["Luka", "Carvajal","Marcelo"]
var generosMusicales: Set<String> = ["Rock", "Pop", "Jazz"]

Aquí tedes o código fonte con todos os exemplos empregados nesta sección:

Crear un conxunto baleiro

var conjunto = Set<Character>()
print("conjunto es del tipo Set<Character> y tiene \(conjunto.count) elementos")
//Esto imprime: conjunto es del tipo Set<Character> y tiene o elementos

Crear con conxuntos con valores

var conjunto2: Set = ["Luka", "Carvajal","Marcelo"]
var generosMusicales: Set<String> = ["Rock", "Pop", "Jazz"]

Acceso e modificación

• Emprega a propiedade count para saber o número de elementos do conxunto
• Emprega a propiedade booleana isEmpy para saber si é un conxunto baleiro
• Podes engadir elementos ao conxunto mediante o método insert(_:)
• Podes eliminar elementos mediante o método remove(_:)
• Podes eliminar todos os elementos mediante removeAll()
• Para averiguar se un conxunto contén un determinado elementos emprega o método contains(_:)

var generosMusicales: Set = ["Rock", "Pop", "Jazz"]

if generosMusicales.isEmpty {
    print("Non son un gran fan da música")
} else {
    print("Gustánme determinados xéreros musicais.")
}

generosMusicales.insert("Hip Hop")
var generoBorrado = generosMusicales.remove("Rock")

if generosMusicales.contains("Funk") {
    print("Me levanto con buen pie.")
} else {
    print("No hay Funk")
}

Recorrer o conxunto

Podemos recorrer o conxunto mediante o bucle for-in:

var generosMusicales: Set = ["Rock", "Pop", "Jazz"]

for genero in generosMusicales {
    print("\(genero)")
}

//Imprime ["Pop", "Jazz", "Rock"]

Para recorrer os valores dun conxunto nunha orde específica, usaremos o método sorted(), que devolve os elementos do conxunto como un array ordenado mediante o operador <.

var generosMusicales: Set = ["Rock", "Pop", "Jazz"]

for genero in generosMusicales.sorted() {
    print("\(genero)")
}
//Imprime ["Jazz", "Pop", "Rock"]

Operacións de conxuntos

A ilustración seguinte representa dous conxuntos cos resultados de varias operacións de conxuntos representados polas rexións sombreadas:

• Usamos o método intersection(_:) para crear un novo conxunto con só os valores comúns a ambos os conxuntos.
• Usamos o método symmetricDifference(_:) para crear un novo conxunto con valores en calquera dos conxuntos, pero non en ambos.
• Usamos o método union(_:) para crear un novo conxunto con todos os valores dos dous conxuntos.
• Usamos o método subtracting(_:) para crear un novo conxunto con valores que non estean no conxunto especificado.

var numPares: Set = [0, 2,4,6,8]
var numImpares: Set = [1,3,5,7,9]
var numPrimos: Set = [2, 3, 5, 7]

numImpares.union(numPares).sorted() //[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
numImpares.intersection(numPares).sorted() //[]
numImpares.intersection(numPrimos).sorted() //[3,5,7]
numImpares.subtracting(numPrimos).sorted() //[1, 9]

Igualdade

A ilustración seguinte representa tres conxuntos: a, b e c, con rexións superpostas que representan elementos compartidos entre conxuntos.

• O conxunto a é un superconxunto do conxunto b, porque a contén todos os elementos de b.
• Pola contra, o conxunto b é un subconxunto do conxunto a, porque todos os elementos en b tamén están contidos por a.
• O conxunto b e o conxunto c están disxuntos entre si, porque non comparten elementos en común.

• Usamos o operador «é igual» (==) para determinar se dous conxuntos conteñen os mesmos valores.
• Usamos o método isSubset(of:) para determinar se todos os valores dun conxunto están contidos no conxunto especificado..
• Usamos o método isSuperset(of:) para determinar se un conxunto contén todos os valores dun conxunto especificado.
• Usamos os métodos isStrictSubset(of:) ou isStrictSuperset(of:) para determinar se un conxunto é un subconxunto ou superconjunto, pero non é igual a un conxunto especificado.
• Usamos o método isDisjoint(with:) para determinar se dous conxuntos non teñen valores en común.

let animalesCasa: Set = ["🐶", "🐱"]
let animalesGranja: Set = ["🐮", "🐔", "🐑", "🐶", "🐱"]
let animalesCiudad: Set = ["🐦", "🐭"]

animalesCasa.isSubset(of: animalesGranja)      // true
animalesGranja.isSuperset(of: animalesCasa)    // true
animalesGranja.isDisjoint(with: animalesCiudad)   // true

Diccionarios

Un dicionario almacena asociacións entre claves e valores nunha colección sen unha orde definida.

• Cada valor está asociado cunha clave única, que actúa como identificador dese valor dentro do dicionario.
• A diferenza dos elementos dun array, os elementos dun dicionario non teñen unha orde especificada.
• Usamos un dicionario cando necesitas buscar valores en función do seu identificador, do mesmo xeito que se usa un dicionario do mundo real para buscar a definición dunha palabra en particular.
• O tipo de dicionario escríbese como Dictionary<Key, Value>, onde Key é o tipo de valor que se pode usar como chave de dicionario e Value é o tipo de valor que o dicionario almacena para esas chaves.

Aquí tedes o código fonte con todos os exemplos empregados nesta sección:

Crear diccionario baleiro

var nombresEnteros: [Int:String] = [:]

nombresEnteros[16]="Dieciseis"
print("\(nombresEnteros)") //IMPRIME: [16: "Dieciseis"]

Crear diccionarios con valores

var aeropuertos: [String:String] = ["MAD":"Madrid","JFK":"New York"]

Acceso e modificación

aeropuertos["LHR"] = "Londres"
aeropuertos.removeValue(forKey: "LHR")

Recorrer o diccionario

for (codigoAeropuerto, aeropuertoNombre) in aeropuertos {
    print("\(codigoAeropuerto): \(aeropuertoNombre)")
}
for codigoAeropuerto in aeropuertos.keys {
    print("\(codigoAeropuerto): \(codigoAeropuerto)")
}