[Swift] array, set, dictionary and OOP

2024년 3월 10일 일요일

 

배열, 세트, 딕셔너리, 그리고 객체지향 프로그래밍에 대해 간단히 정리해 봅니다.   

---

#1. Array

#2. Set

#3. Dictionary

#4. OOP (Object-Oriented Programming)

---

 

#1. Array

• 동일한 타입의 요소들을 저장하는 순서가 있는 컬렉션
• 특정 요소의 인덱스를 사용하여 접근하고 수정할 수 있으며, 배열의 크기는 동적으로 조절된다.
• 처음에 선언할 때(초기화할 때) 배열의 길이를 미리 지정하지 않아도 된다.

 

▼  배열 생성하기

// 1. 타입 추론으로 생성하기
var array1 = [1, 2, 3]
var array2 = [] // error! 타입 추론으론 빈 배열 생성 불가
 
 
// 2. 타입 Annotation으로 생성하기
var array3: [Int] = [1, 2, 3]
var array4: [Int] = [] //빈 배열 생성
 
 
// 3. 생성자로 생성하기
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: >)               // [14, 10, 8, 6, 5, 3, 1]

---

 

#2. Set

• 순서를 정의하지 않고 동일한 타입의 값을 저장한다.
• 항목의 순서가 중요하지 않거나 항목이 한 번만 표시되도록 해야 하는 경우 배열 대신 집합을 사용할 수 있다.
• 세트 안에 있는 모든 값은 고유(unique)해야하므로 중복을 허용하지 않는다.

var letters = Set<String>()
// 값 넣기
letters.insert("Classical Music")

// 초기화
letters = []

var favoriteGenres: Set<String> = ["Rock", "Classical", "Hip hop"]

favoriteGenres.isEmpty // false
favoriteGenres.count // 3
favoriteGenres.contains("Rock") // true
favoriteGenres.randomElement() // Hip hop (다른 element가 나올 수 있음)

// 업데이트(update) - 삽입, 교체, 추가
// 배열에서 사용하는 append가 없음
var set1: Set<Int> = [1,1,2,2,3,3]
set1.update(with: 1) // 1 -> 기존에 있던 요소이므로 값을 옵셔널 타입으로 리턴
set1.update(with: 7) // nil -> 기존에 없던 요소이므로 Set에 요소가 추가되고 nil 리턴

set1.remove(1) // 1 -> 삭제된 요소를 리턴
set1 // [2,3,7]

set1.remove(5) // nil -> 존재하지 않는 요소를 삭제했을 때 에러는 발생하지 않고 nil 리턴

// 전체요소 삭제
set1.removeAll()
set1.removeAll(keepingCapacity: true) // 요소는 제거하지만 메모리는 제거하지 않는다

---

 

#3. Dictionary

• 순서를 정의하지 않고 같은 타입의 key와 같은 타입의 value를 저장한다.
  • key는 중복될 수 없다.
  • 모든 key는 같은 타입이어야 한다.
  • 모든 value는 같은 타입이어야 한다.
  • key와 value는 다른 타입이어도 된다.
• 실물 사전을 찾는 것처럼 순서가 아닌 식별자 기준으로 값을 찾을 때 Dictionary를 사용

var namesOfIntegers: [Int: String] = [:]

namesOfIntegers[16] = "sixteen" // 16은 subscript가 아니라 "키"임

// 초기화
namesOfIntegers = [:]

var airports: [String: String] = ["YYZ": "Toronto Pearson", "DUB": "Dublin"]

airports.keys // ["YYZ", "DUB"]
airports.values // ["Toronto Pearson", "Dublin"]

airports.keys.sorted() // ["DUB", "YYZ"]
airports.values.sorted() // ["Dublin", "Toronto Pearson"]

airports["APL"] = "Apple International"
// airports = ["YYZ": "Toronto Pearson", "DUB": "Dublin", "APL": "Apple International"]

// key에 매칭된 value 값 초기화
airports["APL"] = nil

// 딕셔너리 airports에 있는 값의 수
print(airports.count)
// 출력값: 2

// 딕셔너리 airports에 있는 모든 key들
print(airports.keys)
// ["YYZ", "DUB"]

// 해당 key가 있다면 value를 덮어쓰고, 덮어쓰기 전 기존값울 반환
let newYyz = airports.updateValue("Hello YYZ", forKey: "YYZ") 
           
print(newYyz) // 출력값: Optional("Toronto Pearson")
print(airports["YYZ"]) // 출력값: Optional("Hello YYZ")

