Swift 기초 문법 - Collection Type(Array, Set, Dictionary)

 

 

 

 

Collection Type

 

 

💡 Collection Type

 

Array

 

- 동일한 타입의 요소들을 저장하는 순서가 있는 컬렉션

- 특정 요소의 인덱스를 사용하여 접근하고 수정할 수 있으며 배열의 크기는 동적으로 조절 됨

- 초기 선언 시(초기화할 때) 배열의 길이를 미리 지정하지 않아도 됨

 

 

🌟 자주 사용하는 메서드 🌟

 

 타입 추론으로 생성 

var array1 = [1, 2, 3]
var array2 = [] // error! 타입 추론으론 빈 배열 생성 불가

 

 

 타입 Annotation으로 생성 

var array3: [Int] = [1, 2, 3]
var array4: [Int] = [] //빈 배열 생성

 

 

 생성자로 생성 

var array5 = Array<Int>()
var array6 = [Int]()
var array7 = [Int](repeating: 0, count: 10)   //생성과 동시에 10개 Element 생성 및 0으로 초기화

 

 

 배열 갯수 확인 

var array1 = [1, 2, 3]

let count: Int = array1.count      // 배열 갯수 확인 : 3
let isEmpty: Bool = array1.isEmpty // 배열 비었는지 확인 : false

 

 

 배열 요소에 접근 

var array1 = [1, 2, 3]

// 1. Subscript로 접근하기
array1[0]        // 1
array1[1]        // 2
 
// 2. 범위로 접근하기
array1[0...1]    // [1, 2]
 
// 3. 속성으로 접근하기
array1.first     // Optional(1)
array1.last      // Optional(3)

 

 

 배열에 요소 추가 

// 1. append : 끝에 추가
var array1 = [1, 2, 3]
array1.append(4)                            // [1, 2, 3, 4]
array1.append(contentsOf: [5, 6, 7])        // [1, 2, 3, 4, 5, 6, 7]
 
// 2. inset : 중간에 추가
var array2 = [1, 2, 3]
array2.insert(0, at: 0)                      // [0, 1, 2, 3]
array2.insert(contentsOf: [10, 100], at: 2)  // [0, 1, 10, 100, 2, 3 ]

 

 

 배열에 요소 변경 

// 1. Subscript로 변경하기
var array1 = [1, 2, 3]
array1[0] = 10                       // [10, 2, 3]
array1[0...2] = [10, 20, 30]         // [10, 20, 30]
array1[0...2] = [0]                  // [0]
array1[0..<1] = []                   // []
 
// 2. replaceSubrange로 바꾸기 (범위 변경 시)
var array2 = [1, 2, 3]
array2.replaceSubrange(0...2, with: [10, 20, 30])     // [10, 20, 30]
array2.replaceSubrange(0...2, with: [0])              // [0]
array2.replaceSubrange(0..<1, with: [])               // []

 

 

 배열에 요소 삭제

// 1. 일반적인 삭제하기
var array1 = [1, 2, 3, 4, 5, 6, 7, 8, 9]
 
array1.remove(at: 2)             // [1, 2, 4, 5, 6, 7, 8, 9] 
array1.removeFirst()             // [2, 4, 5, 6, 7, 8, 9]   
array1.removeFirst(2)            // [5, 6, 7, 8, 9]
array1.removeLast()              // [5, 6, 7, 8]
array1.popLast()                 // [5, 6, 7] 
array1.removeLast(2)             // [5]
array1.removeAll()               // [] 
 
// 2. 특정 범위 삭제하기
var array2 = [1, 2, 3, 4, 5, 6, 7, 8, 9]
 
array2.removeSubrange(1...3)     // [1, 5, 6, 7, 8, 9] 
array2[0..<2] = []               // [6, 7, 8, 9]

 

 

 배열 비교 

var array1 = [1, 2, 3]
var array2 = [1, 2, 3]
var array3 = [1, 2, 3, 4, 5,]
 
array1 == array2                    //true
array1.elementsEqual(array3)        //false

 

 

 배열 정렬 

let array1 = [1, 5, 3, 8, 6, 10, 14]
 
// 1. sort : 배열을 직접 "오름차순"으로 정렬
array1.sort()                                         // [1, 3, 5, 6, 8, 10, 14]
 
