[ Swift 기초 문법 ] 컬렉션 (Collection) - Array, Dictionary, Set

 

---

💡 Swift Collection

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

 => 여러 개의 데이터를 한꺼번에 다루는 타입 

/* 📌 컬렉션 / 빈 컬렉션 생성 */
// 1. 배열(array)   - 순서가 있음. 요소 중복 가능  ================================
var array1: Array<Int> = [1, 2, 3]    // 정규 문법
var array2: [Int] = [1, 2, 3]         // 간단 문법
var array3 = [1, 2, 3]               // 리터럴 : 타입에 해당되는 값을 그대로 사용 

// 빈 배열 생성
var array11: [Int] = []
var array22 = Array<Int>()
var array33 = [Int]()  
                                    

// 2. 딕셔너리(dictionary)  - 순서가 없음. 요소는 hashable. 요소 중복 불가 ===========  
var dic1: Dictionary<String, Int> = ["name": 10, "age": 20]     //정규 문법
var dic2: [String: String] = ["name": "홍길동", "age": "20"]      //간단 문법
var dic3 = ["a": "apple", "b": "banana"]                        //딕셔너리 리터럴로 선언

// 빈 딕셔너리 생성
var dic11: Dictionary<String, Int> = [:]      //정규 문법 빈 딕셔너리
var dic22 = Dictionary<String, Int>()         //빈 딕셔너리  
var dic33 = [String: String]()                //간단 문법 빈 딕셔너리


// 3. 집합(Set)  - 순서가 없음. 요소는 hashable. 요소 중복 불가  =================== 
var set1: Set<Int> = [1,3,2,1]       // 출력 : [1, 3, 2] - 정규 문법  
var set2: Set = [2,3,4,5]            // 출력 : [5, 4, 2, 3] - 리터럴로 생성

// 빈 집합 생성
var set1: Set<Int> = []
var set22 = Set<Int>()





/* 동사원형: 컬렉션 직접 변경 & ~ed : 원본은 유지하고 복사본을 변경 후 반환 
.sort()      / .sorted()
.reverse()   / .reversed()
.shuffle()   / .shuffled()
*/

 

 

🔎  1 . 배열(Array)

---

각각의 데이터는 요소(element)라고 부른다. 요소들을 순서대로(index) 저장하기 때문에 중복 가능.

let num1: Array<Int> = [1, 2, 3]    // 정규 문법
let num2: [Int] = [1, 2, 3]         // 간단 문법


// 빈 배열 생성 방법
var array1: [Int] = []

var array2 = Array<Int>()

var array3 = [Int]()


                                      /* 리터럴 : 타입에 해당되는 값을 그대로 사용 */
var array = [1, 2, 3]    // [Int] 타입을 쓰지 않고 리터럴로 직접적인 배열의 값을 생성하고 배열에 할당 


/* 접근 연산자 */
// ✅ .count : 배열의 요소의 개수   다른 언어에서는 .length와 같은 역할  =======================
array.count        //출력 : 3  


// ✅ .isEmpty : 배열의 요소가 비어 있는지 없는지 확인 true/false   ==========================
array.isEmpty     //출력 : false
!array.isEmpty    //출력 : true - !는 결과값을 뒤집는다.


// ✅ .contains() : 해당하는 값을 가지고 있는지 확인하는 함수. 파라미터로 ()안에 값 전달. true/false ===
array.contains(4)    // 출력 : false
                       

// ✅ .randomElement() : 배열에서 요소를 랜덤 추출  =======================================
array.randomElement()    // 출력 : 1, 2, 3 중 랜덤 출력 


// ✅ .swapAt(index, index)  : 해당하는 인덱스의 값을 바꾼다  ==============================
array.swapAt(0, 1)       // 출력 : [2,1,3]


// ✅ .endIndex - 1   : 배열의 마지막 인덱스            =================================
array.endIndex - 1     // 출력 : 3


//옵셔널 타입이라 좀 더 안전한 타입
// ✅ .first  / .last   : 가장 첫번째와 마지막 요소를 추출   ===============================
array.firtst       // 출력 : optional(1)     빈배열일 경우 nil을 리턴하기 때문에 옵셔널타입으로 구현됨 
array.last          // 출력 : optional(3)     따라서 활용할 때에는 옵셔널 바인딩 후 사용해야 함

 

 

 

✅ 배열의 삽입 / 삭제 / 추가 

var num: [Int] = [1, 2, 3]

/* ✅ .insert() : 중간에 삽입 -> 오버헤드 발생 가능  ============================== */
// 배열에 요소 삽입(1)      
num.insert(4, at: 3)    // 출력 : [1, 2, 3, 4]
num.insert(3, at: 1)    // 출력 : [1, 3, 2, 3, 4]

 
// ✅ 배열 요소 삽입(2) - 파라미터로 배열 입력 
num.insert(contentsOf: [5, 6], at: 5)    // 출력 : [1, 3, 2, 3, 4, 5, 6]


