13. Swift 문법 - Collections 1 (Array)

1. Collection Type

Collection Type 이란, 어떤 대상들을 하나로 모아놓은 것을 말합니다. Swift 에서는 3가지 종류의 Collection 을 제공합니다.

- Array
  : 데이터를 순서대로 저장하는 collection

- Dictionary
  : 키와 값을 하나의 쌍으로 저장

- Set
  : 집합 연산을 제공하는 collection

 

Swift 에서는 2가지 타입의 Collection 을 제공합니다.

Foundation Collection	Swift Collection
예전부터 사용하던 Collection class	Swift 에서 새로 도입된 Collection struct(구조체)
참조형식으로 쓰일 때 주로 사용	스위프트에서 주로 (일반적으로) 사용
NSArray, NSDictionary, NSSet	Array, Dictionary, Set
객체 형식의 데이터만 저장이 가능	객체 형식, 값 형식 데이터 모두 저장 가능
하나의 Collection 에 여러 자료형의 값을 같이 저장 가능	하나의 Collection 에는 동일한 자료형만 저장 가능
가변 collection 과 불변 collection 을 따로 제공 (가변: NSMutableArray, NSMutableDictionary, NSMutableSet)  (불변: NSArray, NSDictionary, NSSet) *** collection 의 가변성은 요소의 가변성에 영향을 주지 않음	키워드(let, var) 를 통해 가변, 불변을 구분

 
Swift 에서는 Collection 을 관리할 때 메모리 최적화를 위해 반드시 복사가 필요한 경우에만 복사를 수행합니다. (Copy-on-write 최적화)
즉, Collection 이 변경되지 않는다면 기존 메모리를 그대로 사용하고 변경이 되는 경우에만 새로운 메모리의 Collection 을 생성하게 됩니다. 이런 작업은 Compiler 가 알아서 수행합니다.

 

2. Array

Array (배열)은 하나 이상의 데이터를 연속해서 저장하는 컬렉션입니다. 배열의 특징은 다음과 같습니다.

 

- 배열은 항상 저장된 순서대로 정렬되어 있음 (Ordered Collection)

- 배열에 저장하는 데이터의 타입은 항상 동일해야 함 (Single Type)

- 값은 중복되어 저장할 수 있음

- 요소에 접근할 때는 인덱스를 사용 (0-based Index)

- 중간 요소가 삭제되는 경우 뒤에 요소들이 앞으로 이동하며 자동으로 인덱스 재정렬

- 배열 중간에 요소를 추가하는 경우 오버헤드가 발생할 수 있으니 가능하면 맨 뒤에 삽입

 

배열을 생성하는 방법은 리터럴과 타입 지정이 있습니다.

// Array Literal
// 문법
// [elem, elem, ...]
let n = [1, 2, 3]

// Array Type
// 문법
// Array<T>
// [T] (단축형)
let strArray: Array<String>
let strArray2: [String]

배열의 기본적인 사용법을 살펴보면 다음과 같습니다.

// Array Basics

// - Creating an Array (배열 생성)
let numbers = [1, 2, 3]
// 빈 배열을 만들 떄는 자료형을 직접 지정해야 함
let emptyArray: [Int] = []

let emptyArray2 = Array<Int>()
let emptyArray3 = [Int]()

// 초기 값 지정해서 배열 생성하기
let zeroArray = [Int](repeating: 0, count: 10)
// 결과: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

// - Inspecting an Array
numbers.count       // 결과: 3
numbers.count == 0  // 결과: false

numbers.isEmpty     // 결과: false
emptyArray.isEmpty  // 결과: true

// - Accessing Elements
// 올바른 인덱스와 범위를 사용하는 것이 중요!
let fruits = ["Apple", "Banana", "Melon"]
fruits[0]      // 결과: "Apple"
fruits[2]      // 결과: "Melon"
fruits[0...1]  // 결과: ["Apple", "Banana"]

fruits[fruits.startIndex]                      // 결과: "Apple"
fruits[fruits.index(before: fruits.endIndex)]  // 결과: "Melon"

fruits.first  // 결과: "Apple"
fruits.last   // 결과: "Melon"

emptyArray.first  // 결과: nil
emptyArray.last   // 결과: nil

// emptyArray[0] - 에러 발생
// index 보다는 속성을 사용하여 접근하는 것이 안전!

배열을 편집하는 방법에 대해 코드로 알아보겠습니다. 먼저 배열에 값을 추가하는 방법입니다.

// Adding Elements
var alphabet = ["A", "B", "C"]

// - 배열 마지막에 값 추가 (동일한 자료형만 저장 가능)
alphabet.append("D")  // 결과: ["A", "B", "C", "D"]

// - 두 개 이상의 요소를 추가할 때
alphabet.append(contentsOf: ["F", "G"])  // 결과: ["A", "B", "C", "D", "F", "G"]