// 1-1. sort + 클로저 : 배열을 직접 "내림차순"으로 정렬
array1.sort(by: >)                                    // [14, 10, 8, 6, 5, 3, 1]
 
 
// 2. sorted : 원본은 그대로 두고, "오름차순"으로 정렬된 새로운 배열을 만들어 리턴
let sortedArray = array1.sorted()                     // [1, 3, 5, 6, 8, 10, 14]
 
// 2-1. sorted + 클로저 : 원본은 그대로 두고, "내림차순"으로 정렬된 새로운 배열을 만들어 리턴
let sortedArray2 = array1.sorted(by: >)

 

 

---

 

 

Set

 

- 집합을 생각하면 됨

- 순서를 정의하지 않고 동일한 타입의 값을 저장

- 항목의 순서가 중요하지 않거나, 항목이 한 번만 표시되도록 해야 하는 경우 배열 대신 집합을 사용할 수 있음

- 세트 안에 있는 모든 값은 고유(unique)해야하므로 중복을 허용하지 않음

 

 

 set 생성 

<주의> Set은 타입추론으로 생성 불가 (선언이 배열과 동일하게 때문)
var set1 = [1, 5, 3, 2, 1] // Set이 아닌 배열로 추론됨
 
// 1. 타입 Annotation으로 생성하기
var set2: Set<Int> = []
 
// 2. 생성자로 생성하기
var set3 = Set<Int>()

 

 

 set 갯수 확인 

var set1: Set<Int> = [1, 2, 5, 0]
 
let count: Int = set1.count // Set 갯수 확인 : 4
let isEmpty: Bool = set1.isEmpty // Set 비었는지 확인 : false

 

 

 set 요소 확인 

var set1: Set<Int> = [1, 2, 5, 0]
 
set1.contains(1) // true
set1.contains(10) // false

 

 

 set에 값 추가 

var set1: Set<Int> = [1, 2, 5, 0]
 
// 1. insert : 값을 추가하고, 추가된 결과를 튜플로 리턴 (중복이면 false, 추가된 값)
set1.insert(1) // (false, 1)
set1.insert(10) // (true, 10)
 
// 2. update : 값이 존재하지 않으면 추가 후 nil 리턴, 존재할 경우 덮어쓰기 후 덮어쓰기 전 값 리턴
set1.update(with: 1) // Optioanl(1)
set1.update(with: 120) // nil

 

 

 set 요소 삭제 

var set1: Set<Int> = [1, 2, 5, 0]
 
// 1. remove() : 한 가지 요소 삭제할 때 사용, 삭제 후 삭제한 값 return (없는 요소 삭제 시 nil 리턴)
set1.remove(1) // Optional(1)
set1.remove(10) // nil
 
// 2. removeAll() : 전체 요소 삭제
set1.removeAll()

 

 

 set 비교 

// 연산자로 비교 
var set1: Set<Int> = [1, 2, 5, 0]
var set2: Set<Int> = [0, 2, 1, 5]
var set3: Set<Int> = [1, 3, 11, 20]
 
set1 == set2 // true
set1 == set3 // false


// 포함관계 확인 
// 1. 부분 집합: isSubSet(of: )
var set1: Set<Int> = [1, 2, 5, 0]
var set2: Set<Int> = [1, 2]
 
set1.isSubset(of: set2) // false
set2.isSubset(of: set1) // true


// 2. 상위 집합: isSuperSet(of: )
var set1: Set<Int> = [1, 2, 5, 0]
var set2: Set<Int> = [1, 2]
 
set1.isSuperset(of: set2) // true
set2.isSuperset(of: set1) // false


// 3. 같은 집합 / 서로수 집합 : isDisjoint(with:) 
var set13: Set<Int> = [1, 2, 5, 0]
var set14: Set<Int> = [1, 2, 5, 0]
var set15: Set<Int> = [3, 7, 9, 10]
 
set13.isDisjoint(with: set14) // false (같은 집합 : 모든 요소가 동일한 집합)
set15.isDisjoint(with: set13) // 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]
 
// 1. intersection : 교집합을 새로운 Set으로 리턴
a.intersection(b) // [1, 3, 5, 9, 7]
b.intersection(c) // [] : 겹치는 요소 없음
 
