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)")
}