// - 중간에 값 추가
// insert 메소드를 사용하면 오버헤드가 발생하기 때문에 반드시 필요한 경우에만 사용!!
alphabet.insert("E", at: 4)  // 결과: ["A", "B", "C", "D", "E", "F", "G"]

// - 배열 시작 부분에 추가하기
alphabet.insert(contentsOf: ["a", "b", "c"], at: 0)
// 결과: ["a", "b", "c", "A", "B", "C", "D", "E", "F", "G"]


// Update Elements
alphabet[0...2] = ["x", "y", "z"]
alphabet  // 결과: ["x", "y", "z", "A", "B", "C", "D", "E", "F", "G"]

alphabet.replaceSubrange(0...2, with: ["a", "b", "c"])
alphabet  // 결과: ["a", "b", "c", "A", "B", "C", "D", "E", "F", "G"]

alphabet[0...2] = ["z"]
alphabet  // 결과: ["z", "A", "B", "C", "D", "E", "F", "G"]

alphabet[0..<1] = []
alphabet  // 결과: ["A", "B", "C", "D", "E", "F", "G"]

배열에서 값을 삭제하는 방법은 다음과 같습니다.

// Removing Elements
// 인덱스와 배열이 비어있는지 여부 확인 중요!!

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

// - 하나의 요소 삭제하고 삭제한 요소를 반환
alphabet.remove(at: 2)  
alphabet  // 결과: ["A", "B", "D", "E", "F", "G"]

// - 첫번째 요소를 삭제 후 삭제한 요소를 반환
alphabet.removeFirst()
alphabet  // 결과: ["B", "C", "D", "E", "F", "G"]

// - 시작 부분의 2개의 요소를 삭제 (반환되는 값이 앖음)
alphabet.removeFirst(2)
alphabet  // 결과: ["E", "F", "G"]

// - 배열에 저장된 모든 요소를 삭제
alphabet.removeAll()  // 결과: []

// - 조금 더 안전한 메소드 (removeLast 랑 비교 시)
// 배열이 비어있는 경우에는 nil을 리턴함
alphabet.popLast()  // 결과: nil

alphabet = ["A", "B", "C", "D", "E", "F", "G"]
alphabet.popLast()  // 결과: "G"
alphabet            // 결과: ["A", "B", "C", "D", "E", "F"]

// - 특정 범위를 삭제
alphabet.removeSubrange(0...2)
alphabet  // 결과: ["D", "E", "F"]

alphabet[0...2] = []
alphabet  // 결과: []

 

배열을 비교, 검색, 정렬하는 방법을 알아보겠습니다.

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

// 각 배열의 개별 요소와 저장 순서를 비교
a == b  // 결과: false
a != b  // 결과: true

// == 와 동일
a.elementsEqual(b)  // 결과: false

// 직접 비교 코드를 지정할 때
a.elementsEqual(b) { (lhs, rhs) -> Bool in
    return lhs.caseInsensitiveCompare(rhs) == .orderedSame
}
// 결과: true

// Finding Elements
let nums = [1, 2, 3, 1, 4, 5, 2, 6, 7, 5, 0]
nums.contains(1)  // 결과: true
nums.contains(8)  // 결과: false

nums.contains { (n) -> Bool in
    return n % 2 == 0
}
// 결과: true

// 가장 먼저 검색된 요소를 반환
nums.first { (n) -> Bool in
    return n % 2 == 0
}
// 결과: 2

// 가장 먼저 검색된 요소의 인덱스를 반환
nums.firstIndex { (n) -> Bool in
    return n % 2 == 0
}
// 결과: 1

// 가장 먼저 검색된 요소의 인덱스를 반환
nums.firstIndex(of: 1)  // 결과: 0

// 가장 마지막에 검색된 요소의 인덱스를 반환
nums.lastIndex(of: 1)  // 결과: 3

// Sorting on Array
// 정렬된 새로운 배열을 리턴하는 메소드 sorted
nums.sorted()  // 결과: [0, 1, 1, 2, 2, 3, 4, 5, 5, 6, 7]
nums           // 결과: [1, 2, 3, 1, 4, 5, 2, 6, 7, 5, 0]

// 내림 차순 정렬
nums.sorted { (a, b) -> Bool in
    return a > b
}
nums.sorted().reversed()
[Int](nums.sorted().reversed())

// 배열을 직접 정렬하는 메소드 sort
var mutableNums = nums
mutableNums.sort()     // 결과: [0, 1, 1, 2, 2, 3, 4, 5, 5, 6, 7]
mutableNums.reverse()  // 결과: [7, 6, 5, 5, 4, 3, 2, 2, 1, 1, 0]

// 특정 위치 요소 교체
mutableNums.swapAt(0, 1)  // 결과: [6, 7, 5, 5, 4, 3, 2, 2, 1, 1, 0]

// 요소의 순서를 랜덤으로 변경
mutableNums.shuffle()  // 결과: [2, 1, 1, 0, 5, 2, 4, 7, 5, 3, 6] (실행할 때마다 변경)