[Swift] 스위프트 데이터 타입(Swift data type) - 2. 컬렉션 타입(배열(Array), 딕셔너리(Dictionary), 집합(Set))

1. Swift 기본 데이터 타입

   1 - 1. 기본 데이터 타입 (Bool, Int, UInt, Float, Double, Character, String)

   1 - 2. Any, AnyObject, nil, Typealias

[Swift] 스위프트 데이터 타입(Swift data type) - 1.기본 데이터 타입, Any, AnyObject, nil, Typealias

2. 컬렉션 타입 (Array, Dictionary, Set)

 

3. 열거형 타입 (enum)

[Swift] 스위프트 데이터 타입(Swift data type) - 3. 열거형 타입 (enum)

---

2. 컬렉션 타입

개발하다 보면, 서로 연관된 값들을 컬렉션(Colllection)으로 한번에 처리해야 할 일이 많다.

Swift에서 제공하는 컬렉션 타입에 대해 알아보자!

 

[Contents]

• 배열(Array)
• 딕셔너리(Dictionary)
• 집합(Set)

---

🍎 Array

• Array는 멤버가 순서(인덱스)를 가진 리스트 형태의 컬렉션 타입
• 필요에 따라 자동으로 버퍼의 크기 조절 가능하여 요소의 삽입 및 삭제가 자유롭다.
• 중복 가능

💡 배열 초기화 1. 배열 생성 및 초기화하기 

// 빈 Int Array 생성
var 배열이름: Array<타입> = Array<타입>() // 기본
var integers: Array<Int> = Array<Int>() 

// 같은 표현
var integers: Array<Int> = [Int]()     
var integers: Array<Int> = []
var integers: [Int] = Array<Int>()
var integers: [Int] = [Int]()
var integers: [Int] = []
var integers = [Int]()

실제 코드를 짤때는 간단하게 단축 문법을 사용하여 대괄호 사이에 배열의 타입만 넣어주면 간단하게 끝! 😊

let arr1: [Int]
var arr2: [String]

💡 배열 초기화 2. init(repeating:count:) 메소드 사용해서 초기화 하기

반복할 데이터와 횟수를 지정해 주면, 배열에 설정에 맞추어 생성된다.

let arrayRepeating1 = Array(repeating: 1, count: 5)
//[1, 1, 1, 1, 1]
let arrayRepeating2 = Array(repeating: "A", count: 5)
//["A", "A", "A", "A", "A"]

 

💡 배열 초기화 3. 임의의 값을 넣어서 초기화 하기

let arr = Array(1...10)
// [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

 

💡 형식 추론

배열의 값이 있는 경우, 명시하지 않아도 Xcode의 컴파일러(Apple LLVM/Clang)가 알아서 결정해준다.

단, 빈 배열인 경우 타입을 꼭 명시 해주어야 한다.

// 값이 있는 경우 타입을 명시하지 않아도 알아서 결정됩니다.
var arr2 = [1,2,3,4]

// Error: 빈 배열 선언시 타입 명시 필수!!
var arr1 = []

💡 Any 타입 배열 생성 및 초기화

배열에 다른 타입의 값들을 넣고 싶을때는 Any 타입 명시!!

var integers: Any = [1, "2", 1.0]
// Error! - 다른 타입의 값들을 넣을 때는 Any 타입 명시 필수!!
let arr = [1, "이", 3, "사"]

💡 배열 자주 사용하는 메소드

• 배열에 요소 추가하기
  • append(_:) : 끝에 배열 요소 추가
  • insert (_:at:) : 원하는 인덱스에 배열 요소 추가, at: 추가할 위치의 인덱스
  • contentsOf : 값 여러개 추가 > 마지막 인덱스에 추가됨
  • += 연산자로도 추가 가능
• remove(at:) : 배열 요소 삭제 하기
• isEmpty : 빈 배열 확인(true or false)
  • ⭐️ Swift 에서는 빈 배열인지 확인 할 때, array.count == 0 이 구문보단, array.isEmpty를 사용
