Colecciones

## Objetivos de Aprendizaje - Trabajar con Arreglos - Usar Sets para valores unicos - Dominar Diccionarios - Comprender la mutabilidad de colecciones ## Arreglos ### Crear Arreglos ```swift // Arreglo vacio let vacio: [Int] = [] let vacio2 = Array() // Con valores iniciales let numeros = [1, 2, 3, 4, 5] let cadenas = ["uno", "dos", "tres"] // Valor repetido let ceros = [Int](repeating: 0, count: 5) // [0, 0, 0, 0, 0] ``` ### Anotacion de Tipo ```swift let enteros: [Int] = [1, 2, 3] let dobles: [Double] = [1.0, 2.0, 3.0] let cadenas: [String] = ["a", "b", "c"] ``` ### Forma Abreviada de Tipo de Arreglo ```swift var nombres: [String] = ["Alicia", "Roberto"] // nombres es Array ``` ## Acceder a Elementos ### Acceso por Indice ```swift let frutas = ["manzana", "banana", "cereza"] let primero = frutas[0] // "manzana" let ultimo = frutas[2] // "cereza" // frutas[5] // Error en tiempo de ejecucion! ``` ### Primero y Ultimo ```swift let primero = frutas.first // Optional("manzana") let ultimo = frutas.last // Optional("cereza") if let primero = frutas.first { print(primero) } ``` ### Verificar si Esta Vacio ```swift let vacio: [Int] = [] vacio.isEmpty // true vacio.count // 0 let numeros = [1, 2, 3] numeros.isEmpty // false numeros.count // 3 ``` ## Modificar Arreglos ### Arreglos var ```swift var arreglo = [1, 2, 3] // Agregar elemento arreglo.append(4) // [1, 2, 3, 4] // Agregar contenidos de otro arreglo arreglo.append(contentsOf: [5, 6]) // [1, 2, 3, 4, 5, 6] // Insertar en indice arreglo.insert(0, at: 0) // [0, 1, 2, 3, 4, 5, 6] // Remover arreglo.remove(at: 0) // Devuelve 0, arreglo es [1, 2, 3, 4, 5, 6] arreglo.removeFirst() // Devuelve 1, arreglo es [2, 3, 4, 5, 6] arreglo.removeLast() // Devuelve 6, arreglo es [2, 3, 4, 5] // Remover todos arreglo.removeAll() ``` ### Actualizar Elementos ```swift var puntuaciones = [90, 85, 88] puntuaciones[0] = 95 // [95, 85, 88] puntuaciones[1...2] = [100, 100] // [95, 100, 100] ``` ## Iteracion de Arreglos ### Bucle For-In ```swift let frutas = ["manzana", "banana", "cereza"] for fruta in frutas { print(fruta) } // Con indice for (indice, fruta) in frutas.enumerated() { print("\(indice): \(fruta)") } ``` ## Metodos de Arreglos ### Ordenar ```swift var numeros = [3, 1, 4, 1, 5, 9, 2, 6] numeros.sort() // En lugar: [1, 1, 2, 3, 4, 5, 6, 9] let ordenado = numeros.sorted() // Devuelve nuevo arreglo // Orden personalizado let ordenadoDesc = numeros.sorted(by: >) // Descendente ``` ### Invertir ```swift let invertido = numeros.reversed() // ReversedCollection let arregloInvertido = Array(numeros.reversed()) // [6, 2, 9, 5, 1, 4, 1, 3] ``` ### Contiene y Encontrar ```swift let numeros = [1, 2, 3, 4, 5] numeros.contains(3) // true numeros.contains { $0 > 3 } // true if let indice = numeros.firstIndex(of: 3) { print("Encontrado en \(indice)") } if let primero = numeros.first(where: { $0 > 3 }) { print("Primero > 3 es \(primero)") // 4 } ``` ### Filtrar ```swift let numeros = [1, 2, 3, 4, 5, 6] let pares = numeros.filter { $0 % 2 == 0 } // [2, 4, 6] let mayoresA3 = numeros.filter { $0 > 3 } // [4, 5, 6] ``` ### Mapear ```swift let numeros = [1, 2, 3] let duplicados = numeros.map { $0 * 2 } // [2, 4, 6] let cadenas = numeros.map { String($0) } // ["1", "2", "3"] ``` ### Reducir ```swift let numeros = [1, 2, 3, 4, 5] let suma = numeros.reduce(0) { $0 + $1 } // 15 let producto = numeros.reduce(1, *) // 120 ``` ## Sets ### Crear Sets ```swift // Set vacio let vacio: Set = Set() let vacio2 = Set() // Con valores var frutas: Set = ["manzana", "banana", "cereza"] let numeros: Set = [1, 2, 3, 4, 5] ``` ### Propiedades Clave ```swift let colores = Set(["rojo", "verde", "azul"]) colores.count // 3 colores.isEmpty // false colores.first // Valor Optional (sin orden) ``` ## Operaciones de Set ### Insertar y Remover ```swift var frutas: Set = ["manzana", "banana"] frutas.insert("cereza") // ("cereza", true) si es nuevo frutas.remove("manzana") // Optional("manzana") si existia frutas.remove("uva") // nil (no esta en el set) // Verificar membresia if frutas.contains("banana") { print("Tiene banana") } ``` ### Union ```swift let setA: Set = [1, 2, 3] let setB: Set = [3, 4, 5] let union = setA.union(setB) // [1, 2, 3, 4, 5] let unionA = setA | setB // [1, 2, 3, 4, 5] ``` ### Interseccion ```swift let comun = setA.intersection(setB) // [3] let comun2 = setA & setB // [3] ``` ### Substraccion ```swift let soloA = setA.subtracting(setB) // [1, 2] let soloA2 = setA - setB // [1, 2] ``` ### Diferencia Simetrica ```swift let diff = setA.symmetricDifference(setB) // [1, 2, 4, 5] let diff2 = setA ^ setB // [1, 2, 4, 5] ``` ### Subset y Superset ```swift let a: Set = [1, 2] let b: Set = [1, 2, 3] let c: Set = [1, 2, 3] a.isSubset(of: b) // true b.isSuperset(of: a) // true b.isStrictSubset(of: c) // false b.isStrictSuperset(of: a) // true ``` ## Diccionarios ### Crear Diccionarios ```swift // Diccionario vacio let vacio: [String: Int] = [:] let vacio2 = Dictionary() // Con valores var edades = ["Alicia": 30, "Roberto": 25, "Carlos": 35] ``` ### Anotacion de Tipo de Diccionario ```swift var nombres: [Int: String] = [ 1: "Uno", 2: "Dos", 3: "Tres" ] ``` ## Acceder a Valores ### Acceso con Subindice ```swift let edades = ["Alicia": 30, "Roberto": 25] let edad = edades["Alicia"] // Optional(30) let desconocido = edades["Eva"] // nil // Proporcionar valor por defecto let nombre = edades["Alicia", default: 0] // 30 let faltante = edades["Eva", default: 0] // 0 ``` ### Existencia de Clave ```swift if edades["Alicia"] != nil { print("Alicia existe") } // Alternativa if let edadAlicia = edades["Alicia"] { print("Alicia tiene \(edadAlicia)") } ``` ## Modificar Diccionarios ### Agregar/Actualizar ```swift var edades = ["Alicia": 30, "Roberto": 25] // Agregar nuevo edades["Carlos"] = 35 // Actualizar existente edades["Alicia"] = 31 // Actualizar con closure edades.updateValue(40, forKey: "Roberto") // Devuelve valor antiguo (25) ``` ### Remover ```swift var edades = ["Alicia": 30, "Roberto": 25, "Carlos": 35] edades.removeValue(forKey: "Carlos") // Devuelve valor removido edades.removeValue(forKey: "Eva") // Devuelve nil edades["Roberto"] = nil // Tambien remueve edades.removeAll() ``` ## Iteracion de Diccionarios ### Bucle For-In de Diccionario ```swift let edades = ["Alicia": 30, "Roberto": 25, "Carlos": 35] for (nombre, edad) in edades { print("\(nombre): \(edad)") } // Solo claves for nombre in edades.keys { print(nombre) } // Solo valores for edad in edades.values { print(edad) } ``` ## Metodos de Diccionario ### Propiedades ```swift let edades = ["Alicia": 30, "Roberto": 25] edades.count // 2 edades.isEmpty // false edades.keys // ["Alicia", "Roberto"] edades.values // [30, 25] ``` ### Filtrado de Diccionario ```swift let edades = ["Alicia": 30, "Roberto": 25, "Carlos": 35, "Diana": 40] let adultos = edades.filter { $0.value >= 30 } // ["Alicia": 30, "Carlos": 35, "Diana": 40] ``` ### Mapeo de Diccionario ```swift let edades = ["Alicia": 30, "Roberto": 25] let descripciones = edades.mapValues { "\($0) anos" } // ["Alicia": "30 anos", "Roberto": "25 anos"] ``` ## Resumen - Arreglos: ordenados, indexados, permiten duplicados - Sets: desordenados, valores unicos, operaciones matematicas - Diccionarios: pares clave-valor, busqueda rapida - Usar `var` para colecciones mutables - Acceder con subindices o metodos - Funciones de orden superior: map, filter, reduce - `first`, `last` devuelven opcionales - Usar `isEmpty` antes de acceder