Swift [Collection Types]

 

Index

1. 배열(Array)

2. 딕셔너리(Dictionary)

3. 집합(Set)

4. 마무리

5. 출처

 

 쉬운 개념들이기 때문에 최소한의 코드만 남기고 다음 포스팅으로 넘어가고자 한다.

(이거보다 힘주어 공부해야할 게 더 많다...)

1. 배열(Array)

1-1 기본문법, 빈배열 생성, 배열의 기본 성질

//정식 문법
var numsArray: Array<Int> = [1,2,3,4,5]
//단축 문법
var numsArray2: [Int] = []

//빈 배열 생성
let emptyArray = Array<Int>()
let emptyArray2 = [Int]()

numsArray.isEmpty //false
numsArray.contains(2) //true
numsArray.contains(7) //false
numsArray.randomElement() //5
numsArray.swapAt(0, 4) //[5, 2, 3, 4, 1]
numsArray //[5, 2, 3, 4, 1]
numsArray.index(1, offsetBy: 2) //3

1-2 배열다루기 (배열 요소/인덱스 접근/삽입 교체 추가 삭제)

//배열 다루기
var stringArray: [String] = ["Apple", "Swift", "iOS", "Hello"]

//1.요소 및 인덱스 접근
stringArray[0] //"Apple"
stringArray.first //"Apple"
stringArray.endIndex //4
stringArray.firstIndex(of: "Swift") //1
stringArray.firstIndex(of: "Swift") //1
stringArray[0...2] // ["Apple", "Swift", "iOS"]

//2.삽입(insert)
stringArray.insert("Fun", at: 1) // ["Apple", "Fun", "Swift", "iOS", "Hello"]
stringArray.insert(contentsOf: ["steve","jobs"], at: 2) //["Apple", "Fun", "steve", "jobs", "Swift", "iOS", "Hello"]

//3.교체(replace)

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

alphabet[0] = "a" //"a"
alphabet[0...2] = ["x", "y", "z"] //["x", "y", "z"]
alphabet.replaceSubrange(0...2, with: ["a","b","c"]) //["a", "b", "c", "D", "E", "F", "G"]

alphabet[0...1] = [] //삭제도 가능
alphabet //["c", "D", "E", "F", "G"]

//4.추가(append)

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

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

alphabet.append("I") //["A", "B", "C", "D", "E", "F", "G", "H", "I"]
alphabet.append(contentsOf: ["J", "K"])
//["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K"]

//5.삭제(remove)

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

//서브스크립트 문법으로 삭제
alphabet[0...1] = []
alphabet //["C", "D", "E", "F", "G"]

alphabet.remove(at: 0) //"C"
alphabet.removeSubrange(0...1) //["F", "G"]

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

alphabet.removeFirst() //"A"
alphabet.removeFirst(2) //["D", "E", "F", "G"]

alphabet.removeLast() //"G"
alphabet.removeFirst(2) //["F"]

alphabet = ["A", "B", "C", "D", "E", "F", "G"] //["A", "B", "C", "D", "E", "F", "G"]
alphabet.removeAll() //
alphabet.removeAll(keepingCapacity: true) // 삭제는 하지만 메모리공간은 남긴다

 

1-3 배열값 정렬(sort) 및 for문과 enumerated()메서드로 배열 요소 출력하기

//6.정렬하고 섞기
var nums = [4,3,2,7,6,1]

// swift에서 -ing와 -ed가 붙는 것들은 원본을 건드리지 않음. sort는 동사그대로니 원본을 건드린다로 알아두기

nums.sort() //[1, 2, 3, 4, 6, 7] //오름차순 정렬(원본값이 변경됨)
print(nums) //"[1, 2, 3, 4, 6, 7]\n"
nums = [4,3,2,7,6,1] //[4, 3, 2, 7, 6, 1]
nums.sorted() //[1, 2, 3, 4, 6, 7] //오름차순 정렬된값 리턴(원본값은 그대로임)
print(nums) //"[4, 3, 2, 7, 6, 1]\n" //원본값 그대로
nums.shuffle() //"[4, 3, 2, 7, 6, 1]\n //랜덤으로 바꾸기

//7.배열 활용해보기(for문과 enumerated()메서드)
nums = [1,2,3,4,5,6,7] //[1, 2, 3, 4, 5, 6, 7]
//for문
for n in nums {
    print(n)
}
//1
//2
//3
//4
//5
//6
//7

//enumerated()메서드 : 각배열 요소의 index까지 함께 알고싶을때 사용. Tuple형태로 보여준다

for(index, number) in nums.enumerated(){
    print("\(index)번째 - \(number)")
}
//0번째 - 1
//1번째 - 2
//2번째 - 3
//3번째 - 4
//4번째 - 5
//5번째 - 6
//6번째 - 7

 

2. 딕셔너리(Dictionary)

데이터를 key - value 쌍으로 관리하는 컬렉션

key값은 유일해야하고 동일 타입쌍의 데이터만 담을 수 있다