// 해당 key가 없다면 그 key에 해당하는 value에 값을 추가하고 nil을 반환
let newApl = airports.updateValue("Hello APL", forKey: "APL") 

print(newApl) // 출력값: nil
print(airports["APL"]) // 출력값: Optional("Hello APL")

---

 

 

#4. 객체 지향 프로그래밍 (OOP)

 

• 각 객체와 그 객체들간의 관계를 설계하는 것이 ‘객체 지향 프로그래밍’
• 객체 지향으로 짜여진 프로그램은 여러 객체들의 모임이라고 할 수 있다. 각 객체는 메시지를 주고 받을 수 있으며, 데이터를 처리할 수 있다.

1. 추상화 (Abstraction): 객체 지향 프로그래밍의 핵심 개념 중 하나로, 복잡한 시스템을 단순화하여 중요한 부분을 강조하고 불필요한 부분을 숨기는 것. 클래스나 프로토콜을 통해 데이터와 동작을 추상화하여 필요한 정보만을 노출시키는 것을 포함.
2. 캡슐화 (Encapsulation): 객체의 상태(데이터)와 행동(메서드)를 하나로 묶고, 외부에서의 접근을 제한하여 객체 내부의 세부 구현을 숨기는 것. →  객체 간의 의존성을 줄이고 코드를 보호하며 유지보수성을 높인다.
3. 상속 (Inheritance): 기존 클래스에서 정의된 속성과 메서드를 다른 클래스에서 재사용하는 것. 부모 클래스(상위 클래스, 슈퍼 클래스)의 특성을 자식 클래스(하위 클래스, 서브 클래스)가 물려받아 사용할 수 있다.
4. 다형성 (Polymorphism): 동일한 인터페이스를 가진 다른 클래스들이 각각의 방식으로 동작할 수 있는 능력을 말한다. 오버라이딩과 연관되어 있으며, 서로 다른 클래스들이 동일한 메서드를 호출할 때 각 클래스의 오버라이딩된 메서드가 실행된다.
   1. 오버라이딩 (Overriding): 오버라이딩은 상속 관계에서 부모 클래스의 메서드를 자식 클래스에서 재정의하는 것. 자식 클래스에서 부모 클래스의 동일한 메서드 이름을 사용하여 내용을 변경하거나 확장할 수 있다.
   2. 오버로딩 (Overloading): 오버로딩은 동일한 함수나 메서드 이름을 가지지만 매개변수의 타입, 개수, 순서 등이 다른 여러 버전의 함수를 정의하는 것. 이를 통해 동일한 이름의 다양한 버전의 함수를 사용할 수 있다.

// 추상화 - 이렇게 타입을 정의하는 것
class Account {}
struct Account {}
protocol Account {}

// 캡슐화
class Person {
  private var location = "서울"

  private func doSomething1() {
    print("잠시 휴게소에 들려서 딴짓")
  }
  private func doSomething2() {
    print("한숨 자다 가기")
  }

  func currentLocation() {
    print("====")
    print("현재 위치 :", location)
    print("====")
  }

  func goToBusan() {
    print("서울을 출발합니다.")
    doSomething1()
    doSomething2()
    print("부산에 도착했습니다.")
    location = "부산"
  }
}

// 상속
class Animal {
	var species = "동물"
}

class Dog: Animal {
	var name = "초코"
}

let dog = Dog()
dog.species // 동물
dog.name // 초코


// 다형성

1) 오버라이딩

class Dog {
  func bark() { print("멍멍") }
}
class Poodle: Dog {
  override func bark() { print("왈왈") }
}
class Husky: Dog {
  override func bark() { print("으르르") }
}
class Bulldog: Dog {
  override func bark() {
    super.bark()
    print("bowwow")
  }
}

var dog: Dog = Dog()
dog.bark() // 멍멍

dog = Poodle()
dog.bark() // 왈왈

dog = Husky()
dog.bark() // 으르르

dog = Bulldog()
dog.bark() // 멍멍, bowwow


2) 오버로딩
// 함수를 식별할 땐 단순히 함수 이름을 보고 하는 게 아니라
// 함수 이름, 파라미터(타입, 갯수, Argument Label), 리턴타입을 모두 종합해서 함수를 식별
func printParameter() {
  print("No param")
}

func printParameter(param: Int) {
  print("Input :", param)
}

func printParameter(_ param: Int) -> Int {
  print("Input :", param)
	return param
}

func printParameter(_ param: Int) -> Double {
  print("Input :", param)
	return Double(param)
}

printParameter()
printParameter(param: 1)
let int: Int = printParameter(2)
let double: Double = printParameter(2)