// 2. union : 합집합을 새로운 Set으로 리턴
a.union(b) // [2, 7, 9, 4, 8, 5, 6, 1, 3]
b.union(c) // [9, 3, 10, 4, 1, 8, 7, 2, 6, 5]
 
// 3. sysmetricDifference : 여집합을 새로운 Set으로 리턴
a.symmetricDifference(b) // [4, 8, 6, 2]
b.symmetricDifference(c) // [10, 9, 8, 6, 7, 1, 2, 4, 3, 5]
 
// 4. subtracting : 차집합을 새로운 Set으로 리턴
a.subtracting(b) // [4, 8, 6, 2]
b.subtracting(c) // [9, 1, 3, 5, 7]

 

 

---

 

 

Dictionary

 

- 사전을 생각하면 됨

- 순서를 정의하지 않고 같은 타입의 key와 같은 타입의 value 저장

    → key는 중복될 수 없음

    → 모든 key는 같은 타입이어야 함

    → 모든 value는 같은 타입이어야 함

    → key와 value는 다른 타입이어도 됨

- 실물 사전을 찾는 것처럼 순서가 아닌 식별자 기준으로 값을 찾을 때 Dictionary 사용

 

 

 dictionary에 요소 추가

var dict1 = ["height": 165, "age" : 100]
 
// 1. Subscript로 추가하기
dict1["weight"] = 100 // 해당 Key가 없다면, 추가 (insert)
dict1["height"] = 200 // 해당 Key가 있다면, Value 덮어쓰기 (update)
 
// 2. updateValue(:forKey)
dict1.updateValue(100, forKey: "weight") // 해당 Key가 없다면, 추가하고 nil 리턴 (insert)
dict1.updateValue(200, forKey: "height") // 해당 Key가 있다면, Value 덮어쓰고 덮어쓰기 전 값 리턴 (update)

 

 

 dictionary 요소 삭제 

var dict1 = ["height": 165, "age" : 100]
 
// 1. Subscript로 삭제하기 (nil 대입하기)
dict1["weight"] = nil // 해당 Key가 없어도 에러 안남
dict1["height"] = nil // 해당 Key가 있다면, 해당 Key-Value 삭제
 
// 2. removeValue(forKey:)
dict1.removeValue(forKey: "weight") // 해당 Key가 없다면, nil 반환
dict1.removeValue(forKey: "age") // 해당 Key가 있다면, 해당 Key-Value 삭제 후 삭제된 Value 반환 : Optional(100)
 
// 3. removeAll() : 전체 삭제하기
dict1.removeAll()

 

 

 Key, Value 나열하기 

var dict1 = ["height": 165, "age" : 100]
 
// 1. Key 모두 나열하기
dict1.keys // "height, "age"
dict1.keys.sorted() // "age", "height
 
// 2. Value 모두 나열하기
dict1.values // 165, 100
dict1.values.sorted() // 100, 165

 

 

 dictionary 비교 

var dict1 = ["height": 165, "age" : 100]
var dict2 = ["height": 165, "age" : 100]
var dict3 = ["Height": 165, "Age" : 100]
var dict4 = ["name": "sodeul", "address" : "Suwon"]
 
dict1 == dict2 // true
dict1 == dict3 // false (대소문자 다름)
dict1 == dict4 // false (모든 Key-Vlaue 다름)

 

 

 dictionary 요소 검색 

var dict1 = ["height": 165, "age" : 100]
 
let condition: ((String, Int)) -> Bool = {
    $0.0.contains("h")
}
 
// 1. contains(where:) : 해당 클로저를 만족하는 요소가 하나라도 있을 경우 true
dict1.contains(where: condition) // true
 
// 2. first(where:) : 해당 클로저를 만족하는 첫 번쨰 요소 튜플로 리턴 (딕셔너리는 순서가 없기 때문에, 호출할 때마다 값이 바뀔 수 있음)
dict1.first(where: condition) // Optional((key: "height", value: 165))
 
// 3. filter : 해당 클로저를 만족하는 요소만 모아서 새 딕셔너리로 리턴
dict1.filter(condition) // ["height": 165]

 

 

 

 

 

참고