Collection Types

Swift에는 3개(Array,Set,Dictionary)의 콜렉션 타입이 있다.

Swift에서 배열, 집합, 딕셔너리는 언제나 저장하고자 하는 키값이나, 타입에 대해 명확하다.

NOTE❗️
Swift의 배열,집합,딕셔너리의 타입은 제네릭으로 구현된다.

콜렉션의 가변성 (Mutablility of Collections)

콜렉션 생성하고 변수에 할당 했을 경우 변경(추가,삭제,변경) 가능하다. 그러나 상수에 할당하면 변경이 불가능 하다.

NOTE❗️
콜렉션을 변경할 필요가 없는 경우에는 변경 상수로 콜렉션을 만드는 것이 좋다. 그러면 코드에 대해 더 쉽게 추론할 수 있고 Swift 컴파일러가 생성한 콜렉션의 성능을 최적화 할 수 있다.

배열 (Arrays)

배열 (array)은 각각의 값에 순서에 따른 Index를 저장합니다. 그러므로 같은 값이 하나에 배열안에 다른 순서로 저장 될 수 있다.

배열 타입 구문 (Array Type Shorthand Syntax)

배열 선언 Array<타입> , [Element]

빈배열 선언

var someInts: [Int] = []
let emptyArray2 = Array<Int>()
let emptyArray3 = [Int]()
print("someInts is of type [Int] with \(someInts.count) items.")
// Prints "someInts is of type [Int] with 0 items."

기본값 배열 생성 (Creating an Array with a Default Value)

var threeDoubles = Array(repeating: 0.0, count: 3)
// threeDoubles is of type [Double], and equals [0.0, 0.0, 0.0]