• count : 배열에 들어있는 값의 개수 검사

var nums = [1,2,3]
var emptyArray: [Int] = []

// .count : 배열에 들어있는 값의 개수 검사 
print(nums.count) //3

// .append : 끝에 배열 요소 추가
nums.append(1) // [1, 2, 3, 1]

// .insert : 원하는 인덱스에 배열 요소 추가
nums.insert(10, at: 2) // [1, 2, 10, 3, 1]
// ERROR - 할당 범위 초과 : 마지막 인덱스 다음까지만 가능
//nums.insert(10, at: 5) 

let newNum = [4, 5, 6]
// += 연산자 사용하여 요소 추가하기
nums += newNum

// .isEmpty : 빈 배열 확인
nums.isEmpty // false
emptyArray.isEmpty // true

// .contentsOf : 값 여러개 추가 > 마지막 인덱스에 추가됨
nums.append(contentsOf: [2, 3]) //[1, 2, 10, 3, 1, 2, 3]
nums.append(contentsOf: 4...6) //[1, 2, 10, 3, 1, 2, 3, 4, 5, 6]
nums.insert(contentsOf: [20, 30], at: 2) //[1, 2, 20, 30, 10, 3, 1, 2, 3, 4, 5, 6]

// contains : 멤버 포함 여부 확인 
print(nums.contains(100)) //"false\n"
print(nums.contains(99)) //"false\n"

// remove : 멤버 삭제 
nums.remove(at: 0) //0번 인덱스값 삭제
nums.removeLast() //마지막삭제
//nums.removeAll() //모두 삭제

//firstindex : 값의 위치 찾기, swift4.2 부터 Index deprecated
//func firstIndex(of element: Element) -> Int? (Optional 타입!!!)
print(nums.firstIndex(of: 10)!)

//옵셔널 바인딩을 이용해서 추출하기
if let location = nums.firstIndex(of: 3){
//    print(nums.firstIndex(of: 100))
    print("위치 : \(location)") //위치 :4
}else{
    print("해당하는 값이 존재하지 않는다")
}

• sort 메소드 사용하여 정렬하기
  • 오름차순 : <
  • 내림차순 : >

var array = [1, 10, 30 , 12, 11]

//오름차순
array.sort(by: <) //[1, 10, 11, 12, 30]

//내림차순
array.sort(by: >) //[30, 12, 11, 10, 1]

 

💡 배열의 요소 접근 관련 메소드

1. Subscript로 접근하기
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)

💡 배열 검색하기 

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

// 1. contains : 해당 값이 배열에 존재하는지 Bool로 리턴
array1.contains(1)                //true
array1.contains(10)               //false
 
// 1-1. contains + 클로저 : 직접 검색 구도를 구현 (예제 : 짝수가 하나라도 있으면 true)
array1.contains { num in          // true
    num % 2 == 0
}
 
// 2. first + 클로저 : 클로저의 조건을 만족하는 가장 첫 번째 요소의 "값"을 리턴, 없다면 nil을 리턴
array1.first { num in             // Optional(2)
    num % 2 == 0
}
 
// 3. firstIndex + 클로저 : 클로저의 조건을 만족하는 가장 첫 번째 요소의 "Index"을 리턴, 없다면 nil을 리턴
array1.firstIndex { num in        // Optional(1)
    num % 2 == 0
}
 
// 4. last + 클로저 : 클로저의 조건을 만족하는 가장 마지막 요소의 "값"을 리턴, 없다면 nil을 리턴
array1.last { num in              // Optional(6)
    num % 2 == 0
}
 
// 5. lastIndex + 클로저 : 클로저의 조건을 만족하는 가장 마지막 요소의 "Index"을 리턴, 없다면 nil을 리턴
array1.lastIndex { num in         // Optional(5)
    num % 2 == 0
}

💡 배열 비교

• == : 배열이 같은지 비교할 때 사용(순서까지 같아야 true 리턴!)

var colorList = ["red", "orange", "yellow"]

//let으로 선언한 배열은 변경 불가!!
let newColor = ["red", "orange", "yellow"]