/* ✅ 교체    ============================================================== */
// 인덱스로 요소에 접근할 때 [ ]를 사용하는 함수다. 서브스크립트 문법이라고 한다. 
num[0]        // 출력 : 1
num[0] = 7    // [7, 3, 2, 3, 4, 5, 6]

// 서브스크립트로 범위로 교체 
num[0...1] = [2, 2, 2]    // [2, 2, 2, 3, 4, 5, 6]  

// 21번 크드와 동일한 함수 정식 문법
num.replaceSubrange(0...1, with: [1, 2, 3])  // [1, 2, 3, 3, 4, 5, 6]  

// 
num.firstIndex(of: 3)   // 출력 : 2   앞에서부터 찾았을 때 해당 값이 몇번째 인덱스에 있는지
num.lastIndex(of: 3)    // 출력 : 3   뒤에서부터 찾았을 때 해당 값이 몇번째 인덱스에 있는지


/* ✅ .append() : 배열 마지막에 추가 함수 ====================================== */
num.append(7)                    // [1, 2, 3, 3, 4, 5, 6, 7]  
num.append(contentsOf: [8,9])    // [1, 2, 3, 3, 4, 5, 6, 7, 8, 9]  


/* ✅ .remove() : 삭제     ================================================= */
num[0...2] = []            // [3, 4, 5, 6, 7, 8, 9]  
num.remove(at: 1)          // [3, 5, 6, 7, 8, 9]  해당 index 요소 한 개 삭제
num.removeSubrange(0...1)  // [6, 7, 8, 9]        해당 범위 요소 삭제

num.removeFirst()          // [7, 8, 9]    제일 앞에 있는 요소 삭제
num.removeFirst(2)         // [9]          앞에서부터 두번째까지 요소 삭제

num.removeLast()           //              맨 뒤에 있는 요소 삭제 
num.removeLast(2)          //              맨 뒤에서 두번째까지 요소 삭제 
                           // 리턴값은 넌옵셔널 타입이기 때문에 nil일 때 오류 발생!!! 배열이 비었는지 잘 확인 
num.removeAll()                        // 배열 요소 모두 삭제
num.removeAll(keepingCapacity: true)   // 메모리 공간은 보관

 

 

 

✅ 배열의 정렬 

var nums = [9,1,0,2,3,9,2,5,3]

/* ✅ .sort() 메서드 : 오름차순 정렬    ===================================== */
nums.sort()       // 출력 : [0, 1, 2, 2, 3, 3, 5, 9, 9] - 배열 자체를 바꿔서 정렬 (배열 리턴 ❌)
nums.sorted()     // 출력 : [9, 1, 0, 2, 3, 9, 2, 5, 3] 
                  //       원본 배열 자체는 바뀌지 않음. 새로운 변경된 배열을 리턴. 
 
 
/* ✅ .reversed() 메서드 : 뒤에서부터 역순으로 정렬   ======================== */
nums.reverse()    // 출력 : [3, 5, 2, 9, 3, 2, 0, 1, 9]
nums.reversed()   // 출력 : [9, 1, 0, 2, 3, 9, 2, 5, 3]


/* ✅ .shuffle() : 배열 랜덤으로 정렬    =================================== */
nums.shuffle()
nums.shuffled()

 

 

 

✅ 배열의 활용 

var happyArray = ["b","a","n","a","n","a"]

if !happyArray.isEmpty {
    print("해피!!")                 // 출력 : 해피!!
} else {
    print("no return")
}

// 특정 요소를 지우기 위해서는 인덱스를 찾고 해당 인덱스의 요소 지우기
if let happy = happyArray.lastIndex(of: "a") {    //뒤에서부터 첫번째 a에 해당하는 인덱스 : 5
    happyArray.remove(at: happy)                  //인덱스 5번째의 요소 제거
    print(happyArray)              //출력 : ["b", "a", "n", "a", "n"]
} else {
    print("no return2!!!")
}

 

 

 

✅ 배열의 중첩

/* 배열에 배열을 요소로 담을 수 있다   ============ */
var array = [[1,2,3], [4,5,6], [2,3,4]]

array[0][2]     // 출력 : 3  - array 배열의 0번째 인덱스인 [1,2,3]의 인덱스 2의 요소

 

 

 

 

🔎  2. 딕셔너리(Dictionary)

---

딕셔너리의 요소는 key와 value의 쌍으로 이루어진다. 

key 값은 중복 불가!!

순서의 구분이 없기 때문에 key 값은 유일해야 한다. 

value에는 배열의 타입도 중첩으로 사용 가능하다. 

/* 딕셔너리 - 순서가 없기 때문에 출력할 때마다 순서가 달라진다  ============================== */
var dic1: Dictionary<String, Int> = ["name": 10, "age": 20]           //정규 문법
var dic2: Dictionary<String, Int> = [:]                               //정규 문법 빈 딕셔너리
var dic3 = Dictionary<String, Int>()                                   //빈 딕셔너리  