key값은 Hashable 해야함 => 어떤 타입이 Hashable하다는건 해당타입의 해시함수의 Input값으로 쓰일 수 있는 타입을 뜻함.  정확한 이해를 위해서는 Hash Table 자료구조에 대한 이해가 필요.

 값의 유일성을 보장하고, 검색속도가 빠르다는 장점.(딕셔너리와 집합(Set)은 배열보다 빠른 검색이 가능)

배열처럼 순서가 정해져 있지 않다.

2-1 기본문법, 빈 딕셔너리 생성, 딕셔너리의 기본 성질

//정식문법
var dic1: Dictionary<Int, String>
//단축문법
var dic: [String: String] = [:]

dic = ["A": "Apple", "B": "Banana", "C": "City"]   // 딕셔너리 리터럴로 생성해서 저장
dic1 = [1: "Apple", 2: "Banana", 3: "City"]

//빈 dicionary 생성
let emptyDic: Dictionary<Int, String>
let emptyDic2 = Dictionary<Int,String>()
let emptyDic3 = [Int: String]()

2-2 딕셔너리 다루기 (요소 key값으로 접근/업데이트/ 삭제)

//딕셔너리 다루기

//1. 요소의 접근: key값으로 접근

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

dic["A"] //Apple

print(dic["A"]) //Optional("Apple"). 앞의 옵셔널체이닝 과정에서 말했듯, Dictionary의 value값은 기본적으로 nil의 가능성을 갖고 있기에(key에 해당하는 value값이 없을 수도 있음) 옵셔널 바인딩이 필요하다.

if let x = dic["A"] {
    print(x) //Apple
} else {
    print("Not Found")
}

dic.keys //Dictionary.Keys(["A", "B", "C"])
dic.values //Dictionary.Values(["Apple", "Banana", "City"])
dic.keys.sorted() //["A", "B", "C"]
dic.values.sorted() //["Apple", "Banana", "City"]


//2.업데이트(update) => 추가, 삽입, 교체를 커버침, 딕셔너리는 순서가 없기에 update로 추가함.
dic["A"] = "AKKK"
dic.updateValue("Dice", forKey: "D") //nil

//3.삭제하기(remove)
dic = ["A": "Apple", "B": "Banana", "C": "City"]
dic["A"] = nil //nil값 대입으로 삭제
dic.removeValue(forKey: "B") //"Banana"
dic.removeAll() //[:]

 

2-3 딕셔너리의 중첩활용

//4. 딕셔너리의 중첩활용

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

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

//딕셔너리는 열거(enumerated())하지 않아도 Named튜플 형태로 하나씩 꺼내 전달함
//배열과 달리 순서가 없기에 실행마다 순서는 달라진다.

for (key, value) in dict1 {
    print("\(key) - \(value)")
    }
//arr2 - ["D", "E", "F"]
//arr1 - ["A", "B", "C"]

//value만 꺼내고 싶을때
for(_, value) in dict1{
    print("value:", value)
}

//value: ["D", "E", "F"]
//value: ["A", "B", "C"]

//2. 딕셔너리 안에 딕셔너리가 들어갈 수 있다.
var dict3 = [String: [String: Int]]()     // 딕셔너리 안에 딕셔너리가 들어갈 수 있다.
dict3["dic1"] = ["name": 1, "age": 2]
dict3["dic2"] = ["name": 2, "age": 4]
dict3
print(dict3["dic1"]!) //["age": 2, "name": 1]

3. Set(세트)

규칙

1. 생김새는 배열과 같기에 타입 선언 필수

2. 수학에서의 집합과 동일하기 때문에 요소는 유일해야함(순서가 존재하지 않음) => Dictionary처럼 Hashable

 

3-1 기본문법, 빈 Set 생성, Set의 기본 성질

// 정식문법
let set2: Set<Int> = [1, 2, 3] //{1, 3, 2}
// 단축문법
let set1: Set = [1, 2, 3] //{2, 1, 3}

// 빈 Set의 생성
let emptySet: Set<Int> = []
let emptySet1 = Set<Int>()

//set의 기본기능(배열을 생각)
var set: Set = [1, 1, 2, 2, 3, 3, 3] //중복이 되지 않는다. {3, 2, 1}
set.count //3
set.isEmpty //false

set.contains(1) //true
set.randomElement() //1

3-2 집합 다루기(업데이트, 삭제)

//업데이트(update) => Set역시 순서가 없기에 update방식 사용

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


//삭제하기
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)

3-3 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]

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)

//상위집합
a.isSuperset(of: b)
a.isStrictSuperset(of: b)

//서로소
b.isDisjoint(with: d)

//합집합/교집합/차집합
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) //b의 원본 변경

//교집합
var interSet = a.intersection(b)
a.formIntersection(b) // a의 원본변경

//차집합
var subSet = a.subtracting(b)
//a.subtract(b)       // 원본변경


//Set과 반복문

let iteratingSet: Set = [1, 2, 3]
for num in iteratingSet {    // 순서X 컬렉션이기에, 실행할때마다 순서가 달라짐
    print(num)
}

4. 마무리

Array과 Dictionary, Set의 차이점이 무엇인지 알고, 각 컬렉션 타입을 어떻게 코드로 다루는지 안다면 pass!

 

5. 출처

Inflearn Allen님의 강의 노트

Swift 공식문서