배열 접근과 수정 (Accessing and Modifying an Array

numsArray.count
numsArray.isEmpty

numsArray.contains(1)  //파라미터로 값을 전달
numsArray.contains(8)

numsArray.randomElement()

numsArray.swapAt(0, 1)

numsArray = [1, 2, 3, 4, 5]   // 배열 리터럴
stringArray = ["Apple", "Swift", "iOS", "Hello"]


// [] 서브스크립트 문법(대괄호를 이용한 특별한 함수)
stringArray[0]
stringArray[1]
stringArray[2]
stringArray[3]

stringArray[1] = "Steve"
print(stringArray)

stringArray.first   // 리턴값 String?  ====> 빈 배열이라면 nil 리턴
stringArray.last

// 배열의 시작 인덱스
stringArray.startIndex

stringArray.endIndex
//stringArray.endIndex.advanced(by: -1)

stringArray[stringArray.startIndex]
stringArray[stringArray.endIndex - 1]
//stringArray[stringArray.index(before: stringArray.endIndex)]
//stringArray.index(<#T##i: Int##Int#>, offsetBy: <#T##Int#>)

stringArray.firstIndex(of: "iOS")     // 앞에서 부터 찾았을때 "iOS"는 배열의 (앞에서부터) 몇번째
stringArray.lastIndex(of: "iOS")     // 뒤에서 부터 찾았을때 "iOS"는 배열의 (앞에서부터) 몇번째

if let index = stringArray.firstIndex(of: "iOS") {
    print(index)
}

var alphabet = ["A", "B", "C", "D", "E", "F", "G"]


// 앞 또는 중간에 삽입하기
alphabet.insert("c", at: 4)

//alphabet.insert("c", at: alphabet.endIndex)

alphabet.insert(contentsOf: ["a","b","c"], at: 0)

//alphabet.insert(contentsOf: ["a","b","c"], at: alphabet.endIndex)

---

• 교체하기 (replace)

---

alphabet = ["A", "B", "C", "D", "E", "F", "G"]

// 요소 교체하기
alphabet[0] = "a"

// 범위를 교체하기
alphabet[0...2] = ["x", "y", "z"]

// 원하는 범위 삭제
alphabet[0...1] = []
alphabet

// 교체하기 함수 문법
alphabet.replaceSubrange(0...2, with: ["a", "b", "c"])

---

• 추가하기 (append)

---

alphabet = ["A", "B", "C", "D", "E", "F", "G"]
alphabet += ["H"]

// 추가하기 함수 문법
alphabet.append("H")   // 맨 마지막에 추가하는 것
alphabet.append(contentsOf: ["H", "I"])

//alphabet.append(7)   // 에러 ===> 동일한 자료형만 저장가능함

---

• 삭제(제거)하기 (remove)

---

alphabet = ["A", "B", "C", "D", "E", "F", "G"]

// 서브스크립트 문법으로 삭제
alphabet[0...2] = []   //빈배열 전달하면 해당 범위가 삭제
// 요소 한개 삭제
alphabet.remove(at: 2)  // 삭제하고, 삭제된 요소 리턴
//alphabet.remove(at: 8)    // 잘못된 인덱스 전달 ====> 에러발생
// 요소 범위 삭제
alphabet.removeSubrange(0...2)

alphabet = ["A", "B", "C", "D", "E", "F", "G"]

alphabet.removeFirst()   // 맨 앞에 요소 삭제하고 삭제된 요소 리턴 (리턴형 String)
alphabet.removeFirst(2)   // 앞의 두개의 요소 삭제 ===> 리턴은 안함

alphabet.removeLast()   // 맨 뒤에 요소 삭제하고 삭제된 요소 리턴 (리턴형 String)
alphabet.removeLast(2)

// 배열이 비어있는지도 잘 확인해보고 삭제(제거)해야함 =======> 에러
// alphabet.removeFirst()    // 리턴형 String
// alphabet.removeLast()     // 리턴형 String
// 배열의 요소 모두 삭제(제거)
alphabet.removeAll()
alphabet.removeAll(keepingCapacity: true)  // 저장공간을 일단은 보관해 둠. (안의 데이터만 일단 날림)

---

• 배열의 기타 기능

---

var nums = [1, 2, 3, 1, 4, 5, 2, 6, 7, 5, 0]
// 배열을 정리해보기
// 1) 배열을 직접정렬하는 메서드  sort  (동사)
// 2) 정렬된 새로운 배열을 리턴  sorted (동사ing/동사ed)

nums.sort()   // 배열을 직접 정렬 (오름차순) (배열리턴 하지 않음)
nums.sorted()    //오름차순으로 정렬

nums.reverse()   // 요소를 역순으로 정렬  (배열리턴 하지 않음)
nums.reversed()

nums.sorted().reversed()
// 새로운 배열은 생성하지 않고, 배열의 메모리는 공유하면서 역순으로 열거할 수 있는 형식을 리턴
// 배열을 랜덤으로 섞기
//nums.shuffle()    // 요소의 순서 랜덤으로 직접 바꾸기
//nums.shuffled()

---

• 배열의 비교

---

let a = ["A", "B", "C"]
let b = ["a", "b", "c"]

// 두 배열을 비교해보기

a == b   // false
a != b   // true

// 개별요소 비교, 저장순서도 비교 하기 때문에

---

• 활용

---

// 특정 요소 한개 삭제하기
// ===> 직접 삭제는 불가 (1) 인덱스 찾아서, (2) 인덱스에 해당하는 요소 지우기
var puppy1 = ["p", "u", "p", "p", "y"]

if let lastIndexOfP = puppy1.lastIndex(of: "p") {
    puppy1.remove(at: lastIndexOfP)
}

if !nums.isEmpty {            // "!"(true ====> false)  (false ====> true)
    print("\(nums.count) element(s)")
} else {
    print("empty array")
}

// 배열의 배열 접근

var data = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

data[0][2]

---

• 반복문과의 결합

---

// 각 요소에 차례대로 접근, 배열과 반복문은 필연적으로 많이 쓰임

for i in nums {
    print(i)
}

//:> enumerate: 영어로 열거하다는 뜻

// enumerated() ===> 열거된 것들을 Named 튜플 형태로 한개씩 전달

// 데이터 바구니이기 때문에,
// 실제 번호표(index)까지 붙여서, 차례대로 하나씩 꺼내서 사용하는 경우가 많을 수 있어서 아래처럼 활용 가능

nums = [10, 11, 12, 13, 14]

// (offset: 0, element: 10)

for tuple in nums.enumerated() {
    //print(tuple)
    print("\(tuple.0) - \(tuple.1)")
}

for (index, word) in nums.enumerated() {      // 바로 뽑아내기
    print("\(index) - \(word)")
}

for (index, value) in nums.enumerated().reversed() {      // 거꾸로 뒤에서 부터
    print("\(index) - \(value)")
}

집합 (Sets)

집합은 배열과 달리 순서와 상관없이 값을 저장한다. 순서가 중요하지 않거나 값이 중복되면 안될 때 사용한다.

집합 타입을 위한 해쉬 값 (Hash Values for Set Types

집합의 값은 Hashable해야 한다. 해쉬 값은 정수로써 모든 객체에 대해 동일하다. Swift의 모든 기본 타입은 기본적으로 Hashable하고 집합의 값 또는 딕셔너리의 키 값으로 사용할 수 있다. 또한 연관값이 없는 열거형 케이스 값은 기본적으로 Hashable 하다.

빈집합 선언

var letters = Set<Character>()
let emptySet: Set<Int> = []
print("letters is of type Set<Character> with \(letters.count) items.")
// Prints "letters is of type Set<Character> with 0 items."

집합 접근과 수정 (Accessing and Modifying a Set)

---

• Set의 기본 기능

---

set.count
set.isEmpty

set.contains(1)
set.randomElement()

---

• 업데이트 (update) - 삽입하기 / 교체하기 / 추가하기

---

// 서브스크립트 관련 문법 없음 ⭐️

// (정식 기능) 함수 문법

set.update(with: 1)     // Int?

set.update(with: 7)     // 새로운 요소가 추가되면 ====> 리턴 nil

Set는 append 함수를 제공하지 않음
append는 순서가 있는 컬렉션의 끝에 추가하는 개념
Set은 순서가 없기 때문에, update를 통해서 추가

---

• 삭제(제거)하기 (remove)

---

var stringSet: Set<String> = ["Apple", "Banana", "City", "Swift"]

// 요소 삭제해 보기
stringSet.remove("Swift")     // "Swift" 삭제한 요소를 리턴
stringSet                     // ["Hello", "Apple"]

// 존재하지 않는 요소를 삭제해보기
stringSet.remove("Steve")       // nil    (에러는 발생하지 않음)

// 전체요소 삭제
stringSet.removeAll()
stringSet.removeAll(keepingCapacity: true)

---

• Set의 정의

---

var a: Set = [1, 2, 3, 4, 5, 6, 7, 8, 9]
var b: Set = [1, 3, 5, 7, 9]
var c: Set = [2, 4, 6, 8, 10]
var d: Set = [1, 7, 5, 9, 3]

---

• Set의 비교

---

a == b
a != b

//Set(정렬되지 않은 컬렉션)은 어짜피 순서는 중요하지 않음
b == d  // 항상 true

---

• 부분집합 / 상위집합 / 서로소

---

a = [1, 2, 3, 4, 5, 6, 7, 8, 9]
b = [1, 3, 5, 7, 9]     // 홀수 모음
c = [2, 4, 6, 8, 10]    // 짝수 모음
d = [1, 7, 5, 9, 3]     // 홀수 모음

// 부분집합 여부를 판단

b.isSubset(of: a)   // true 부분집합 여부
b.isStrictSubset(of: a)   // false 진부분집합 여부

// 상위집합

a.isSuperset(of: b)    // true 상위집합 여부
a.isStrictSuperset(of: b)   // false  진상위집합 여부

// 서로소 여부

d.isDisjoint(with: c)

---

• 합집합

---

a = [1, 2, 3, 4, 5, 6, 7, 8, 9]
b = [1, 3, 5, 7, 9]
c = [2, 4, 6, 8, 10]
d = [1, 7, 5, 9, 3]

var unionSet =  b.union(c)

//b.formUnion(c)      // 원본변경

---

• 교집합

---

var interSet = a.intersection(b)

//a.formIntersection(b)      // 원본변경

---

• 차집합

---

var subSet = a.subtracting(b)

//a.subtract(b)       // 원본변경

---

• 대칭차집합

---

var symmetricSet = a.symmetricDifference(b)

//a.formSymmetricDifference(b)       // 원본변경

---

• 반복문과의 결합

---

let iteratingSet: Set = [1, 2, 3]

for num in iteratingSet {    // 정렬되지 않은 컬렉션이기 때문에, 실행할때마다 순서가 달라짐
    print(num)
}

---

• 기타 유의점

---

var newSet: Set = [1, 2, 3, 4, 5]

var newArray: Array = newSet.sorted()

//:> Set을 정렬하면, 배열로 리턴함 (정렬은 순서가 필요하기 때문)

딕셔너리 (Dictionaries)

딕셔너리는 순서와 상관없이 타입의 키와 값으로 저장한다. 각 값은 딕셔너리 내부에서 유일한 키값과 대치된다. 특정 단어를 찾기위해 사전에서 찾는 방법처럼 식별자를 기준으로 값을 찾는다.

빈 딕셔너리 생성

 var namesOfIntegers = [Int: String]()
let emptyDic1: Dictionary<Int, String> = [:]
let emptyDic2 = Dictionary<Int, String>()
// namesOfIntegers is an empty [Int: String] dictionary

딕셔너리 접근과 수정

---

• 딕셔너리의 기본 기능

---

dic = ["A": "Apple", "B": "Banana", "C": "City"]

dic.count
dic.isEmpty
// contains 함수가 존재하긴 하나, 뒤에서 배울 클로저의 내용을 알아야함
// dic.contains(where: <#T##((key: String, value: String)) throws -> Bool#>)

dic.randomElement()      // Named Tuple 형태로 리턴

---

• 딕셔너리의 각 요소(element)에 대한 접근 (키 값으로 접근)

---

// 배열
var numsArray = [1, 2, 3, 4, 5]
numsArray[0]
//:> 딕셔너리는 기본적으로 서브스크립트[ ]를 이용한 문법을 주로 사용

// 딕셔너리
dic = ["A": "Apple", "B": "Banana", "C": "City"]
dic["A"]        // nil의 가능성 =====> String?(옵셔널)
//print(dic["A"])
//print(dic["Q"])

if let a = dic["A"] {    // 옵셔널 바인딩
    print(a)
} else {
    print("Not found")
}

// 딕셔너리는 값만 따로 검색하는 방법은 제공하지 않음. ⭐️
// 서브스크립트 문법으로 "키"를 전달

// 참고 (잘 사용하지는 않음)
dic["S", default: "Empty"]       // nil이 발생할 확률이 없음
// 자료가 없으면 기본값을 리턴하는 문법  ===> 리턴 String

dic.keys
dic.values

dic.keys.sorted()
dic.values.sorted()

for key in dic.keys.sorted() {     // 오름차순 정렬  ===> "return 배열" 배열이 됨
    print(key)
}

---

• 업데이트 (update) - 삽입하기 / 교체하기 / 추가하기

---

words = [:]

words["A"] = "Apple"   // 애플로 다시 바꾸기
words

words["B"] = "Banana"  // 동일한 키가 없으면 ===> 추가하기
words

words["B"] = "Blue"    // 동일한 키가 있으면 ===> 기존 밸류 덮어쓰기
words
words.updateValue("City", forKey: "C")

// (정식 기능) 함수 문법 (update + insert = upsert)

words.updateValue("City", forKey: "C")   // 새로운 요소가 추가되면 ==> 리턴 nil
words

//words = [:]      // 빈 딕셔너리로 만들기
words = ["A": "A"]   // 전체 교체하기(바꾸기)

//:> 딕셔너리는 append 함수를 제공하지 않음
// append는 순서가 있는 컬렉션의 끝에 추가하는 개념
// 딕셔너리는 순서가 없기 때문에, update를 통해서 추가

---

• 삭제(제거)하기 (remove)

---

dic = ["A": "Apple", "B": "Banana", "C": "City"]

// 요소 삭제해 보기

dic["B"] = nil    // 해당요소 삭제
dic

dic["E"] = nil   // 존재하지 않는 키/값을 삭제 ======> 아무일이 일어나지 않음(에러아님)
dic

// 함수로 삭제해보기
dic.removeValue(forKey: "A")   // 삭제후, 삭제된 값 리턴

dic.removeValue(forKey: "A")   // 다시 삭제해보기 ===> nil리턴

// 전체 삭제하기

dic.removeAll()
dic.removeAll(keepingCapacity: true)

---

• 딕셔너리의 비교

---

let a = ["A": "Apple", "B": "Banana", "C": "City"]
let b = ["A": "Apple", "C": "City", "B": "Banana"]

// 비교 연산자
a == b   // true
// 딕셔너리는 원래 순서가 없기 때문에, 순서는 상관없음
// (순서 상관없이 무조건 true나옴 - Hashable하기 때문에, 순서 상관없이 비교가능)

a != b   // false

---

• 딕셔너리의 활용

---

// 딕셔너리의 중첩 사용
var dict1 = [String: [String]]()        // 딕셔너리 밸류에 "배열"이 들어갈 수도 있다.

dict1["arr1"] = ["A", "B", "C"]
dict1["arr2"] = ["D", "E", "F"]
dict1
//dict1["arr"] = "A"

var dict2 = [String: [String: Int]]()     // 딕셔너리 안에 딕셔너리가 들어갈 수 있다.

dict2["dic1"] = ["name": 1, "age": 2]
dict2["dic2"] = ["name": 2, "age": 4]
dict2

---

• 반복문과의 결합

---

// 딕셔너리 열거해서 프린트 하기

let dict = ["A": "Apple", "B": "Banana", "C": "City"]

// 딕셔너리는 열거하지 않아도, Named 튜플 형태로 하나식 꺼내서 전달
// 순서가 없으므로, 실행마다 순서가 달라짐 ⭐️

// 데이터 바구니이기 때문에,
// 차례대로 하나씩 꺼내서 사용하는 경우가 많을 수 있어서 아래처럼 활용 가능

for (key, value) in dict {
    print("\(key): \(value)")
}

for (key, _) in dict {
    print("Key :", key)
}

for (_, value) in dict {
    print("Value :", value)
}

참고: 앨런 Swift문법 마스터 스쿨 코드자료