var dic4: [String: String] = ["name": "홍길동", "age": "20"]            //간단 문법
var dic = [String: String]()                                          //간단 문법 빈 딕셔너리

var dic6 = ["a": "apple", "b": "banan": "c": "orange"]                //딕셔너리 리터럴로 선언



/* 접근 연산자   ================================================================= */
// ✅ .count      -> 몇개의 쌍인지
// ✅ .isEmpty    -> true/false
// ✅ .randomeElement()    -> 출력 : (key: "name", value: 10)/ named tuple 형태 / 옵셔널 타입
   if let d = dic1.randomElement(){
   		print(d)            // 출력 : (key: "name", value: 10) , nil일 땐 출력 안됨
   } 

// ✅ .keys       // 출력 : ["name", "age"]
// ✅ .values
// ✅ 배열로 변환
	dic1.keys.sorted()
      
	for keys in temp { print(keys) }  // 반복문으로도 사용 가능


/* key 값으로 요소에 접근   ======================================================== */
dic1["age"]           
print(dic1["age"])    // 출력 :  optional(20) -> 해당 key값이 없을 경우 nil

// 서브스크립트 문법[]도 함수이기 때문에 key값이 파라미터로 전달된다. 
dic1["happy", default: 1]      // 출력 : 1   -> 넌옵셔널타입 Int, 옵셔널 바인딩 필요 없음

 

 

 

 

✅ 딕셔너리의 업데이트 / 삭제

딕셔너리는 순서가 필요 없기 때문에 insert, replace, append를 update가 대신한다. 

/* ✅ .updateValue() : 업데이트   ================================== */
var name = [String: String]()

name.updateValue("name", forKey: "jihyeon")


/* ✅ .removeValue() : 삭제   ================================== */
name["name"] = nil      // 서브스크립트 방법으로 해당 value 값 삭제

name.removeValue(forKey: "name")

name.removeAll()
name.removeAll(keepingCapacity: true)

 

 

 

 

 

🔎  3. 집합(Set)

---

요소값이 중복으로 들어가도 중복 저장 되지 않는다. 

hashing 알고리즘의 사용으로 정렬순서보다 검색 속도가 중요할 때 사용

var nums1: Set<Int> = [1,3,2,1]       // 출력 : [1, 3, 2] - 정규 문법  
var nums2: Set = [2,3,4,5]            // 출력 : [5, 4, 2, 3] - 리터럴로 생성


// 빈 Set 생성
var newSet1: Set<Int> = []
var newSet2 = Set<Int>()

 

 

✅ 집합의 기본기능/  업데이트 / 삭제

배열과 딕셔너리와 같이 서브스크립트 문법은 없음❌

/* 접근 연산자 : 배열과 같이 기본 기능은 같다 */
// ✅ .count =======================
nums1.count        


// ✅ .isEmpty =====================
nums1.isEmpty     


// ✅ .contains() : true/false ====
nums1.contains(4)
                       

// ✅ .randomElement() ============
nums1.randomElement()



/* 업데이트 : 삽입 & 추가 & 교체 ======= */
// ✅ . update(with: )
nums1.update(with: 1)  // 출력 : [1, 3, 2] - 요소 1은 이미 있기 때문에 변함이 없음
nums1.update(with: 7)  // 출력 : [1, 3, 2, 7]

// ✅ . remove()
nums1.remove(1)        // 출력 : [3, 2, 7]
nums1.remove(9)        // 없는 요소를 삭제하기 때문에 nil return 
                       // 삭제하려는 요소가 없을 수도 있기 때문에 반환값은 옵셔널 타입이다.
nums1.removeAll()      // 출력 : []

 

22번 코드를 좀 더 자세하게 살펴보면,

새로운 요소를 추가하는 코드 실행 시 nil을 반환하는 것을 볼 수 있다. 

 

update할 때 기존에 있던 값을 반환하고

새로 추가한 값이 업데이트가 된다. 

 

7이라는 요소는 기존에 없었던 요소이기 때문에

nil을 return하고 정상적으로 update되었다는 의미이다. 

 

 

 

✅ Set의 정렬은 배열로 return

var setNums: Set = [2,5,3,8,1]
var arrayNums: Array = setNums.sorted() //출력 : [1, 2, 3, 5, 8] 
                                        //정렬을 하는 sorted()는 순서가 필요하기 때문에 배열로 반환된다.

 

 

 

🔗 Reference 

- https://www.inflearn.com/course/lecture?courseSlug=%EC%8A%A4%EC%9C%84%ED%94%84%ED%8A%B8-%EB%AC%B8%EB%B2%95-%EB%A7%88%EC%8A%A4%ED%84%B0-%EC%8A%A4%EC%BF%A8&unitId=86570&tab=curriculum