//배열 비교(순서도 같아야 함!)
let equelArray = (colorList == newColor) //true

 

추가로, 배열 다룰때 가장 중요한 세 가지 map, filter, reduce는 아래에서 확인!!

[Swift] 고차함수 - map, filter, reduce

---

🍎 Dictionary

• 키와 값의 쌍으로 이루어진 컬렉션 타입
• 값은 중복이 가능하나 키는 중복 불가!
• Dictionary는 여러 리터럴 문법을 활용할 수 있어서 표현 방법이 다양하다.

💡 딕셔너리 생성 및 초기화

// var anyDictionary: Dictionary<키타입, 값타입> = [키타입: 값타임]()

// Key가 String 타입이고 Value가 Any인 빈 Dictionary 생성
var anyDictionary: Dictionary<String, Any> = [String: Any]()

// 같은 표현
var anyDictionary: Dictionary <String, Any> = Dictionary<String, Any>()
var anyDictionary: Dictionary <String, Any> = [:]
var anyDictionary: [String: Any] = Dictionary<String, Any>()
var anyDictionary: [String: Any] = [String: Any]()
var anyDictionary: [String: Any] = [:]
var anyDictionary = [String: Any]()

💡 딕셔너리 값 할당, 접근하기

• 딕셔너리의 경우, Subscript([])로 요소에 접근하면 기본 반환값이 Optional 타입!
• 키값이 없는 경우 에러 안나고 nil 반환!

// 키에 해당하는 값 할당
anyDictionary = ["key1": 1000]
anyDictionary["key2"] = "value"
anyDictionary["key3"] = 100
print(anyDictionary)

// 키에 해당하는 값 변경
anyDictionary["someKey"] = "dictionary"
print(anyDictionary)

// 내부 값 접근
print(anyDictionary["key1"]) //Optional(1000)
// 내부에 없는 키로 접근했을 경우 > 오류발생 없이 nil 반환
print(anyDictionary["key4"]) //nil
// 키에 해당하는 값이 없는 경우 default 값을 반환하도록
print(anyDictionary["key4", default : 0]) //0

💡 딕셔너리 값 수정하기

• updateValue(_:forKey:) 메소드 사용
  • 해당 키가 없을수도 있기 때문에, 옵셔널을 리턴한다.
  • 따라서, 해당 키의 이전 값에 엑세스할 때는 옵셔널 바인딩을 사용하는 것이 좋다.

var anyDictionary = ["key1": 1000]
let oldValue = anyDictionary.updateValue(2000, forKey: "key1")

if let lastValue = oldValue, let currentValue = anyDictionary["key1"]{
    print("lastValue : \(lastValue), currentValue : \(currentValue)")
}

// lastValue : 1000, currentValue : 2000

💡 딕셔너리 값 삭제하기

• removeValue(forKey:) 메소드 사용
• 전체 삭제하려면, removeAll() 사용
• nil 값을 설정하여 제거 가능!

// removeValue : 키에 해당하는 값 제거
anyDictionary.removeValue(forKey: "key1")
// nil 을 설정하여 제거
anyDictionary["key2"] = nil

// removeAll() : 전체 삭제하기
anyDictionary.removeAll()

💡 Any 타입으로 생성 가능

// 여러 타입을 저장하는 딕셔너리 생성하기
var dictAny1: [String: Any] = ["name": "Sodeul", "age": 100]
var dictAny2: NSDictionary = ["name": "Sodeul", "age": 100]

💡 딕셔너리 관련 메소드

• .isEmpty : 딕셔너리가 비었는지 확인(true or false)

//isEmpty : 딕셔너리가 비었는지 확인
print(anyDictionary.isEmpty)

💡 딕셔너리에 루프 적용하기

• Swift는 딕셔너리의 키-값 쌍을 반복 처리할 수 있다.
• 물론, 키에 해당하는 값만 반복 처리 가능

let dict: [String : String] = ["A" : "Apple", "B" : "Banana", "C" : "Cherry"]
for (key, value) in dict {
    print("key : \(key), value : \(value)")
}

for key in dict.keys {
    print(key)          // C B A
}

• 딕셔너리는 순서가 없기 때문에 key나 value 값들을 for문으로 출력하면 출력되는 순서가 계속 바뀐다;;
• 특정 순서로 값을 반복하려면 sort() 메서드 사용

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

//swift dictionary 는 정의된 순서가 없음!!
//특정 순서로 값을 반복하려면 sort() 메서드 사용 필요
for key in dict.keys {
    print(key)          
}
// BCA 였다가 ABC 였다가... 출력값이 계속 바뀜

//sort 메소드 사용하여 오름차순 출력
for value in dict.keys.sorted() {
    print(value)        // A B C
}

💡 딕셔너리 to Array

• 아래 코드로 딕셔너리의 키값을 사용하여 Array 타입의 인스턴스 생성이 가능하다!

var dictArray = Array(dict.keys)
print(dictArray)//["A", "B", "C"]

---

🍎 Set

• Set는 순서가 없고, 멤버가 유일한 것을 보장하는 컬렉션 타입입니다. >> 순서가 없으므로 중복 불가!
• 해시를 통해 값을 저장하기 때문에 배열에 비해 검색속도가 빠르고, 저장되는 자료형은 Hashable 프로토콜을 준수해야 함.
• Hashable 프로토콜을 채택한 자료형만 저장 가능하므로 Any타입으로 생성 불가! > NSSet 타입으로 여러 타입 저장 가능
• 집합 연산에 유용

💡 Set 생성 및 초기화

var integerSet: Set<Int> = Set<Int>()

// 1. 타입 Annotation으로 생성하기
var set1: Set<Int> = []
 
// 2. 생성자로 생성하기
var set2 = Set<Int>()

//<주의> 타입추론으로 생성시에는 배열로 인식!!
var set = [1, 5, 3, 2, 1]   // 배열로 인식됨

💡 NSSet타입으로 생성하여 여러 타입 저장하기

var set: NSSet = [1, "s", 1.2] //{"s", 1, 1.2}

💡 Set 메소드

• .isEmpty : set이 비었는지 확인(true or false)
• .count 
• contains(_:) : 특정 항목이 인스턴스에 있는지 확인하는 메소드
• insert(_:) 로 집합에 요소 삽입하는 메소드
• update
• remove
• removeAll

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

set1.contains(1)                    // true
set1.contains(10)                   // false

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

// 삭제
integerSet.remove(100)
integerSet.removeFirst()

💡 Set 집합 연산

• Union(_:) : 두 집합을 합치는 메소드(합집합)
• intersection(_:) : 두 집합에 공통으로 존재하는 요소를 골라내는 메소드(교집합)
• insDisjoint(with:) : 두 집합의 공통 요소가 있는지 확인하는 메소드(서로소)

// Set는 집합 연산에 유용
let setA: Set<Int> = [3, 4, 5]
let setB: Set<Int> = [3, 4, 5, 6, 7]

// 부분집합
setA.isSubset(of: setB)               // true
setB.isSubset(of: setA)               // false

// 합집합
let union: Set<Int> = setA.union(setB)

// 합집합 오름차순 정렬
let sortedUnion: [Int] = union.sorted()

// 교집합
let intersection: Set<Int> = setA.intersection(setB)

// 차집합
let subtracting: Set<Int> = setA.subtracting(setB)

//서로소
let yourFirstBag = Set(["Apple", "Wo"])
let yourSecondBag = Set(["Berry", "Yo"])

let disjoint = yourFirstBag.isDisjoint(with: yourSecondBag) //true

💡 Set 타입 추론

var integerSet: Set<Int> = Set<Int>()

// 타입 추론 >> (type(of: ))
print(type(of: integerSet)) //Set<Int>

// array와 같은 대괄호를 사용하기 때문에 타입 추론을 하게 되면 컴파일러는 array로 타입을 지정한다.
var set = [1,2,3]
print(type(of: set))